planet.linuxaudio.org

July 23, 2014

GStreamer News

GStreamer OpenMAX IL wrapper plugin 1.2.0 release

The GStreamer project is proud to announce a new release of the GStreamer OpenMAX IL wrapper plugin for the API and ABI-stable 1.x series of the GStreamer multimedia framework.

This plugin wraps available OpenMAX IL components and makes them available as standard GStreamer elements.

Check out the release notes for gst-omx, or download tarballs for gst-omx,

July 23, 2014 10:01 AM

July 20, 2014

linux.autostatic.com » linux.autostatic.com

Wolfson Audio Card for Raspberry Pi

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


Wolfson Audio Card for Raspberry Pi

by Jeremy at July 20, 2014 07:28 PM

July 19, 2014

GStreamer News

GStreamer Core, Plugins and RTSP server 1.4.0 stable release

The GStreamer team is pleased to announce the first release of the stable 1.4 release series. 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.

Binaries for Android, iOS, Mac OS X and Windows are provided together with this release.

The stable 1.4 release series is API and ABI compatible with 1.0.x, 1.2.x and any other 1.x release series in the future. Compared to 1.2.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.

July 19, 2014 05:00 PM

July 17, 2014

Create Digital Music » Linux

24 Knobs, 8 Faders, 16 Buttons, in a Launchpad Form: Launch Control XL

LCX_3quarter

If you’re reading this, and if you care about controllers at all, you’ve probably got one. Now the question is, what are you missing? LaunchControl XL is coming with a whole mess of handy faders and knobs if you’ve got more controls than you can map.

In fact, while it would make an utterly horrid marketing statement, I would dub the slogan of this hardware like this:
Twist knobs without having to constantly press shift and select keys or give up having some faders.

There’s Push, of course, the Ableton-controlling flagship, complete with pressure- and velocity-sensitive grid. There’s AKAI’s former APC, which already has a full complement of faders, encoders, and triggers. Beyond that, we’re talking about various combinations of faders and knobs and triggers in smaller controllers in some combination. For example:

There’s the Novation Launchpad – built like a tank, dirt cheap, just a grid.

There’s the new AKAI APC mini – grid with faders, but no knobs.

There’s the Novation LaunchControl – knobs and some pads, but no faders.

Well, now Novation is back with the LaunchControl XL. It’s knobs, yes – but more knobs. And those knobs get their own colored indicators so you know what they’re controlling. And now it has faders, too. And if it doesn’t sell like hotcakes to everyone, betcha it sells like hotcakes to people who have just a Launchpad.

24 knobs in three rows of eight – which maps conveniently to Live
Multicolored indicators on the knobs for multiple functions
Driver-free (so if you’re using Bitwig or Renoise on Linux, you’re in, too)
16 multi-color buttons give you track focus, mix controls
Works on iOS, too, via Camera Connection Kit

£159.99, coming late August, which is also roughly when we should have one in for review.

More pics and a video… (though I didn’t personally take the musical style in the vid, maybe you will – )

LCXL_withlaunchpad

LCXL

Significantly, whether that video is your cup of tea or not, you can watch an in-depth video here on how they did what they did and download the set to have a look. So, we can all get back to making weird, dancefloor-clearing IDM if we really want to. (Hey, if she or he is still on the dance floor, that may be the one for you. Nerd love. The best.)

The post 24 Knobs, 8 Faders, 16 Buttons, in a Launchpad Form: Launch Control XL appeared first on Create Digital Music.

by Peter Kirn at July 17, 2014 02:56 PM

July 16, 2014

Create Digital Music » Linux

Fork this Chant: GitHub Goes Gregorian, with Open Source Notation

Can I get an Amen break?

Can I get an Amen break? Photo (CC-BY) MyBiggestFan.

Before there was computer code, there was music notation. And before there was forking code or remixing music, there were centuries of variations to the musical code, stored in notation. So it’s fitting that musicians would begin to use GitHub – built originally as a repository for programmers – to store notation.

And that means that in addition to music software and the like, you can find the WWII-era Nova Organi Harmonia organ accompaniments today on GitHub. Adam Wood, Director of Music with St. Stephen’s Episcopal Church in Hurst, Texas, made the addition, with help from a team including Jeff Ostrowski. The GitHub repository is hosted by the Church Music Association of America.

For musicologists and composers alike, Git seems a perfect fit. It makes it easy to track the contributions of any number of people, to file and manage variations, and to keep track of revisions over time.

In this case, the project uses LilyPond, an open source language for scores I’ve praised in the past. Because it’s text-based, that means you can track changes fairly easily. (The same would be true of interchange format MusicXML.)

Indeed, even for an individual musical user, Git could be a useful way to backup materials, access them online, and keep track of revisions – even before you get into the utility of collaboration.

Wood tells Wired that the project, in its infancy, improves the accessibility of the music, and calls GitHub “a much more stable and content-centric approach than warehousing your creative output on a blog or (good lord) on your own computer.”

I’d love to see what others might do with this. After a recent computer crash during a sound check, I’m now keeping my open source tools and materials for live performance on GitHub – more on that migration soon – and using the cloud for proprietary stuff, too.

What tools do you use online? And are you using GitHub (or other similar repository tools) for music? Let us know in comments.

Holy Octocat! There’s Church Music on GitHub Now [Wired]
Nova Organi Harmonia (Organ Accompaniments) [Corpus Christi Watershed blog - who put these online to begin with]
and: https://github.com/CMAA/nova-organi-harmonia

Oh, and do let us know if you come up with a creative use for this repository, too.

The post Fork this Chant: GitHub Goes Gregorian, with Open Source Notation appeared first on Create Digital Music.

by Peter Kirn at July 16, 2014 02:12 PM

July 15, 2014

KXStudio News

DISTRHO New release pack (2014-07-16)

DISTRHO has a new release!

In this release we cleaned up all the plugins, added new ones and removed those that we not considered good enough.
Standalones are no longer available. Highlife was removed as a requested by its authors.

The plugins we added to Ports are:

  • Dexed
  • KlangFalter
  • MVerb
  • Nekobi
  • Obxd
  • PitchedDelay

Additionally we made a new plugin - ProM - a music visualizer as audio plugin based on projectm.

See the plugins and ports sections on DISTRHO's website for screenshots and downloads.
The complete source code is available at https://github.com/DISTRHO/.

by falkTX at July 15, 2014 11:28 PM

Airtime News

Airtime 2.5.1a, minor security release with SSL login

The Broadcaster theme for Newscoop features the integration of Airtime functionality

The Broadcaster theme for Newscoop features the integration of Airtime functionality

This latest security maintenance release, Airtime 2.5.1a is a recommended update for anyone hosting multiple Airtime installations on a single web server. It resolves a critical security issue related to user accounts in Airtime versions 1.6.0 to 2.5.1. However, web servers that are hosting single Airtime installations are not affected.

Another security enhancement in this release is that the administration interface is accessed over https by default, using the method described in the Airtime manual.

In the last minor release, 2.5.1, Airtime improved the reliability of program scheduling with linked shows, and added important bugfixes to station and user timezone handling.

Introducing Airtime's website theme: Broadcaster

Working on new features for The Scope radio station, based at Ryerson University, the Airtime team have been working closely with our Newscoop theme developers to offer a brand new Broadcaster theme. This theme is customised for radio broadcasters and offers Airtime users even more functionality and control for a full online radio experience. The design is based on our popular Newscoop theme, Rockstar, designed by Stephanie Miebach and Christian Kobben. One of the distinctive features of this theme is how it integrates Airtime widgets for weekly schedules and HTML5 audio playback.

 

The Program Grid in Broadcaster features the radio program schedule integrated in the web design

The Program Grid in Broadcaster features the radio program schedule integrated in the web design

You can find out more about Broadcaster:

Airtime 2.5.0 introduced custom logging

The last major release, Airtime 2.5.0, enabled playout logging in the exact format you require and the ability to export that data in CSV or PDF file formats. This is a great feature for professional radio stations who need an organised (digital) paper trail. Advertisers and stakeholders, the DJ community and listeners benefit from having easy access to detailed playout history in formats that are easy to share forward.

Template customisation makes data broadcast ready

The playout history templates can be customized to comply with the broadcasting regulations in your country. This feature also enables you to see playback statistics on each file and show in your library. That data can be edited manually, for corrections or logging of analogue sources.

Airtime is open source broadcast automation, playout and scheduling software.

What's next?

The Airtime team is planning a new tool to connect radio producers and podcasters with radio stations. We'd like to hear your feedback about how we can build this tool to suit your needs. Join the conversation over on our forum and stay tuned in 2014!

  • Don't forget, you can get started with a free trial of Airtime Pro today!

July 15, 2014 06:13 PM

Linux Audio Announcements - laa@linuxaudio.org

Re: [LAA] jackwsmeter 1

From: Guillaume Pellerin <lists@...>
Subject: Re: [LAA] jackwsmeter 1
Date: Jul 15, 5:57 pm 2014

Hi Fred,

Great project!
I get this:

momo@wm22:~/dev/audio/jackwsmeter$ make
CC jackwsmeter-jackwsmeter.o
jackwsmeter.c: In function ‘callback_http’:
jackwsmeter.c:92:3: error: too few arguments to function
‘libwebsockets_serve_http_file’
In file included from jackwsmeter.c:41:0:
/usr/local/include/libwebsockets.h:1077:1: note: declared here
jackwsmeter.c:125:7: error: ‘LWS_CALLBACK_SET_MODE_POLL_FD’ undeclared (first
use in this function)
jackwsmeter.c:125:7: note: each undeclared identifier is reported only once for
each function it appears in
jackwsmeter.c:129:7: error: ‘LWS_CALLBACK_CLEAR_MODE_POLL_FD’ undeclared (first
use in this function)
make: *** [jackwsmeter-jackwsmeter.o] Erreur 1

Cheers,
Guillaume
_______________________________________________
Linux-audio-announce mailing list
Linux-audio-announce@lists.linuxaudio.org
http://lists.linuxaudio.org/listinfo/linux-audio-announce

read more

July 15, 2014 06:00 PM

July 14, 2014

Create Digital Music » Linux

This Free Tool Will Make Any Mobile Browser Into a Multi-Touch Music Controller

Hey, look: a controller, right in your browser, with drag-and-drop editing. No app needed.

Hey, look: a controller, right in your browser, with drag-and-drop editing. No app needed.

Tablet or phone or touch-enabled desktop computer – now it doesn’t matter. A free tool called (for the moment) Nexus lets you make any browser a canvas for music. iOS, Android, Windows, Mac – if the browser is there, your creations become omni-platform.

Shown at the NIME (New Interfaces for Musical Expression) conference in London earlier this month, Nexus is the most complete foundation for this idea seen yet. And since it’s free, it’s open to others to build upon. Right out of the box, it includes basic interface widgets obviously inspired by Lemur (and apps like TouchOSC), so you get faders and knobs and multi-touch arrangements of balls and keyboards and so on. But because it’s all built with Web tech, anyone can create any interface they imagine – with a custom look and feel, and complete with animations. And even in the browser, it uses OSC (Open Sound Control), for flexibility with a range of commercial or custom-built software.

Various demos are featured in a video:

There are a few ways you can work with Nexus, depending on whether you’re an end user or a coder, and which tools you prefer:

1. Drag and drop in a browser. Take any modern browser on desktop or tablet, and you can make your interfaces without coding at all using NxDrop. You can design right on the device, or build on a computer and then send to a mobile gadget.

2. Work with the browser to make sound. You can interface directly with the Web Audio API, meaning you can both create your interface in the browser and use it with sound.

3. Work with libraries like libpd. Another way to integrate interface and sound engine is with tools like libpd, the open source Pure Data engine, which you’ll see in some of the examples.

4. Make interfaces with – and for – Max/MSP. Integration features with Max make it really easy to automatically route messages, and even (in one demo) to use Max to help create the interfaces themselves. That should be welcome for both Max and Max for Live users.

5. Code with JavaScript. It’s clear that Nexus has some potential for non-coders right now, and that more ready-to-use applications will come in time if it attracts interest. In the meanwhile, though, if you do Web technologies as your day job, you’ll be happy as a pig in slop. With just a few lines of JavaScript and HTML5, you can code interfaces directly.

If you do want to give it a go – and you don’t necessarily know about code or Web server operation – there are a couple of useful video tutorials complementing the resources on the official site. These walk you Mac users (works reasonably well on Linux, too, or a Windows *nix setup of some kind) through the Web server bits and gets you up and running:

The advantage of all of this is, controllers can be distributed and shared and operate independent of platform. You could build a synth and let someone run it in a browser or a simple cross-platform app. You could have backups of your live rig run if your iPad breaks or is stolen. You can make mobile music ensembles, or give friends controls over a music creation for jamming. And you know your controllers aren’t tied to a single device or app – they’ll run on whatever you have, making them future-proof.

So far, Nexus is a starting point. It isn’t as polished in look and feel or installation as dedicated apps; you’ll need to do a little DIY (like installing a Web server, though there’s a good tutorial below). It receives data, but doesn’t send it yet, though that’s on the agenda. It seems some graphic designers could give the whole thing a better look, and the drag-and-drop app could be cleaner. And the name needs some work, because it’s too close to Google’s line of mobile devices. (Anyone got any ideas?)

But the technology works beautifully. And on a project-by-project basis, there’s no question it can begin to rival those better-known apps. There’s already a tool called Vox that converts existing TouchOSC layouts for use with Nexus.

There’s quite a lot of work done already – perhaps the most so far along these lines – thanks to the terrific labors of the team Ben Taylor, Jesse Allison, and Yemin Oh (of Louisiana State University).

And there are some interesting projects already. In addition to the video above, some of the LSU folks are working with the idea of laser-cut overlays, adding tactile feedback to tablets. I had a go on their iPads, and the results were impressive – it was still nearly as smooth running my fingers along the iPad, but my fingers could find their way to notes, as you would with frets or keys.

OLYMPUS DIGITAL CAMERA

OLYMPUS DIGITAL CAMERA

OLYMPUS DIGITAL CAMERA

Lindsey Hartman has made a patch remixing of Imogen Heap, showing how Max and Nexus combine (photo via suncanon Instagram):

imogen_nexus

You’ll find all the code in a BSD license, with loads of documentation, on GitHub:

https://github.com/lsu-emdm/nexusUI

No need to dive into the code, though. At NIME, we had people up and running after just a couple of minutes following directions to install a Web server. The main site will take you straight to the getting started tutorials and free downloads:

http://www.nexusosc.com

Academics (or the technically curious), check out the full paper:
Simplified Expressive Mobile Development with NexusUI, NexusUp and NexusDrop

I’m curious to see what you do with this. And I do hope some intrepid Web designers reading this venture in, as well, or let us know if this might interoperate with other browser music projects.

nexusUI

The post This Free Tool Will Make Any Mobile Browser Into a Multi-Touch Music Controller appeared first on Create Digital Music.

by Peter Kirn at July 14, 2014 05:10 PM

Linux Audio Announcements - laa@linuxaudio.org

[LAA] MMA Version 14.07 now available

From: Bob van der Poel <bob@...>
Subject: [LAA] MMA Version 14.07 now available
Date: Jul 14, 7:04 am 2014

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

A stable release, version 14.07, of MMA--Musical MIDI Accompaniment
is available for downloading. In addition to a number of bug fixes
and optimizations, MMA now features:

- Works with Python 2.7 or 3.x
- Plectrum articulate
- MIDI enhancements
- Lots of minor enhancements and bug fixes

Please read the file text/CHANGES-13 for a complete list of changes.

MMA is a accompaniment generator -- it creates midi tracks
for a soloist to perform with. User supplied files contain
pattern selections, chords, and MMA directives. For full details
please visit:

http://www.mellowood.ca/mma/

If you have any questions or comments, please send
them to: bob@mellowood.ca

--
**** Listen to my FREE CD at http://www.mellowood.ca/music/cedars ****
Bob van der Poel ** Wynndel, British Columbia, CANADA **
EMAIL: bob@mellowood.ca
WWW: http://www.mellowood.ca

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


A stable release, version 14.07, of MMA-=
-Musical MIDI Accompaniment
is available for downloading. In addition to=
a number of bug fixes
and optimizations, MMA now features:

=C2=
=A0- Works with Python 2.7 or 3.x

=C2=A0- Plectrum articulate
=C2=A0- MIDI enhancements
=C2=A0- Lots of=
minor enhancements and bug fixes

Please read the file text/CHANGES-=
13 for a complete list of changes.
=C2=A0
MMA is a accompaniment gen=
erator -- it creates midi tracks

for a soloist to perform with. User supplied files contain
pattern selec=
tions, chords, and MMA directives. For full details
please visit:


>=C2=A0=C2=A0 http://www.mellowood=
.ca/mma/



If you have any questions or comments, please send
them to:
=3D"mailto:bob@mellowood.ca">bob@mellowood.ca


--
**** Listen=
to my FREE CD at
=3D"_blank">http://www.mellowood.ca/music/cedars
****

Bob van der Poel ** Wynndel, British Columbia, CANADA **
EMAIL:
=3D"mailto:bob@mellowood.ca" target=3D"_blank">bob@mellowood.ca

WWW:=
=C2=A0 http://www.me=
llowood.ca



--001a113452562ec04a04fe03c3b6--

read more

July 14, 2014 08:00 AM

July 12, 2014

GStreamer News

GStreamer Core, Plugins and RTSP server 1.3.91 release candidate

The GStreamer team is pleased to announce the second release candidate of the stable 1.4 release series. 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.

This release candidate will hopefully shortly be followed by the stable 1.4.0 release if no bigger regressions or bigger issues are detected, and enough testing of the release candidate happened. The new API that was added during the 1.3 release series is not expected to change anymore at this point.

Binaries for Android, iOS, Mac OS X and Windows are provided together with this release.

The stable 1.4 release series is API and ABI compatible with 1.0.x, 1.2.x and any other 1.x release series in the future. Compared to 1.2.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.

July 12, 2014 05:00 PM

July 11, 2014

Hackaday » » digital audio hacks

Party Ready Mini LED Volume Tower

Audio LED Light Tower

There are many very cool visual effects for music, but the best are the kind you build yourself. [Ben's] mini LED volume towers adds some nice bling to your music.

[Ben] was inspired to created this project when he saw a variety of awesome stereo LED towers on YouTube (also referred to as VU meters). We have even featured a few VU meters, one very recently. [Ben] goes over every detail, including how to test your circuit (a very important part of any project). The schematic is deceptively simple. It is based on the LM3914 display driver IC, a simple chained comparator circuit is used to control the volume bar display. All you really need is a 3D printer to make the base, and you can build this awesome tower.

See the completed towers in action after the break. What next? It would be cool to see a larger tower that displays frequency magnitude!


Filed under: digital audio hacks, led hacks

by Nicholas Conn at July 11, 2014 02:01 AM

July 10, 2014

Create Digital Music » open-source

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

FFS CA Convoluting Anode Web

The technique is called convolution, and it uses the power of digital audio theory to combine sounds, as if one is heard “inside” another. And if you’ve heard of it before, you probably associate it with reverb – rightfully so, as you can produce highly detailed, realistic reverberation with the technique. But as celebrated film and TV composer Diego Stocco has shown us previously, you can use that same potential to create sounds that would be otherwise impossible.

And it means you can fuse the sounds of a synthesizer with totally unrelated sounds to create something unlike you’ve ever heard before.

Diego Stocco recently picked up our own monosynth, the MeeBlip anode. Let me be a bit humble here for a moment. The hardware alone really doesn’t do the work. We tried to make a synthesizer that has its own personality, that inspires people. But it’s really a lot to do with the musician who picks up what we designed: Diego makes sounds with anode that sound like him, that don’t sound like just another analog monosynth – gorgeous, droning detuned hums reminiscent of a just-discovered, ancient folk instrument.

The message of what Diego is doing is also that you aren’t restricted to using just the sound of a synth directly. It can be a machine for producing ingredients to use elsewhere. He has an ear for making new percussive creations with this approach, as we’ve seen previously:

Cure Dull Sound and Transform Rhythms By Adventuring Into Convolution [Watch]

With MeeBlip anode, every aspect of the hardware became the starting point for something new – even the sound of turning off the power supply. The deep intonations of anode’s pitched sounds become a dark, pulsating hum. Higher harmonies buzz like bees, the edge of the analog filter turning into odd, otherworldly colors. Others become pitched, but sound like the resonance of some hitherto-uninvented synthetic material from the future. Alien insect swarms? Check. The inside of the lungs of an android? Got it. And yes, you can even work with some of the sounds as reverbs, but different in timbre than what you’d normally here.

You can try out these 15 sounds for free, using any convolution processor that accepts audio files as impulses. On Ableton Live Suite 9, for instance, you can drag and drop these onto the new Convolution Reverb and Convolution Reverb Pro. (The “Pro” version even sees the whole folder as a collection.) The Space Designer Pro in Apple’s Logic works nicely, as well. Freeverb is an open source option and includes VST builds.

For another tutorial on convolution (minus Diego’s clever creative percussion ideas, but a good companion to his work):
How to Use Convolution for Reverb & Effects [Tuts+]

15 sounds is already a lot to start with; I barely got round to writing this article as I got distracted listening to even some semi-boring default drum loops in Ableton Live through them. Feeding rhythmic material works really well, either mixed or completely wet, and that’s just as a starting point. I now also have to hook up my own anode and try capturing impulses; there’s no way not to be inspired by this if you’re addicted to sound design.

Still, I love listening to Diego’s own compositional ideas. Here, he applies this and his other libraries to a music track. Keep listening – it starts minimal, then heats up.

Shameless plug, but because we haven’t mentioned it much: yes, you can now buy a MeeBlip anode anywhere worldwide. They’re also gradually arriving in dealers in North America and Europe.
MeeBlip

But back to not spending money, just enter your email address and you can download all the WAV files (24-bit) for use as impulses. If you don’t want to donate to Diego, just type a ’0′ in the amount form and the fields for your credit card information magically disappear.

FFS // Convoluted Anode Bonus [Free Download]

For more on the whole series, see Diego’s site

I’d be really interested to hear tracks made with this, so get in touch if you use them. And let us know if you discover other convolution techniques or try making some impulses of your own.

The post Transform Sounds for Free, with Tools Made with MeeBlip anode by Diego Stocco appeared first on Create Digital Music.

by Peter Kirn at July 10, 2014 06:12 PM

Music, Programming and a Cat

Laborejo 2 Alpha Video DevLog

Youtube link to watch the videos

Here are five short videos so far.

I think they are good to watch.

So "like" and share and comment all this stuff, please!

Nils

July 10, 2014 05:56 PM

July 09, 2014

blog4

32 years Tron

32 years ago the movie Tron was released. I was on vacation in Japan with my father when we saw posters of that film and we both became hysterical (and that in a country which already made me hysterical) about it and saw it eventually in a cinema either in Tokyo or Kyoto, complete with japanese subtitles.
The soundtrack is by Wendy Carlos who also did the amazing music for Clockwork Orange ten years before, conceptual designer team included Moebius and Syd Mead.
https://www.youtube.com/watch?v=of-IF7R-fgo

by herrsteiner (noreply@blogger.com) at July 09, 2014 02:46 PM

July 08, 2014

Hackaday » » digital audio hacks

MIDI And Vintage FM Synthesis

FM

Before the days when computers could play and record audio that far surpassed the quality of CDs, sound cards were very, very cool. Most audio chips from the 80s, from the Commodore SID is pretty much a synth on a chip, but you can also find similar setups in ancient ISA sound cards. [Emilio] pulled one of these cards with an ADLIB OPL2 chip on it, and used a PIC micro to create his very own FM synthesis synth (IT, translatatron, although Google is screwing up the formatting).

The Yamaha YM3812 chip, otherwise known as the OPL2, was a fairly complete synthesizer in a very tiny package using FM synthesis for some very unique sounds. Once [Emilio] had the PIC sending commands to the sound chip, he added MIDI support, allowing him to play this vintage ‘synth on a chip’ with a keyboard instead of a tracker.

Judging from the video below, it sounds great, and that’s with [Emilio] mashing the keys for a simple demo.


Filed under: classic hacks, digital audio hacks

by Brian Benchoff at July 08, 2014 08:00 PM

Objective Wave

Some Hydrogen features

Long time not posting on the blog, but I have been busy working on a few requirements for Hydrogen, the open-source drum-machine (http://www.hydrogen-music.org).

Two features that are already finished:

I am now in the middle of coding the possibility to have multiple banks per instrument. This would allow to for example have snare drum top and bottom, or drums overhead. Although not finished yet, it’s (kind of) functional and available here: https://github.com/blablack/hydrogen/tree/multi_bank_per_instrument


by blablack at July 08, 2014 05:10 PM

July 07, 2014

Linux Audio Announcements - laa@linuxaudio.org

[LAA] Qtractor 0.6.2 - The Boson Walk Beta is out!

From: Rui Nuno Capela <rncbc@...>
Subject: [LAA] Qtractor 0.6.2 - The Boson Walk Beta is out!
Date: Jul 7, 7:28 pm 2014

So it's summer, they say.

White bright and light pastel colors sparkling on every corner and turn.
Cheesy and silly season, they say. Alas, southerners don't apply. Sorry
about that. Of course I mean the hemisphere, obviously.

For whom it might concern, all anxiety has come to an end.

Indeed.

It all relates back to this last May 3, when a not-so-formal meeting
(aka. workshop) took place while during LAC2014@ZKM-Karlsruhe, where
some pertinent and undeniable requests were dodged and framed to a
"soonish" implementation. And guess what?

Yup, the "soonish" are no more, or so I think.

Qtractor 0.6.2 (boson walk beta) is out!

Perhaps an additional word is due though, about the riddling code-names
that are branding the post-TYOQA beta releases. They have no personal
nor logical sense, I assure you. Perfectly arbitrary now. Everything in
life and the universe is way more unconventional than just a name.

Without further assay.

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.

Release highlights:
* Plugins activation MIDI controller / automation (NEW)
* LV2 UI Idle and Show (>= Qt5) interface support (NEW)
* Discrete editing of automation curve node velues (NEW)
* Missing audio/MIDI files and plugins warning message (NEW)
* MIDI note drawing on tempo-map changes (FIX)
* Automation curves re-adjusted to tempo-map changes (FIX)


Website:
http://qtractor.sourceforge.net

Project page:
http://sourceforge.net/projects/qtractor

Downloads:
http://sourceforge.net/projects/qtractor/files

- source tarball:
http://download.sourceforge.net/qtractor/qtractor-0.6.2.tar.gz

- source package (openSUSE 13.1):

http://download.sourceforge.net/qtractor/qtractor-0.6.2-12.rncbc.suse131.src.rpm

- binary packages (openSUSE 13.1):

http://download.sourceforge.net/qtractor/qtractor-0.6.2-12.rncbc.suse131.i586.rpm

http://download.sourceforge.net/qtractor/qtractor-0.6.2-12.rncbc.suse131.x86_84.rpm

- quick start guide & user manual (severely outdated, see wiki):
http://download.sourceforge.net/qtractor/qtractor-0.5.x-user-manual.pdf

- wiki (help wanted!):
http://sourceforge.net/p/qtractor/wiki/

Weblog (upstream support):
http://www.rncbc.org

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

Change-log:
- Prevent linear and spline automation curve modes for all integer
valued subjects. Also, make sure those values are rounded to the nearest
integer away from zero.
- Fixed save of LV2 Presets for plugins with state files.
- A man page has beed added (making up Gürkan Sengün's work on debian,
thanks).
- When moving plugins by eg. drag-and-dropping across tracks, automation
curves were being left behind, maybe leading to unpredictable mistaken
behavior. Hopefully, not anymore.
- Translations install directory change.
- Automation curves are now automatically re-adjusted to tempo map node
changes (after a ticket by Holger Marzen, thanks).
- Audio/MIDI files or plugins found missing on session load are now
subject for an explicit modal warning message and prompt for an
immediate session backup salvage.
- Changing instrument plugin p [message continues]

read more

July 07, 2014 08:00 PM

rncbc.org

Qtractor 0.6.2 - The Boson Walk Beta is out!

So it's summer, they say.

White bright and light pastel colors sparkling on every corner and turn. Cheesy and silly season, they say. Alas, southerners don't apply. Sorry about that. Of course I mean the hemisphere, obviously.

For whom it might concern, all anxiety has come to an end.

Indeed.

It all relates back to this last May 3, when a not-so-formal meeting (aka. workshop) took place while during LAC2014@ZKM-Karlsruhe, where some pertinent and undeniable requests were dodged and framed to a "soonish" implementation. And guess what?

Yup, the "soonish" are no more, or so I think.

Qtractor 0.6.2 (boson walk beta) is out!

Perhaps an additional word is due though, about the riddling code-names that are branding the post-TYOQA beta releases. They have no personal nor logical sense, I assure you. Perfectly arbitrary now. Everything in life and the universe is way more unconventional than just a name.

Without further assay.

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.

Release highlights:

  • Plugins activation MIDI controller / automation (NEW)
  • LV2 UI Idle and Show (>= Qt5) interface support (NEW)
  • Discrete editing of automation curve node values (NEW)
  • Missing audio/MIDI files and plugins warning message (NEW)
  • MIDI note drawing on tempo-map changes (FIX)
  • Automation curves re-adjusted to tempo-map changes (FIX)

Flattr this

Website:

http://qtractor.sourceforge.net

Project page:

http://sourceforge.net/projects/qtractor

Downloads:

License:

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

Change-log:

  • Prevent linear and spline automation curve modes for all integer valued subjects. Also, make sure those values are rounded to the nearest integer away from zero.
  • Fixed save of LV2 Presets for plugins with state files.
  • A man page has beed added (making up Gürkan Sengün's work on debian, thanks).
  • When moving plugins by eg. drag-and-dropping across tracks, automation curves were being left behind, maybe leading to unpredictable mistaken behavior. Hopefully, not anymore.
  • Translations install directory change.
  • Automation curves are now automatically re-adjusted to tempo map node changes (after a ticket by Holger Marzen, thanks).
  • Audio/MIDI files or plugins found missing on session load are now subject for an explicit modal warning message and prompt for an immediate session backup salvage.
  • Changing instrument plugin programs is now an undo/redo-able command operation, especially for DSSI but also for plugins that come with the LV2 Programs interface extension support (http://kxstudio.sourceforge.net/ns/lv2ext/programs).
  • Drawing, selecting and/or resizing of MIDI note events that extend across tempo/time-signature changes is now made a bit more correctly over the MIDI clip editor (aka. piano-roll), especially regarding to current snap-to-beat setting (after an outstanding ticket by yubatake, thanks).
  • Once again, audio frame/MIDI time drift correction has been slightly refactored to improve MIDI input monitor and timing.
  • Discrete automation curve node values may now be edited via a numerical entry floating spin-box on double-click (as yet another request by AutoStatic aka. Jeremy Jongepier, thanks).
  • Pressing shift/ctrl keyboard modifiers while double-clicking on a plugin list entry now briefly reverses the current View/Options.../Plugins/Editor/Open plugin's editor (GUI) by default option preference.
  • Fixed an old crash lurker when switching output buses that implied a change on the number of audio channels, while on tracks that have (auto-)monitor turned on and at least one active plugin in chain (yet another ticket by AutoStatic aka. Jeremy Jongepier, thanks).
  • MIDI Controller assignment (aka MIDI learn) and/or automation of plugins (de)activation state has been added (as requested by AutoStatic aka. Jeremy Jongepier, thanks).
  • LV2 UI Idle and Show interfaces support added.
  • Allow the build system to include an user specified LDFLAGS (patch by Alessio Treglia aka. quadrispro, thanks).

Enjoy && Have (lots of) fun.

by rncbc at July 07, 2014 05:30 PM

Create Digital Music » open-source

There’s an Unofficial Eurorack Version of MeeBlip anode

MeeBlip-Anode-Eurorack-module-e1404588146822

MeeBlip anode is the monosynth with an analog filter, co-produced with CDM and shipping now worldwide – see meeblip.com – and open source, at GitHub.

Now, much to our surprise when we opened Synthtopia over the weekend, it seems someone has gone ahead and made a Eurorack version. You can’t buy it – this is a one-off – but it’s certainly a clever idea. 20HP wide, and tons of analog ins and outs: gate, envelope controls, inputs for the analog filter and resonance (the only way to external control resonance, actually, as that’s an all-analog control), plus two outs.

They’ve also produced an epic demo video. The sound quality isn’t exactly pristine, but some nice musical ideas and it shows off the patching powers clearly.

Details: Ninstrument, which has some nice things to say about what we’ve done with anode as a synth.

For a better idea of what anode sounds like, listen to our SoundCloud demos:

This isn’t the first time someone has tried something like this. Shawn Rudiman in 2012 took the MeeBlip DIY version and built an extraordinary rack module out of it, making it look like a Roland SH-7, and also including CV ins and outs for everything. Also, awesomely, the video seems like it was shot on VHS in the 80s.

So, for now, anode is available exclusively in a case with MIDI. But I’m curious – how many of you would want a module, and is this what you’d want it to look like?

One note: while MeeBlip is open source, anyone selling a module like this would need to call it something else — and perhaps list it as “MeeBlip-compatible.” That’s just to avoid confusion in identification and support. This is a one-off, though, so we’re happy to see our logo on the front!)

The post There’s an Unofficial Eurorack Version of MeeBlip anode appeared first on Create Digital Music.

by Peter Kirn at July 07, 2014 10:05 AM

July 05, 2014

Linux Audio Announcements - laa@linuxaudio.org

[LAA] jackwsmeter 1

From: Frederic Peters <fpeters@...>
Subject: [LAA] jackwsmeter 1
Date: Jul 5, 6:18 pm 2014

Hello all,

Here is the first release of jackwsmeter.

This is a small utility that gets the signal values of the audio that
flow through JACK ports and make the peak levels available over a
websocket link, it's a clean and efficient way to get an overview of
levels from a serie of jack servers.

It's available in git at http://repo.or.cz/w/jackwsmeter.git, it's
released under the GNU GPL v2 or later.

The release tag is http://repo.or.cz/w/jackwsmeter.git/tag/refs/tags/1


I hope it can be useful to some people.


Cheers,

Fred
_______________________________________________
Linux-audio-announce mailing list
Linux-audio-announce@lists.linuxaudio.org
http://lists.linuxaudio.org/listinfo/linux-audio-announce

read more

July 05, 2014 07:00 PM

[LAA] [LAU] Guitarix 0.30.0 released

From: hermann meyer <brummer-@...>
Subject: [LAA] [LAU] Guitarix 0.30.0 released
Date: Jul 5, 6:18 pm 2014

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

The Guitarix developers proudly present

Guitarix release 0.30.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, support LADSPA plugs, and
now, new, as well LV2 plugs.

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).

Preset could organized in Banks, so a Bank could represent your "show".
If you have any issue with Preset loading/creating/handling, please read
here in our wiki how this stuff work in guitarix. It is straightforward,
and maybe more intuitive then you guess.
http://sourceforge.net/p/guitarix/wiki/EnhancedUI/#creating-presets

This release fix some bugs in our faust based zita-rev1 implementation,
add LV2 support to the guitarix racks and introduce some new plugs, GX
based and as well in the LV2 format.
new plugs:
* GxDetune (gx / LV2)
* Baxandall tonestack(gx)
* GxShimmizita ( LV2)
* GxSwitchedTremolo (LV2)

Please refer to our project page for more information:
http://guitarix.sourceforge.net/

Download Site:
http://sourceforge.net/projects/guitarix/

Forum:
http://guitarix.sourceforge.net/forum/

Please consider visiting our forum or leaving a message on
guitarix-developer@lists.sourceforge.net




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




charset=ISO-8859-1" />
charset=ISO-8859-1">



The Guitarix developers proudly present




Guitarix release 0.30.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, support LADSPA plugs,
and now, new, as well LV2 plugs.



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).



Preset could organized in Banks, so a Bank could represent your
"show".

If you have any issue with Preset loading/creating/handling,
please read here in our wiki how this stuff work in guitarix. It
is straightforward, and maybe more intuitive then you guess.

 http://sourceforge.net/p/guitarix/wiki/EnhancedUI/#creating-presets

 

This release fix some bugs in our faust based zita-rev1
implementation, add LV2 support to the guitarix racks and
introduce some new plugs, GX based and as well in the LV2
format.


new plugs:

July 05, 2014 07:00 PM

Scores of Beauty

Trees, Music and Lilypond

In this post I write about some hierarchical aspects of typesetting music with LilyPond. In a way the elements that form a musical score can be split into pieces that stand in a hierarchical relation. We can make use of this relationship to do interesting stuff such as creating templates and injecting tweaks into a score without touching the music source itself. For my personal use I have developed several tools that help me manage my projects in a structured manner. Recently I made them publicly available and today I’ll start introducing them on this blog. This first post is about the theory behind the implementation which I will describe in following articles.

Compositing Music

Any piece of music can be seen as a tree — I might say: It is alive ;) . But here I want to look at the way of compositing music. Yes, it is not composing, but assembling parts to a complete piece of engraved music. A piece of music can be seen as a tree with branches from several perspectives. If you look at the printed sheet music, you will find a conductor having a full score on his desk (or in his head) while the individual instrumentalist or singer only deals with the necessary information for performing his own part. The conductor is looking at the whole tree, a single particpant is looking at a single branch.

Now what does this have to do with typesetting music? Let us first look at a very simple score and dissect it.

Dissecting Music

If you enter the music in a lilypond file, you will most likely define variables for every participating musician and then use them in a score block to actually engrave the piece. The names for the variables might for example be:

violin = \relative c'' { a4 b c d }
viola = \relative c' { r8 f e4 g f }
cello = \relative c { c2 bes }

\score {
  <<
    \new Staff { \violin }
    \new Staff { \clef "alto" \viola }
    \new Staff { \clef "bass" \cello }
  >>
}

This is an easy case: We just have to combine three staves to compose the full score and use the variables for each part — making this an example of the mentioned situation with a conductor and the instrumentalists. Vocal music adds a level of complexity already: each singer needs not only a melody but also lyrics. The variables might be called sopranoMelody, sopranoLyrics, altoMelody and so on. So the singers are looking at two sub-branches – melody and lyrics – for their own voice. This example exposes a strict naming scheme, marking the hierarchy with an upper case letter in the variable name.

Adhering to such a naming scheme makes it possible to go one step further: Instead of using the music variables directly we can create a (Scheme) function that automatically retrieves the right music variables by selecting them based on a given part of the variable name (you will see later what that means). This way you may not have to type all variables and contexts explicitly. And it will help us circumvent another issue you have to take care of when writing everything explicitly: how to arrange the definition of music variables and score blocks when combining multiple movements to one piece. You can find working solutions on the net, for example in the lilypond-user archive. Rainhold Kainhofers OrchestralLily also deals with this issue, but in this post I want to take a deeper look at the hierarchical aspect behind it.

Planting a tree

The next thing to understand is that we can use paths to address branches in a tree. Thinking as a software engineer we call the branching points nodes and can give them names. If every node in our imagined tree has a name every branch and every leaf can be denoted with a path by listing all nodenames from the root up to the one we’re interested in. Such a path might be massInC/kyrie/soprano/melody to point to the melody to be sung by the sopranos in the kyrie movement of a piece called massInC. Now it is easy to separate the lyrics massInC/kyrie/soprano/lyrics, the music for the alto-singers massInC/kyrie/alto/melody, the other movements massInC/gloria/soprano/melody or another piece massInD/kyrie/soprano/melody. These paths are comparable to a file path or a URL in a web address: http://www.music-server.example/massInC/kyrie/soprano/lyrics.

If the tree structure follows the same naming conventions on all nodes and their child nodes we can apply the same methods to all leaves — or may I say fruits? In the given example of a hypothetical “massInC”, we want to reach the melody of the soprano voice. From the root of the tree the first node is named “massInC”. From this node emerge five branches with nodes named “kyrie”, “gloria”, “credo”, “sanctus” and “agnus-dei”. And each of these five nodes branch into four nodes named “soprano”, “alto”, “tenore” and “basso”, which carry each two fruits named “melody” and “lyrics”.

The way to massInC/kyrie/tenore/melody

The way to massInC/kyrie/tenore/melody (click to enlarge)

Now that we have this concept in place, implemented through the strict naming scheme, let us recall what we’re after: we want to retrieve the right music variables through a function in order to put them in the right place in the score structure. To achieve this we will store the content in a special kind of variable, an “association list” with the name of musicTree.
(Please note: from now on I will use Scheme code which is partly non-trivial. If you don’t understand it in detail please don’t give up on the post. Its main intent is to demonstrate the underlying concepts and not the concrete implementation. I will not try to explain how the code actually works but what it is meant to do.)

We start with writing two functions \putMusic and \getMusic which store and retrieve the content in the musicTree list:

% the main music tree
musicTree = #'()

% function to store music in `musicTree`
putMusic =
#(define-void-function (parser location path content)(string? ly:music?)
   (let ((pl (string->path path)))
     (set! musicTree (tree-set! musicTree pl content))
     ))

% function to get music from `musicTree`
getMusic =
#(define-music-function (parser location path)(string?)
   (let* ((pl (string->path path))
          (content (tree-get musicTree pl)))
     (if (ly:music? content) content (make-music 'SequentialMusic 'void #t))
     ))

To make these commands work, we first have to define the helper functions tree-set! and tree-get. These do the actual work of dealing with the internal list structures.

% set a value in a tree -- based on nested association lists
#(define-public (tree-set! tree path val)
   (if (> (length path) 1)
       (let ((tab (assoc (car path) tree)))
         (if (not (pair? tab))(set! tab '((car path))))
         (assoc-set! tree (car path) (tree-set! (cdr tab) (cdr path) val))
         )
       (assoc-set! tree (car path) val))
   )
% get a value from a tree -- based on nested association lists
#(define-public (tree-get tree path)
   (let ((ret (assoc (car path) tree)))
     (if (pair? ret)
         (if (> (length path) 1)
             (tree-get (cdr ret) (cdr path))
             (cdr ret))
         #f))
   )
% split a string by '/'
#(define-public (string->path str)(string-split str #\/))

With those methods available we have the tools to composite parts from a tree, for example the melody and the lyrics of a vocal staff. We can now write a function \vocalStaff that creates a staff and retrieves the melody and the lyrics from the “fruits” of the branch given as a string. Another function SATBgroup can then call \vocalStaff four times to create a choir score:

% helper function to append strings
stringAppend =
#(define-scheme-function (parser location str1 str2)(string? string?)
   (string-append str1 str2))

% create one vocal staff
vocalStaff =
#(define-music-function (parser location my-path-to-vocal)(string?)
   ; create a unique name for the voice
   (let ((voice-name my-path-to-vocal))
     #{
       <<
         \new Staff \new Voice = #voice-name { \getMusic \stringAppend #my-path-to-vocal "/melody" }
         \new Lyrics \lyricsto #voice-name { \getMusic \stringAppend #my-path-to-vocal "/lyrics" }
       >>
     #}))

% and now combine four vocal staves to a choir group:
% create vocal staffs for Soprano, Alto, Tenore and Basso
SATBGroup =
#(define-music-function (parser location my-path-to-choir)(string?)
   #{
     \new ChoirStaff <<
       { \vocalStaff \stringAppend #my-path-to-choir "/soprano" }
       { \vocalStaff \stringAppend #my-path-to-choir "/alto" }
       { \vocalStaff \stringAppend #my-path-to-choir "/tenore" }
       { \vocalStaff \stringAppend #my-path-to-choir "/basso" }
     >>
   #})

Now, let us use \putMusic to insert some music into the tree:

\putMusic "massInC/kyrie/soprano/melody" \relative c'' { c2 d4 c }
\putMusic "massInC/kyrie/soprano/lyrics" \lyricmode { Ky -- ri -- e }
\putMusic "massInC/kyrie/alto/melody" \relative c'' { r4 g f e }
\putMusic "massInC/kyrie/alto/lyrics" \lyricmode { Ky -- ri -- e }
\putMusic "massInC/kyrie/tenore/melody" \relative c { \clef "G_8" e4 f( g) g }
\putMusic "massInC/kyrie/tenore/lyrics" \lyricmode { Ky -- ri -- e }
\putMusic "massInC/kyrie/basso/melody" \relative c { \clef "bass" c4 g4 c~ c }
\putMusic "massInC/kyrie/basso/lyrics" \lyricmode { Ky -- ri -- e __ }

and engrave it:

\SATBGroup "massInC/kyrie"

trees-and-music.score_

Finally the different movements of the composition might be collected this way:

\score {
  \SATBGroup "massInC/kyrie"
}
\score {
  \SATBGroup "massInC/gloria"
}
\score {
  \SATBGroup "massInC/credo"
}
\score {
  \SATBGroup "massInC/sanctus"
}
\score {
  \SATBGroup "massInC/agnusdei"
}

You can download the whole example here. (The Gloria, Credo, Sanctus and Agnus-Dei movements are to be composed …)

Let us again line up, what is happening here:

  1. \SATBGroup is called with path "massInC/kyrie"
  2. The function (or template) \SATBGroup calls for all four voices (sopranos, altos, tenors, bassos) — replace tenore with soprano, alto or basso respectively
    \vocalStaff "massInC/kyrie/tenore"
  3. \vocalStaff calls
    <<
      \new Staff { \new Voice = "melody" \getMusic "massInC/kyrie/tenore/melody" }
      \new Lyrics \lyricsto "melody" \getMusic "massInC/kyrie/tenore/lyrics"
    >>
    

The hierarchical naming and storing scheme makes it possible to separate content and layout. A function \SATBTwo might create two staves — with sopranos and altos in the upper and tenors and bassos in the lower stave — accessing the music with the same paths.

vocalTwo =
#(define-music-function (parser location my-path-to-vocal-A my-path-to-vocal-B)(string? string?)
   (let (
          (staff-name (string-append my-path-to-vocal-A my-path-to-vocal-B)) ; a name for the staff-context
          (voice-name-A my-path-to-vocal-A) ; a name for the upper voice-context
          (voice-name-B my-path-to-vocal-B) ; a name for the lower voice-context
          )
     #{
       <<
         \new Staff = #staff-name <<
           \new Voice = #voice-name-A { \voiceOne \getMusic \stringAppend #my-path-to-vocal-A "/melody" }
           \new Voice = #voice-name-B { \voiceTwo \getMusic \stringAppend #my-path-to-vocal-B "/melody" }
         >>
         % align lyrics above the staff and voice A
         \new Lyrics \with { alignAboveContext = #staff-name }
         \lyricsto #voice-name-A { \getMusic \stringAppend #my-path-to-vocal-A "/lyrics" }
         % align lyrics below the staff and voice B
         \new Lyrics \with { alignBelowContext = #staff-name }
         \lyricsto #voice-name-B { \getMusic \stringAppend #my-path-to-vocal-B "/lyrics" }
       >>
     #}))

SATBTwo =
#(define-music-function (parser location my-path-to-choir)(string?)
   (let ( ; create paths for the four voices
          (soprano (string-append my-path-to-choir "/soprano"))
          (alto (string-append my-path-to-choir "/alto"))
          (tenore (string-append my-path-to-choir "/tenore"))
          (basso (string-append my-path-to-choir "/basso"))
          )
   #{
     \new ChoirStaff <<
       { \vocalTwo #soprano #alto }
       { \vocalTwo #tenore #basso }
     >>
   #}))

With those functions available, you can decide whether to engrave the previously stored music in four or in two staves.
And to create a score only with the tenors part, you simply call \vocalStaff "massInC/kyrie/tenore".

Conclusion

Now we have a method to write template functions and to store music in a structured hierarchical manner.
Coming back to the image of a tree, the \SATBGroup builds the trunk of the engravement-tree for a whole movement. It delegates to four \vocalStaff calls, which retrieve music from the named branches of the tree.
And from a software developers point of view the tree represents the musical content — or is kind of a model in the sense of the model-view-controller pattern and the templates are the view on the music-model formed by the tree.

With these ideas in mind I developed a template framework to be used with LilyPond edition projects. The original framework can be inspected or downloaded from lalily@GitHub, but I’m gradually making it available in a slightly more generic form at the openLilyLib repository. Of course, the implementation of the functions differ from the demo functions above. The next posts will develop the examples exposed in this article towards the existing implementations and introduce the usage of them. And this will also lead us to the edition-engraver, which is another important step towards separation of content and layout.

by Jan-Peter Voigt at July 05, 2014 09:44 AM

July 04, 2014

PID EINS!

FUDCON + GNOME.Asia Beijing 2014

Thanks to the funding from FUDCON I had the chance to attend and keynote at the combined FUDCON Beijing 2014 and GNOME.Asia 2014 conference in Beijing, China.

My talk was about systemd's present and future, what we achieved and where we are going. In my talk I tried to explain a bit where we are coming from, and how we changed focus from being purely an init system, to more being a set of basic building blocks to build an OS from. Most of the talk I talked about where we still intend to take systemd, which areas we believe should be covered by systemd, and of course, also the always difficult question, on where to draw the line and what clearly is outside of the focus of systemd. The slides of my talk you find online. (No video recording I am aware of, sorry.)

The combined conferences were a lot of fun, and as usual, the best discussions I had in the hallway track, discussing Linux and systemd.

A number of pictures of the conference are now online. Enjoy!

After the conference I stayed for a few more days in Beijing, doing a bit of sightseeing. What a fantastic city! The food was amazing, we tried all kinds of fantastic stuff, from Peking duck, to Bullfrog Sechuan style. Yummy. And one of those days I am sure I will find the time to actually sort my photos and put them online, too.

I am really looking forward to the next FUDCON/GNOME.Asia!

July 04, 2014 04:43 PM

July 02, 2014

Linux Audio Announcements - laa@linuxaudio.org

[LAA] Vee One Suite 0.5.0 - Officially beta now!

From: Rui Nuno Capela <rncbc@...>
Subject: [LAA] Vee One Suite 0.5.0 - Officially beta now!
Date: Jul 2, 7:17 pm 2014

Greetings,

The Vee One Suite of old-school software instruments, primarily slated
for Linux, featuring synthv1 [1], a polyphonic synthesizer, samplv1 [2],
a polyphonic sampler and drumkv1 [3], a drum-kit sampler, are officially
in beta phase now.

Change-log for the new release:
- LV2 UI Idle and Show interfaces support added.
- First attempt to allow a headless stand-alone JACK client application
run mode, without a GUI, with option given as command line argument
(--no-gui).
- A man page has beed added (re. stand-alone JACK client).
- Reverse sample option and parameter knob added. (samplv1 and drumkv1
only).
- Allow the build system to include an user specified LDFLAGS.

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

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


The fine print follows ;)

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

synthv1 0.5.0 released!

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

LV2 URI: http://synthv1.sourceforge.net/lv2

website:
http://synthv1.sourceforge.net
downloads:
http://sourceforge.net/projects/synthv1/files
- source tarball:
http://download.sourceforge.net/synthv1/synthv1-0.5.0.tar.gz
- source package:

http://download.sourceforge.net/synthv1synthv1-0.5.0-17.rncbc.suse131.src.rpm
- binary packages:

http://download.sourceforge.net/synthv1synthv1-0.5.0-17.rncbc.suse131.i586.rpm

http://download.sourceforge.net/synthv1synthv1-0.5.0-17.rncbc.suse131.x86_84.rpm


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

samplv1 0.5.0 released!

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

LV2 URI: http://samplv1.sourceforge.net/lv2

website:
http://samplv1.sourceforge.net
downloads:
http://sourceforge.net/projects/samplv1/files
- source tarball:
http://download.sourceforge.net/samplv1/samplv1-0.5.0.tar.gz
- source package:

http://download.sourceforge.net/samplv1/samplv1-0.5.0-17.rncbc.suse131.src.rpm
- binary packages:

http://download.sourceforge.net/samplv1/samplv1-0.5.0-17.rncbc.suse131.i586.rpm

http://download.sourceforge.net/samplv1/samplv1-0.5.0-17.rncbc.suse131.x86_84.rpm


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

drumkv1 0.5.0 released!

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

LV2 URI: http://drumkv1.sourceforge.net/lv2

website:
http://drumkv1.sourceforge.net
downloads:
http://sourceforge.net/projects/drumkv1/files
- source tarball:
http://download.sourceforge.net/drumkv1/drumkv1-0.5.0.tar.gz
- source package:

http://download.sourceforge.net/drumkv1/drumkv1-0.5.0-13.rncbc.suse131.src.rpm
- binary packages:

http://download.sourceforge.net/drumkv1/drumkv1-0.5.0-13.rncbc.suse131.i586.rpm

http://download.sourceforge.net/drumkv1/drumkv1-0.5.0-13.rncbc.suse131.x86_84.rpm


References:

[1] synthv1 - an old-school polyphonic synthesizer
http://synthv1.sourceforge.net/

[2] samplv1 - an old-school polyphonic sampler
http://samplv1.sourceforge.net/

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

read more

July 02, 2014 08:00 PM

[LAA] ZynAddSubFX 2.4.4

From: Mark D. McCurry <mark.d.mccurry@...>
Subject: [LAA] ZynAddSubFX 2.4.4
Date: Jul 2, 7:17 pm 2014


--CXFpZVxO6m2Ol4tQ
Content-Type: text/plain; charset=utf-8
Content-Disposition: inline

ZynAddSubFX 2.4.4 is out.

ZynAddSubFX is a general purpose musical synthesizer with a very long list of
features and capabilities licensed under the GPLv2 License.

Changelog:
2.4.4 (28 Jun 2014)
- Add UI Mousewheel Support
- Add Spectral Adjust Parameter Rescaling
- Add Subnote filter smoothing
- Add Unison derandomization options
- Add NSM import/export
- Add NTK UI compatiability
- (re)Add OSX Support
- Enhance performance of ADnote and SUBnote
- Enhance Installer
- Fix JACK2 specific segfault
- Fix possible DSSI specific segfaults
- Fix Unison Regressions
- Documentation additions
- Misc bug fixes


Project page:
http://zynaddsubfx.sf.net/

Download:
http://downloads.sf.net/zynaddsubfx/zynaddsubfx-2.4.4.tar.xz

Enjoy,
--Mark McCurry

--CXFpZVxO6m2Ol4tQ
Content-Type: application/pgp-signature

-----BEGIN PGP SIGNATURE-----
Version: GnuPG v1

iQEcBAEBAgAGBQJTsDxcAAoJENYPRmmhc6KtRq0H/3jxr3G2acnW5Mpl4CGysNaF
ndBmK39Yjh74qoY97OblwD8soYkoB3PvboEMq+/npOSPo36+vN7nkjA2wgT0T7Ix
iPp3WWdAxv69cdkbCzmqIvucw0SHVEUMxrzdP/dznBTjP5WADsF3U/XddlSZTDe5
jiZcu3vyVPj9/tch0E022FvwrPXqdWyld7udF7AvP73ZyIAPTd5EIrc5KDmycBl2
8zdEnCxvdhID9q9oeDvV2IE3F3hBWw/MK/GEc7rwFdD0/uLTjIOeAe+RVqFekVNb
ntJnhob/CplJz46roITLikGvHPKU+YVmu/CRlTHv/P2yGSxFi8rmbfIjDtNVcZo=
=YHoI
-----END PGP SIGNATURE-----

--CXFpZVxO6m2Ol4tQ--

read more

July 02, 2014 08:00 PM

[LAA] Yoshimi 1.2.2 available

From: Will Godfrey <willgodfrey@...>
Subject: [LAA] Yoshimi 1.2.2 available
Date: Jul 2, 7:17 pm 2014

There are a couple of 'doh' bug fixes.
A really obscure one!
Some GUI tidy-ups.
A few small extensions to existing features.
Reinstatement of two features that got lost in the mist.

--
Will J Godfrey
http://www.musically.me.uk
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
Linux-audio-announce@lists.linuxaudio.org
http://lists.linuxaudio.org/listinfo/linux-audio-announce

read more

July 02, 2014 08:00 PM

June 30, 2014

rncbc.org

Vee One Suite 0.5.0 - Officially beta now!

Greetings,

The Vee One Suite of old-school software instruments, primarily slated for Linux, featuring synthv1, a polyphonic synthesizer, samplv1, a polyphonic sampler and drumkv1, a drum-kit sampler, are officially in beta phase now.

Change-log for the new release:

  • LV2 UI Idle and Show interfaces support added.
  • First attempt to allow a headless stand-alone JACK client application run mode, without a GUI, with option given as command line argument (--no-gui).
  • A man page has been added (re. stand-alone JACK clients).
  • Reverse sample option and parameter knob added. (samplv1 and drumkv1 only).
  • Allow the build system to include an user specified LDFLAGS.

As before, all made available in dual form:

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

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

The fine print follows ;)

synthv1 - an old-school polyphonic synthesizer

synthv1 0.5.0 released!

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

LV2 URI: http://synthv1.sourceforge.net/lv2
website:
http://synthv1.sourceforge.net
downloads:
http://sourceforge.net/projects/synthv1/files

Flattr this

samplv1 - an old-school polyphonic sampler

samplv1 0.5.0 released!

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

LV2 URI: http://samplv1.sourceforge.net/lv2
website:
http://samplv1.sourceforge.net
downloads:
http://sourceforge.net/projects/samplv1/files

Flattr this

drumkv1 - an old-school drum-kit sampler

drumkv1 0.5.0 released!

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

LV2 URI: http://drumkv1.sourceforge.net/lv2
website:
http://drumkv1.sourceforge.net
downloads:
http://sourceforge.net/projects/drumkv1/files

Flattr this

Enjoy && ever again, have fun.

by rncbc at June 30, 2014 05:00 PM

Nothing Special

The Infamous Cellular Automaton Synth

It started with the obfuscated C competition... and a youtube video. Well, no it really started with learning about Conway's Game of Life. Err.. It started with a video about a 13 year old girl who was implementing Conway's Game of Life on the raspberry pi... Ahem. I became interested in cellular automata and especially linking it to music. I originally tried to emulate this one liner that was getting passed around on IRC:


echo "main(i){for(i=0;;i++)putchar(((i*(i>>8|i>>9)&46&i>>8))^(i&i>>13|i>>6));}" | gcc -x c - && ./a.out | aplay

I tried to implement my own version that used an automaton to do the same sort of thing (I'll let you scratch your head on what it does, or just copy and paste it into your terminal). It took me a while to get it working, but I eventually got an automaton operating successfully on a torus. I then went and obfuscated it thinking of entering it into the IOCC. It looks pretty good:


echo "main(_i_,i,_,i_i){i_i=30;for(i=7;;i=_i_<<1|_i_>>7)
{_i_=0;for(_=0;_<8;_++)_i_|=((i_i&1<<((i>>_|i<<(1+~_&7))&7))>0)
<<_;putchar(_i_);}}" | gcc -x c - && ./a.out | aplay

 
Got it? Simple enough. So where did I go with this?




It works. Well. It compiles. Problem is it sounded awful. I was hoping for some really great sound, but just got an annoying buzz. Oh well. I let it rest there.

Then several months later, I contributed a filter to the LV2 Midi filters project using a normal random distribution approximation rather than the uniform distribution method employed initially. I had already looked at the source of many plugins but never got the nerve to jump into developing, but this broke down the wall.

I knew I wanted to make a synth. I'm not sure how exactly I came to decide the way to do it, but eventually I decided to use the cellular automaton code I'd developed in it. I thought for a while, whether each cell would be another note or what, but I eventually settled on making an additive synth with each cell being a harmonic, that sounds when the cell is alive and is silent when the cell is dead. This works pretty well, especially to get pulsating sounds, though the synth isn't limited to those sort of things. The fundamental is always on, and you can easily create a patch that all the harmonics are on or off and don't change. If that doesn't sound so easy, then read on.

An elementary cell automaton basically is a sort of state machine where a number of cells will change in the next time step according to their current state and that of their neighbors. Since this is operating on a toroid this means that the edge cell wraps and is neighbors with the other edge. We use 16 cells, though actually any number is doable by the code. How cells respond is determined by a rule, which is basically an 8 bit number (0-255) where each bit value corresponds to the next state and the bit position is the current state. So for example rule 30 is hex value 0x1E or binary 00011110b. Which means the cells operate as follows:

111 110 101 100 011 010 001 000
 0   0   0   1   1   1   1   0

So a cell sequence of three cells in a row alive, the middle one will die for the next state. If the inital conditon is 0x0100 or 0000000100000000b (16 cells middle one alive) then the sequence looks like:
       0       
      000      
     00  0     
    00 0000    
   00  0   0   
  00 0000 000  
 00  0    0  0 
00 0000  000000
0  0   000     
00000 00  0    0
      0 0000  00
0    00 0   000
00  00  00 00  
0 000 000  0 0 0
  0   0  000 0 0
0000 00000   0 0
     0    0 00 0
0   000  00 0  0
 0 00  000  0000
 0 0 000  000  
00 0 0  000  0 
0  0 0000  00000

where a 0 is a cell and blank is no cell. I cut it off of course but it will go on indefinitely unless it reaches a stable state (i.e all cells are dead and the last bit of the rule is zero). Wikipedia has a nice article with some great graphics from elementary cell automata, though the images are generated from random initial conditions and not on a torus.

If you want to do some great sound design using the automaton, I recommend getting a pencil and paper and writing out the states and filling in what you want the next state to do:

111 110 101 100 011 010 001 000
 1   1   1   1   0   0   0   0

This rule is 0xF0 = 240. In this example I made it so each cell becomes the state its left neighbor is in. Coupled with an input like 0xAFAA you get diagonal stripes going down:
0 0 00000 0 0 0
 0 0 00000 0 0 0
0 0 0 00000 0 0
 0 0 0 00000 0 0
0 0 0 0 00000 0
 0 0 0 0 00000 0
0 0 0 0 0 00000
 0 0 0 0 0 00000
0 0 0 0 0 0 0000
00 0 0 0 0 0 000
000 0 0 0 0 0 00
0000 0 0 0 0 0 0
00000 0 0 0 0 0
 00000 0 0 0 0 0
0 00000 0 0 0 0
 0 00000 0 0 0 0

This gives an interesting phasor sort of sound. These sequences shown are generated by the rule utility provided with the source of Infamous Plugins, which will help you in your explorations. I used this methodology to make all the presets.

The synth has no filter, though filter like effects can be attained through adjusting the number of harmonics played. If you use this parameter to turn off the harmonics because you don't want that sort of sound I reccommend you also turn the cell lifetime up to the max because the cells are calculated even when they are not going to be played (this way you can "open up" the number of harmonics like a filter for some nice effects). Nothing bad happens if you don't, just wasted CPU cycles.

You can also use the lfos for some FM synthesis or to get some good drum sounds like I do on the kick drum of the demo. The demo is entirely made with the Infamous Cellular Automaton Synth plugin. Have a listen and feel free to comment, make suggestions, ask questions, etc. Oh ya and download the source and install it!

*note: I accidentally deleted this post, but luckily was able to recover it from the linux audio planet! whew.

by Spencer (noreply@blogger.com) at June 30, 2014 01:57 PM

Scores of Beauty

What You “Miss” When Using Version Control

Recently I stumbled over this list about “How I save documents” – it’s German but you’ll surely get the point.

It is meant to be funny, but actually it’s a comprehensive documentation of one of the reasons why using plain text and version control rocks. When presented with this list scholars or other people usually respond with telling sighs of recognition – while my personal recognition has actually faded away and has to be actively pulled from a very distant past ;-)

I realized that while having written so much about version control on Scores Of Beauty we don’t have an article yet telling you concisely why you should use it as your bread-and-butter tool for daily work. So today I’m going to give you a list of things you will miss and eventually forget when you switch your toolkit to using version control.

Issues “missed most” when using version control

  1. Naming schemes and file duplication as displayed in the above list
    With version control you will have to content yourself with just one “projekt.doc” (well, it should rather be “projekt.tex” or “projekt.md”)
  2. Asking yourself which copy you should edit or have edited
    With version control you edit the single file. Fullstop. Any modifications are commited to and documented in the project history.
  3. Propagating wrong edits or deletions through shared drives etc.
    Thinking that managing a project on Dropbox or similar service serves you as a backup may fall hard on your toes. If you delete a file while online it will immediately be propagated to the server, and when you are sharing that server with others the files will be deleted from their computers too. If you accidentally delete a file in a version control repository you can simply “discard” that action and revert to the last state. Actually it’s quite improbable that one accidentally deletes a file and commits that deletion to the repository. And even in that case version control won’t finally delete the file but will propagate the deletion as a revertable process.
  4. Concurrent and conflicting edits
    Did you ever run into the issue that your collaborator sent you a document containing some edits. Then you continued to work on that document (respectively a renamed copy, see 1.), and the next day your partner sent the file again, with some more edits? Then you’ll probably be sad to hear that version control takes all the fun out of manually searching the copies for the different changes and figuring out where to apply which version of the content (see 5.). With version control you’ll simply merge in the changes and have the latest state of all collaborators’ work available. And if these changes should conflict in some places, you’ll be conveniently confronted with the decision to choose from the respective version on a line-by-line basis.
  5. Searching for modifications
    Although many programs offer features such as “tracking changes” or similar, in the end all modifications will somehow be melted into a document file. When you look at a document, for example a Finale score returned from a proof-reader, how can you tell where the fixes are? Either you simply trust your colleague, use some external documentation such as a commenting email and trust that, or you have to compare the files yourself again. Version control presents you with the exact changes through the project history, so you’ll immediately (and persistently) know who has changed what and when, usually also why (using commit messages).

Feel free to extend that list in the comments :-)

Rounding off this article I’ll tell you a real-world story I heard from a member of a well-known publishing house. It makes use of a mix of these aspects.
After ten years of regular use editors of said publishing house reviewed the edition of an opera and did some improvements and fixes to the musical text. Unfortunately someone applied these fixes to the wrong score files, say, a backup copy representing the state of the edition half a year before publication (I’m not completely sure about these details, but the point is true). So the result was a completely faulty edition – but with the latest fixes. Unfortunately they only realized their mistake after having trashed all existing copies of the rental material and having printed 20 new sets (and I can tell you that sets of material for this composer’s operas are big). In fact it was the orchestras who had to notice that their new performance materials seemed crappy and unusable …
With version control the initial mistake could have happened too: it’s perfectly possible doing some work while having the wrong branch checked out, and one would even commit that work to the wrong branch. But there are so many opportunities where it’s usual or necessary to look at the project history that it’s extremely unlikely that this error wouldn’t be noticed before actually producing the paper copies. And fixing the issue itself is really straightforward: As mentioned above all changes are completely documented in the project history, so it’s not an issue at all to identify the modifications that have been applied during the review. Actually you now would not identify the modifications and re-apply them manually to the correct state of the edition, but you would rather take the commits and apply them to the right branch – which is appropriately called “cherry-picking” in version control terminology. Depending of the “distance” between the two base points in the project history this process may in fact produce a number of “merge conflicts”, but these can be handled in a straightforward manner too. And finally the version control documentation will clearly indicate the spots where the edition has been changed, so the responsible engraver will know exactly where she should have a close look to check for any regressions and side-effects.

So, actually the question should not be “Why should I use version control?” but “How could I ever justify not using version control?”

by Urs Liska at June 30, 2014 06:09 AM

June 29, 2014

GStreamer News

GStreamer Core, Plugins and RTSP server 1.3.90 release candidate

The GStreamer team is pleased to announce the first release candidate of the stable 1.4 release series. 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.

This release candidate will hopefully shortly be followed by the stable 1.4.0 release if no bigger regressions or bigger issues are detected, and enough testing of the release candidate happened. The new API that was added during the 1.3 release series is not expected to change anymore at this point.

Binaries for Android, iOS, Mac OS X and Windows are provided together with this release.

The stable 1.4 release series is API and ABI compatible with 1.0.x, 1.2.x and any other 1.x release series in the future. Compared to 1.2.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.

June 29, 2014 01:00 PM

harryhaaren

LV2 and Atom communication

EDIT: There are now better resources to learn LV2 Atom programming: please use them!
www.lv2plug.in/book
http://lac.linuxaudio.org/2014/video.php?id=24
/EDIT


Situation: You're trying to write a synth or effect, and you need to communicate between your UI and the DSP parts of the plugin, and MIDI doesn't cut it: enter Atom events. I found them difficult to get to grips with, and hope that this guide eases the process of using them to achieve communication.

 

Starting out

I advise you to first read this : http://lv2plug.in/ns/ext/atom/
It is the official documentation on the Atom spec. Just read the
description. It gives a good general overview of these things called Atoms.

This is "message passing": we send an Atom event from the UI to the DSP part of the plugin. This message needs to be safe to use in a real-time context.

(Note it is assumed that the concepts of URIDs is familiar to you. If they're not, go back and read this article: http://harryhaaren.blogspot.ie/2012/06/writing-lv2-plugins-lv2-overview.html )

Step 1: Set up an LV2_Atom_Forge. The lv2_atom_forge_*   functions are how you build these events.

LV2_Atom_Forge forge;
lv2_atom_forge_init( &forge, map ); // map = LV2_URID_Map feature

Atoms

Atoms are "plain old data" or POD. They're a sequence of bytes written in a contiguous part of memory. Moving them around is possible with a single memcpy() call.

 

Writing Atoms

Understanding the URID naming convention

// we need URID's to represent functionality: There's a naming scheme here, and its *essential* to understand it. Say the functionality we want to represent is a name of a Cat (similar to the official atom example). Here eg_Cat represents the "noun" or "item" we are sending an Atom about. eg_name represents something about the eg_Cat.

something_Something represents an noun or item, while something_something (note the missing capital letter) is represents an aspect of the noun.

LV2_URID eg_Cat;
LV2_URID eg_name; 


In short classes and types are Capitalized, and nothing else is.

Code to write messages

// A frame is essentially a "holder" for data. So we put our event into a LV2_Atom_Forge_Frame. These frames allow the "appending" or adding in of data.
LV2_Atom_Forge_Frame frame;


// Here we write a "blank" atom, which contains nothing (yet). We're going to fill that blank in with some data in a minute. A blank is a dictionary of key:value pairs. The property_head is the key, and the value comes after that.
Note that the last parameter to this function represents the noun or type of item the Atom is about.
LV2_Atom* msg = (LV2_Atom*)lv2_atom_forge_blank(
                &forge, &frame, 1, uris.eg_Cat );


// then we write a "property_head": this uses a URID to describe the next bit of data coming up, which will form the value of the key:value dictionary pair.
lv2_atom_forge_property_head(&forge, uris.eg_name, 0);
 

// now we write the data, note the call to forge_string(), we're writing string data here! There's a forge_int() forge_float() etc too!
lv2_atom_forge_string(&forge, "nameOfCat", strlen("nameOfCat") );

// Popping the frame is like a closing } of a function. Its a finished event, there's nothing more to write into it.

lv2_atom_forge_pop( &forge, &frame);

 

From the UI

// To write messages, we set up a buffer:
uint8_t obj_buf[1024];

// Then we tell the forge to use that buffer

lv2_atom_forge_set_buffer(&forge, obj_buf, 1024);

// now check the "Code to write messages" heading above, that code goes here, where you write the event.

// We have a write_function (from the instantiate() call) and a controller. These are used to send Atoms back. Note that the type of event is atom_eventTransfer: This means the host should pass it directly the the input port of the plugin, and not interpret it. write_function(controller, CONTROL_PORT_NUMBER,
               lv2_atom_total_size(msg),
               uris.atom_eventTransfer, msg);



From the DSP

// Set up forge to write directly to notify output port. This means that when we create an Atom in the DSP part, we don't allocate memory, we write the Atom directly into the notify port.

const uint32_t notify_capacity = self->notify_port->atom.size;
lv2_atom_forge_set_buffer(&self->forge,
                         (uint8_t*)self->notify_port,
                          notify_capacity);
 

// Start a sequence in the notify output port
lv2_atom_forge_sequence_head(&self->forge,
                             &self->notify_frame, 0);

Now look back at the "Code to write messages" section. that's it, write the event into the Notify atom port, and done.




Reading Atoms


// Read incoming events directly from control_port, the Atom input port
LV2_ATOM_SEQUENCE_FOREACH(self->control_port, ev)
{

  // check if the type of the Atom is eg_Cat
  if (ev->body.type == self->uris.eg_Cat)

  {
    // get the object representing the rest of the data
    const LV2_Atom_Object* obj = (LV2_Atom_Object*)&ev->body;
 

    // check if the type of the data is eg_name
    if ( obj->body.otype == self->uris.eg_name )
    {

      // get the data from the body
      const LV2_Atom_Object* body = NULL;
      lv2_atom_object_get(obj, self->uris.
eg_name,
                          &body, 0);
      

      // convert it to the type it is, and use it
      string s = (char*)LV2_ATOM_BODY(body);
      cout << "Cat's name property is " << s << endl;
    }
  }
}



Conclusion

That's it. Its not hard. It just takes getting used to. Its actually a very powerful and easy way of designing a program / plugin, as it *demands* separation between the threads, which is a really good thing.

Questions or comments, let me know :) -Harry

by Harry van Haaren (noreply@blogger.com) at June 29, 2014 02:42 AM

June 27, 2014

Scores of Beauty

Slur shapes and transposed parts: Use tags!

Many contemporary music scores are engraved in concert pitch for easier reading. Parts for transposing instruments must (obviously) be transposed. This may cause slurs and ties to be shaped differently between the score and the parts. In most cases, LilyPond’s d default slur and tie positioning will be attractive enough. If so, there’s no particular problem: LilyPond will calculate the slur/tie shape based on the notes actually being processed at the time.

It does present a problem if the default shape needs to be modified using the \shape command. \shape specifies the alteration in terms of moving the Bezier curve’s control points away from their default positions:

\shape #'((dx0 . dy0) (dx1 . dy1) (dx2 . dy2) (dx3 . dy3)) Slur

To make a downward slur deeper, for instance, you would push the
middle control points down:

\shape #'((0 . 0) (0 . -1) (0 . -1) (0 . 0)) Slur

If transposition should cause the slur to flip upward, this modification will flatten the curve instead. This is quite likely to look wrong, perhaps even unreadable.

I recently ran into this problem in one bar of a trio d’anches that I’m close to finishing. This bar contains a melodic phrase that spans 2.5 octaves in the space of five notes before leaping down a major tenth, under a slur. (Note that the notes themselves are contained in a music variable, and the score only refers to the variable. This is standard practice for any LilyPond project where a score and parts must be generated. It makes it possible to enter the notes once, and lay them out in a score or in parts as needed.)

music = \relative c' {
  \tupletSpan 1*6/8
  \tuplet 4/3 {
    cis4 f,! ( d' e cis' b'2 g,4 )
  }
  \tupletSpan \default
}

{ \time 12/8 \music }
(click to enlarge)

(click to enlarge)

The slur is pretty close, although it makes me a little physically uncomfortable to look at it. There is not enough space above the B, and the shape also disguises the sharp downward leap in the last note.

To fix it, push the third control point up (positive Y offset), and the last control point down.

music = \relative c' {
  \tupletSpan 1*6/8
  \tuplet 4/3 {
    cis4
    \shape #'((0 . 0) (0 . 0) (0 . 1.2) (0 . -0.5)) Slur
    f,! ( d' e cis' b'2 g,4 )
  }
  \tupletSpan \default
}

{ \time 12/8 \music }
(click to enlarge)

(click to enlarge)

What happens if we use that music in a transposed part, however?

music = \relative c' {
  \tupletSpan 1*6/8
  \tuplet 4/3 {
    cis4
    \shape #'((0 . 0) (0 . 0) (0 . 1.2) (0 . -0.5)) Slur
    f,! ( d' e cis' b'2 g,4 )
  }
  \tupletSpan \default
}

{ \time 12/8 \transpose a c' \music }
(click to enlarge)

(click to enlarge)

Now, the slur begins below the top of the stem and just to the right, and it ends quite a bit closer to the notehead than the concert-pitch version. These differences mean that the default curve for A clarinet is much more pronounced. The \shape alteration for concert pitch increases the curvature even further, making the transposed slur look exceptionally “loopy.”

So we need more curvature than the default for concert pitch, and less curvature of the transposed part.

But, in the \shape examples in the LilyPond manuals, it appears that \shape must appear right before the note that initiates the slur or tie to be affected. That is, in normal usage, you can have only one \shape per slur or tie. In this case, the music variable needs to specify both shape modifications, and the music expression that uses the variable should be able to choose which one to use at the time of engraving.

LilyPond has a mechanism to choose between versions of some content: tags. A portion of music (a music expression) can be enclosed in curly braces and associated with a name using the \tag command. If the music variable is used without any tag references, all of the tagged expressions will be kept. Other commands, \keepWithTag and \removeWithTag, can cause certain tagged expressions to be ignored.

music = { \tag #'tagName { ... music expression ... } }

% Elsewhere, in the score
\keepWithTag #'tagName \music

It might not seem to apply to this case, because most uses of \tag will include real music in the expression. Here, all the notes are the same; it would be redundant to put notes inside the tags. Ideally, the tags would include only the content that is different: namely, the \shape alterations. But is that legal? Will it break the \shape calls to put them inside a tag, while the slur itself is outside?

In fact, it is legal. \shape inserts \once \override commands into the expression. These are considered “music,” and may legally appear alone in a tagged expression. The final expression that LilyPond renders includes the override, followed immediately by the slur to affect: no problem.

So the surprisingly simple solution is to write both \shape alterations, each with a different \tag. Then, use \keepWithTag or \removeWithTag to choose which of the \shape calls will be used in this context.

music = \relative c' {
  \tupletSpan 1*6/8
  \tuplet 4/3 {
    cis4
    \tag #'scoreOnly { \shape #'((0 . 0) (0 . 0) (0 . 1.2) (0 . -0.5)) Slur }
    \tag #'partOnly { \shape #'((-0.5 . 1.5) (0 . 0) (0 . 0) (0 . 1.0)) Slur }
    f,! ( d' e cis' b'2 g,4 )
  }
  \tupletSpan \default
}

\markup \bold "Score in concert pitch"
\score {
  \new Staff { \time 12/8 \keepWithTag #'scoreOnly \music }
}

\markup \column { \vspace #1 \bold "Part, transposed for clarinet in A" }
\score {
  \new Staff { \time 12/8 \transpose a c' \keepWithTag #'partOnly \music }
}

example-5.preview

More on tags: Using tags

More on shape: Modifying shapes

by James Harkins at June 27, 2014 06:44 PM

June 24, 2014

ardour

linuxDSP Workstation Plug-ins Bundle - Pay What You Want - Limited Offer

The linuxDSP Workstation Plug-ins Bundle is now available as Pay What You Want for a limited time until the end of June 2014. A unique opportunity to add professional console grade processing to your Ardour sessions for a fraction of the normal price (or whatever you think it's worth). Min price £5.00 (to cover payment processing and charges). Get it here:

http://www.linuxdsp.co.uk/download/lv2/download_wpp

by paul at June 24, 2014 03:42 AM

June 23, 2014

ardour

Subscriptions Updated

I have manually synced the subscriptions records with a downloaded report from PayPal. All subscriptions known to PayPal to be active should be marked as active, and all subscriptions not known to PayPal to be active should be dead. The active subscription count dropped by nearly 300.

If you disagree with the state of your own subscription, please let me know. I did not send email to each subscriber because I think this information is mostly redundant.

read more

by paul at June 23, 2014 09:08 PM

June 22, 2014

GStreamer News

GStreamer Core and Plugins 1.3.3 development release

The GStreamer team is pleased to announce the third release of the unstable 1.3 release series. The 1.3 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. The unstable 1.3 release series will lead to the stable 1.4 release series in the next weeks, and newly added API can still change until that point.

This is hopefully the last 1.3 development release and will be followed by the first 1.4.0 release candidate (1.3.90) in 1-2 weeks. Which then hopefully is followed by 1.4.0 soonish in early July.

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

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, gst-libav, or gst-rtsp-server, or

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

June 22, 2014 08:00 PM

Music, Programming and a Cat

The Linux Audio Company

This is an article of the category "Let's talk about Next-Gen. Future ideas for Linux Audio" where I elaborate(!) on realistic near future improvements or unrealistic science fiction scenarios.

What we want

 

Music produced with Linux, assuming equal human skill and resources, will be better than music produced on other systems because the ecosystem, the concept, the workflow and the ideas are superior in Linux.

That said there is a resources mismatch between different operating systems, and Linux is ... Read More

June 22, 2014 12:09 PM

Scores of Beauty

Polymetrics in Sibelius (vs. LilyPond)

Recently I published an article about polymetric notation to demonstrate how LilyPond provides easy solutions for desires that Finale leaves unfulfilled. Now I got some excerpts from the Sibelius manual showing how that program deals with the task of polymetric notation, and I think this is a good opportunity to have a look at the different approaches to this topic. The following quotes are from the Sibelius 7 manual, with my comments interspersed.

“Multiple time signatures (from the Sibelius 7 manual)

Occasionally scores have two simultaneous time signatures with the same bar-length, such as 2/4 against 6/8. To input this sort of case:

  • Create a 2/4 time signature and input the 2/4 music as normal
  • Input the 6/8 music as triplet eighths (quavers), but use the Note Input > Triplet > Other dialog at least for the first tuplet, switching on None and switching off Bracket, so it won’t show that they’re triplets
  • You can copy the first 6/8 bar as a quick way to get the triplet rhythm for subsequent bars
  • When all of the music has been inputted, delete the 2/4 time signature and drag the first note rightwards until there’s enough space for a replacement time signature
  • Type the 2/4 and 6/8 using text – start with nothing selected and use Time signatures (one staff only), which you can create from the Text > Styles > Style menu, in the Time signatures (special) category
  • Click where you want to put the time signature to type it in as text, with a Return (on the main keyboard) after the top number.”

Wow, that’s neat ;-) . Given that procedure I would really like to know how Sibelius would respond to the request of changing anything in such a polymetric construct.

Basically it’s a very similar approach to what we’d do with LilyPond, except that we would scale the durations while Sibelius users create tuplets only to conceal they are tuplets. If we apply the example from the previous post to the one from the Sibelius manual we see that the steps are much more straightforward in LilyPond:

  • Use a 2/4 time signature and input the 2/4 music as normal
  • In the 6/8 staff tell LilyPond to
    • display a 6/8 time signature: \set Staff.timeSignatureFraction = 6/8
    • compress the music accordingly: scaleDurations 2/3 { ... }
    • enter the 6/8 music as normal
\version "2.19.6"

one = \relative c' {
  \time 2/4
  c8 c c c
}

two = \relative c' {
  \time 2/4
  \set Staff.timeSignatureFraction = 6/8
  \scaleDurations 2/3 {
    c8[ c c] c[ c c]
  }
}

\score {
  <<
    \new Staff \one
    \new Staff \two
  >>
}

I would like to stress that from this example only two lines are relevant to the polymetric issue, and once this has been established in the input file it is completely robust. If you want to change anything in the content or the relation of the timings you can simply modify the input code without any hassles regarding breaking anything through improper undo operations.

I assume that Sibelius wouldn’t treat the beaming in a 9/8 tuplet correctly either, so the drawback that I admitted in the previous post isn’t really a drawback – at least not compared to the competitors. And of course we have a solution in LilyPond, given by Simon Albrecht in his comment to that post.

But now we’re coming to the ugly part:

(Multiple Time Signatures, continued, from the Sibelius 7 manual)

“In cases where two or more time signatures with different bar lengths are required, such as 4/4 and 5/4:

  • Calculate the lowest common multiple between the two time signatures – in this case, 20/4 – and create that as the time signature
  • When all of the music has been inputted, delete the 20/4 time signature and drag the first note rightwards until there’s enough space for a replacement time signature
  • Type the 4/4 and 5/4 using text – to do this you’ll need to create a new text style (see above)
  • Add the extra barlines using the vertical line from the Notations > Lines > Line gallery. This method has the advantage of ensuring that systems end at coinciding barlines. If simultaneous time signatures always have barlines in different places, adopt the same procedure, but remove the barlines in one staff (see Hiding barlines on some staves only in b 4.5 Barlines), then use the vertical line Notations > Lines > Line to draw in suitable barlines where you want them.”

In LilyPond we simply move the responsibility for the timing from the score to the staff context and can then simply enter music in independent meters. I have shown that extensively in the previous post.

But apart from the fact that LilyPond’s approach is much more straightforward here, Sibelius’ technique has a number of severe flaws:

  • Entering all the music in one bar spanning the whole section (at least until the barlines coincide) significantly scrambles the musical meaning. I mean, this 20/4 measure doesn’t have any notion of what is going on inside its intended 4/4 and 5/4 measures.
  • What would you do if the measures only happen to coincide at the end of the piece (or at least after a number of systems)?
  • You have to do all the beaming manually to mimic the individual time signatures.
    While we’re at it, will Sibelius gracefully allow you to enter music like in my example: four groups of four quintuplets (with barlines in between), then start a new section (which happens to start at the 17th quintuplet in that fake measure), etc. And all this with interspersed n-tuplets going across barlines and meter changes?
  • If you have changing meters (as in my previous post’s example) you’ll have to enter all time signatures manually as text.
  • What’s more, you not only have to insert all barlines, you also have to position them. That may be OK with the manual’s 4/4/5/4 example, but I wouldn’t want to do that in my previous post’s score.
  • When entering barlines and time signatures manually like this, what happens to the spacing?
  • If you have such long measures, how will Sibelius behave when you have to change anything in between, say modify or add a nested tuplet? As far as I know, Sibelius (like Finale) is quite rough about its idea of “complete” measures…

Now lets look at the case of alternating time signatures.

“Alternating time signatures (from the Sibelius 7 manual)

To write music in e.g. alternating 2/4 and 3/4 time, signaled by a 2/4 3/4 composite time signature:

  • Input a 2/4 time signature and copy it to alternate bars
  • Do the same for a 3/4 time signature in the remaining bars
  • Input the music
  • Then delete all the time signatures except the initial 2/4 (saying No when asked if you want to rewrite the music)
  • Finally write a 3/4 time signature immediately after the initial 2/4 using text, as described in Multiple time signatures above.”

Well, this first made me scratch my head because I couldn’t instantly find a ready solution with LilyPond. No built-in function, nothing in the docs, no snippet. Some research turned out that there had been a snippet for a quite similar task, but this obviously had been considered obsolete when the \compoundMeter function was introduced in LilyPond. But \compoundMeter actually serves a different purpose than the snippet, and unfortunately the snippet can now only be found in some obscure mailing list discussions and copies of outdated manuals.

However, it became clear what the approach should be: overriding the TimeSignature stencil. Overriding a stencil essentially means telling LilyPond to print something else instead of a given object. Just recently we have seen some examples of that in Peter Bjuhr’s post about using SMuFL glyphs. It is a technique that may look somewhat frightening and is actually somewhat more involved. In the end it’s a very similar approach to the one suggested in the Sibelius manual: remove the default object and print some arbitrary glyphs instead. However, I think there are some substantial advantages in LilyPond’s approach:

  • When you override a stencil LilyPond will take care of the spacing and collision handling automatically. There’s no need to “drag the first note rightwards until there’s enough space for a replacement time signature” (ugh). The new stencil still “is” a time signature for LilyPond, not just some meaningless text elements.
  • You can write your music as normal, using \time commands to indicate the actual measuring. What will Sibelius do when you have to change a measure from 3/4 to 4/4 (or vice versa) after the music has been entered? While it is probably possible it’s definitely a scary thing to be confronted with …

After that you simply have to hide the time signatures for the alternating passage and unhide them to return to normal music.

In order to make this common notation generally available I have written a function. With this it is possible to write

\alternatingTimeSignatures #'((3 8) (4 8) (5 8))

to produce a – perfectly aligned – time signature consisting of an arbitrary number of items. After that you’ll \omit Score.TimeSignature to suppress the printing of time signatures, and then use a simple \undo \omit Score.TimeSignature to bring them back again.

(Click for full-size PDF)

(Click for full-size PDF)

The input file reveals that the function itself isn’t trivial, and regular users shouldn’t be expected to have to dig so deep. But it shows several nice things about LilyPond as an open source project:

  • You can modify or extend LilyPond’s behavior, possibly up to its innermost gear-wheels.
  • Once such a function has been implemented its use is very straightforward.
  • A function like this can easily be made available publicly. Actually I intended to contribute this function (in a slightly modified form) to LilyPond itself, but the review process triggered a discussion about a modification of some underlying syntax, eventually making the function obsolete. Independently of the outcome you can inspect and use the function from the openLilyLib snippets repository,
  • Usually you would ask about such functionality on the lilypond-user mailing list, and chances are pretty good that someone (or several people working together) will present you with a working solution. If it is generally useful it may also be incorporated either in LilyPond or in one of the libraries.

Well, I can only say: If you regularly have to struggle with polymetrics in Finale or Sibelius, or – much worse – if you are a composer and find yourself avoiding polymetrics because of Finale or Sibelius, you should really give LilyPond a closer look!

by Urs Liska at June 22, 2014 08:50 AM

June 21, 2014

Linux Audio Announcements - laa@linuxaudio.org

[LAA] GlassCoder v0.8.0

From: Fred Gleason <fredg@...>
Subject: [LAA] GlassCoder v0.8.0
Date: Jun 21, 8:51 pm 2014

I’m pleased to announce the next public beta release of GlassCoder, a
minimalist JACK live encoder client for Icecast and Shoutcast streaming
servers. GlassCoder is available under the GNU Public License version
2. Some features available in this beta release:

Support for Icecast (v2) and Shoutcast (v1) streaming audio servers

Support for the following audio codecs:
MPEG-1/1.5 Layer 2 ('MP2')
MPEG-1/1.5 Layer 3 ('MP3')
MPEG-2 Advanced Audio Coding, Main Profile ('AAC')
MPEG-4 Advanced Audio Coding, High Efficiency Profile ('HE-AAC+')
Ogg Vorbis

Support for the JACK Audio Connection Kit (http://www.jackaudio.org)

GlassCoder is a ‘minimalist’ client in the sense that it utilizes no GUI
or configuration file components whatever; its entire ‘user interface’
consists of a command-line invocation, making it particularly
well-suited for use cases where the encoder is driven by fan external
system, such as an automation system or script. Full documentation is
provided by the included man page.

Further information and download links are available at
https://github.com/ElvishArtisan/GlassCoder

Cheers!


|----------------------------------------------------------------------|
| Frederick F. Gleason, Jr. | Chief Developer |
| | Paravel Systems |
|----------------------------------------------------------------------|
| A room without books is like a body without a soul. |
| -- Cicero |
|----------------------------------------------------------------------|
_______________________________________________
Linux-audio-announce mailing list
Linux-audio-announce@lists.linuxaudio.org
http://lists.linuxaudio.org/listinfo/linux-audio-announce

read more

June 21, 2014 09:00 PM

[LAA] QmidiNet 0.2.0 is out!

From: Rui Nuno Capela <rncbc@...>
Subject: [LAA] QmidiNet 0.2.0 is out!
Date: Jun 21, 8:51 pm 2014

Headless finally!

QmidiNet 0.2.0 is out!

all that is to say that it may now run without the GUI, eg.
qmidinet --no-gui

QmidiNet [1] is a MIDI network gateway application that sends and
receives MIDI data (ALSA-MIDI and JACK-MIDI) over the network, using
UDP/IP multicast. Inspired by multimidicast [2] and designed to be
compatible with ipMIDI [3] for Windows.

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

See also:

http://www.rncbc.org/drupal/node/790

Website:

http://qmidinet.sourceforge.net

Project pages:

http://sourceforge.net/projects/qmidinet

Downloads:

- source tarballs:
http://downloads.sourceforge.net/qmidinet/qmidinet-0.2.0.tar.gz

- source package (openSUSE 13.1):

http://downloads.sourceforge.net/qmidinet/qmidinet-0.2.0-3.rncbc.suse131.src.rpm

- binary packages (openSUSE 13.1):

http://downloads.sourceforge.net/qmidinet/qmidinet-0.2.0-3.rncbc.suse131.i586.rpm

http://downloads.sourceforge.net/qmidinet/qmidinet-0.2.0-3.rncbc.suse131.x86_64.rpm

Weblog (upstream support):

http://www.rncbc.org

License:

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

Change-log:

- A man page has beed added (making up Alessio Treglia's work on debian,
thanks).
- First attempt to allow a headless application run mode, without GUI or
system-tray icon accessibility, with all options given as command line
arguments.
- Allow the build system to include an user specified LDFLAGS.

References:

[1] QmidiNet - A MIDI Network Gateway via UDP/IP Multicast
http://qmidinet.sourceforge.net

[2] multimidicast - sends and receives MIDI from ALSA sequencers over
network
http://llg.cubic.org/tools/multimidicast

[3] ipMIDI - MIDI over Ethernet ports - send MIDI over your LAN
http://nerds.de

[4] GPL - GNU General Public License
http://www.gnu.org/copyleft/gpl.html


Cheers && Enjoy
--
rncbc aka Rui Nuno Capela
rncbc@rncbc.org
_______________________________________________
Linux-audio-announce mailing list
Linux-audio-announce@lists.linuxaudio.org
http://lists.linuxaudio.org/listinfo/linux-audio-announce

read more

June 21, 2014 09:00 PM

Music, Programming and a Cat

Cologne Audio Meeting #01 - Done!

Last wednesday I organized the first Open Source Audio Meeting Cologne  (which really translates to Linux Audio). It was great! There were nine people, as you can see in the picture. below.

Nine persons for an event with such a niche topic, in a rather local area, with little advertisment to get people to notice. That is huge!

 

The next one will be held on 20.08.2014 . If you are in the area you are welcome to visit, too! Just put your name on the list here!
The website for this event is cologne.linuxaudio.org

Naturally for a local meeting most of the people will speak German but if you want to present software, music or hold a talk in English please do so, by any means!

 

 

 

 

    

June 21, 2014 01:25 PM

Scores of Beauty

The Ring Closes

Oh my, it has been more than a month without anything new on Scores of Beauty – what a shame. OK, we haven’t been lazy in the meantime, but there simply hasn’t been the time to squeeze anything in that could be shared publicly. Maybe I’ll find the time to report about my participation in a conference on “Digital Music Edition” at the university of Berne earlier this month, but for now you’ll have to do with today’s little post about two rings.

The first closing “ring” to be talked about is Janek’s first post which instantiated our blog more than a year ago (OMG, we even missed our birthday ;-) ). Throughout this year we have published 76 posts (not counting this one), sharing opinions, giving insights into different aspects of LilyPond programming, and hopefully we have contributed giving LilyPond (and friends) a more active public appearance. Some of the posts have triggered interesting discussion, some went through without visible feedback. In total I think we can be very happy with our first year and hope for more to come.

The other “ring” really deserves this naming scheme. We are happy to present a substantial production realized with LilyPond.
Aurélien Bello has arranged a short version of Richard Wagner’s “Ring der Nibelungen” for children and engraved the whole orchestral material using LilyPond (see his announcement on the mailing list).

The first performance in Berlin has been recorded by Deutschlandradio Kultur and will be broadcast tonight, 19.00 CEST. Read more (German only) on DRadio’s detail page. Deutschlandradio Kultur also provides a live stream at http://srv.deutschlandradio.de/themes/dradio/script/aod/index.html?audioMode=2&audioID=3.

Go ahead, listen to the music and think of LilyPond :-) .

by Urs Liska at June 21, 2014 08:10 AM

June 20, 2014

ardour

Ardour and Money, 2014 edition

This is being written on June 20th, 2014, basically 2/3rds of the way through the month, and roughly half way through the year. Over there on the right hand side it says that the project has received a total of just under $1800 this month.

I really don't like writing articles about Ardour and money. I like to think that successful and worthy projects will magically fund themselves, and obviously, I like to think that Ardour is successful and worthy. This is wrong thinking, however.

read more

by paul at June 20, 2014 11:17 AM

June 19, 2014

rncbc.org

QmidiNet 0.2.0 is out!

Headless finally!

QmidiNet 0.2.0 is out!

all that is to say that it may now run without the GUI (eg. qmidinet --no-gui).

QmidiNet is a MIDI network gateway application that sends and receives MIDI data (ALSA-MIDI and JACK-MIDI) over the network, using UDP/IP multicast. Inspired by multimidicast and designed to be compatible with ipMIDI for Windows.

Have (lots of) fun!
Flattr this

Website:

http://qmidinet.sourceforge.net

Project page:

http://sourceforge.net/projects/qmidinet

Downloads:

  • source tarball:
    qmidinet-0.2.0.tar.gz
  • source package (openSUSE 13.1):
    qmidinet-0.2.0-3.rncbc.suse131.src.rpm
  • binary packages (openSUSE 13.1):
    qmidinet-0.2.0-3.rncbc.suse131.i586.rpm
    qmidinet-0.2.0-3.rncbc.suse131.x86_64.rpm
  • Weblog (upstream support):

    http://www.rncbc.org

    License:

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

    Change-log:

    • A man page has beed added (making up Alessio Treglia's work on debian, thanks).
    • First attempt to allow a headless application run mode, without GUI or system-tray icon accessibility, with all options given as command line arguments.
    • Allow the build system to include an user specified LDFLAGS.

    Cheers && Enjoy!

    by rncbc at June 19, 2014 05:30 PM

    Linux Audio Announcements - laa@linuxaudio.org

    [LAA] Hydrogen 0.9.6-RC2 released

    From: Sebastian Moors <mauser@...>
    Subject: [LAA] Hydrogen 0.9.6-RC2 released
    Date: Jun 19, 7:25 am 2014

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

    Hi everyone,

    Hydrogen 0.9.6-RC2 has been released today. It brings no new features
    (in comparison to RC1), but fixes a number of bugs.See
    https://github.com/hydrogen-music/hydro ... /0.9.6-RC2
    for
    more details about download possibilites and a list of changes. We would
    like to encourage everyone who is interested in Hydrogen to test this
    version.

    Best regards,
    Sebastian

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








    charset=ISO-8859-15" />
    charset=ISO-8859-15">
    Hi everyone,



    Hydrogen 0.9.6-RC2 has been released today. It brings no new
    features (in comparison to RC1), but fixes a number of bugs.See
    class="postlink"
    href="https://github.com/hydrogen-music/hydrogen/releases/tag/0.9.6-RC2">https://github.com/hydrogen-music/hydro
    ... /0.9.6-RC2
    for more details about download possibilites
    and a list of changes. We would like to encourage everyone who is
    interested in Hydrogen to test this version.



    Best regards,

    Sebastian




    --------------050908080707010502050008--

    read more

    June 19, 2014 08:00 AM

    June 17, 2014

    PID EINS!

    Factory Reset, Stateless Systems, Reproducible Systems & Verifiable Systems

    (Just a small heads-up: I don't blog as much as I used to, I nowadays update my Google+ page a lot more frequently. You might want to subscribe that if you are interested in more frequent technical updates on what we are working on.)

    In the past weeks we have been working on a couple of features for systemd that enable a number of new usecases I'd like to shed some light on. Taking benefit of the /usr merge that a number of distributions have completed we want to bring runtime behaviour of Linux systems to the next level. With the /usr merge completed most static vendor-supplied OS data is found exclusively in /usr, only a few additional bits in /var and /etc are necessary to make a system boot. On this we can build to enable a couple of new features:

    1. A mechanism we call Factory Reset shall flush out /etc and /var, but keep the vendor-supplied /usr, bringing the system back into a well-defined, pristine vendor state with no local state or configuration. This functionality is useful across the board from servers, to desktops, to embedded devices.
    2. A Stateless System goes one step further: a system like this never stores /etc or /var on persistent storage, but always comes up with pristine vendor state. On systems like this every reboot acts as factor reset. This functionality is particularly useful for simple containers or systems that boot off the network or read-only media, and receive all configuration they need during runtime from vendor packages or protocols like DHCP or are capable of discovering their parameters automatically from the available hardware or periphery.
    3. Reproducible Systems multiply a vendor image into many containers or systems. Only local configuration or state is stored per-system, while the vendor operating system is pulled in from the same, immutable, shared snapshot. Each system hence has its private /etc and /var for receiving local configuration, however the OS tree in /usr is pulled in via bind mounts (in case of containers) or technologies like NFS (in case of physical systems), or btrfs snapshots from a golden master image. This is particular interesting for containers where the goal is to run thousands of container images from the same OS tree. However, it also has a number of other usecases, for example thin client systems, which can boot the same NFS share a number of times. Furthermore this mechanism is useful to implement very simple OS installers, that simply unserialize a /usr snapshot into a file system, install a boot loader, and reboot.
    4. Verifiable Systems are closely related to stateless systems: if the underlying storage technology can cryptographically ensure that the vendor-supplied OS is trusted and in a consistent state, then it must be made sure that /etc or /var are either included in the OS image, or simply unnecessary for booting.

    Concepts

    A number of Linux-based operating systems have tried to implement some of the schemes described out above in one way or another. Particularly interesting are GNOME's OSTree, CoreOS and Google's Android and ChromeOS. They generally found different solutions for the specific problems you have when implementing schemes like this, sometimes taking shortcuts that keep only the specific case in mind, and cannot cover the general purpose. With systemd now being at the core of so many distributions and deeply involved in bringing up and maintaining the system we came to the conclusion that we should attempt to add generic support for setups like this to systemd itself, to open this up for the general purpose distributions to build on. We decided to focus on three kinds of systems:

    1. The stateful system, the traditional system as we know it with machine-specific /etc, /usr and /var, all properly populated.
    2. Startup without a populated /var, but with configured /etc. (We will call these volatile systems.)
    3. Startup without either /etc or /var (We will call these stateless systems.).

    A factory reset is just a special case of the latter two modes, where the system boots up without /var and /etc but the next boot is a normal stateful boot like like the first described mode. Note that a mode where /etc is flushed, but /var is not is nothing we intend to cover (why? well, the user ID question becomes much harder, see below, and we simply saw no usecase for it worth the trouble).

    Problems

    Booting up a system without a populated /var is relatively straight-forward. With a few lines of tmpfiles configuration it is possible to populate /var with its basic structure in a way that is sufficient to make a system boot cleanly. systemd version 214 and newer ship with support for this. Of course, support for this scheme in systemd is only a small part of the solution. While a lot of software reconstructs the directory hierarchy it needs in /var automatically, many software does not. In case like this it is necessary to ship a couple of additional tmpfiles lines that setup up at boot-time the necessary files or directories in /var to make the software operate, similar to what RPM or DEB packages would set up at installation time.

    Booting up a system without a populated /etc is a more difficult task. In /etc we have a lot of configuration bits that are essential for the system to operate, for example and most importantly system user and group information in /etc/passwd and /etc/group. If the system boots up without /etc there must be a way to replicate the minimal information necessary in it, so that the system manages to boot up fully.

    To make this even more complex, in order to support "offline" updates of /usr that are replicated into a number of systems possessing private /etc and /var there needs to be a way how these directories can be upgraded transparently when necessary, for example by recreating caches like /etc/ld.so.cache or adding missing system users to /etc/passwd on next reboot.

    Starting with systemd 215 (yet unreleased, as I type this) we will ship with a number of features in systemd that make /etc-less boots functional:

    • A new tool systemd-sysusers as been added. It introduces a new drop-in directory /usr/lib/sysusers.d/. Minimal descriptions of necessary system users and groups can be placed there. Whenever the tool is invoked it will create these users in /etc/passwd and /etc/group should they be missing. It is only suitable for creating system users and groups, not for normal users. It will write to the files directly via the appropriate glibc APIs, which is the right thing to do for system users. (For normal users no such APIs exist, as the users might be stored centrally on LDAP or suchlike, and they are out of focus for our usecase.) The major benefit of this tool is that system user definition can happen offline: a package simply has to drop in a new file to register a user. This makes system user registration declarative instead of imperative -- which is the way how system users are traditionally created from RPM or DEB installation scripts. By being declarative it is easy to replicate the users on next boot to a number of system instances.

      To make this new tool interesting for packaging scripts we make it easy to alternatively invoke it during package installation time, thus being a good alternative to invocations of useradd -r and groupadd -r.

      Some OS designs use a static, fixed user/group list stored in /usr as primary database for users/groups, which fixed UID/GID mappings. While this works for specific systems, this cannot cover the general purpose. As the UID/GID range for system users/groups is very small (only containing 998 users and groups on most systems), the best has to be made from this space and only UIDs/GIDs necessary on the specific system should be allocated. This means allocation has to be dynamic and adjust to what is necessary.

      Also note that this tool has one very nice feature: in addition to fully dynamic, and fully static UID/GID assignment for the users to create, it supports reading UID/GID numbers off existing files in /usr, so that vendors can make use of setuid/setgid binaries owned by specific users.

    • We also added a default user definition list which creates the most basic users the system and systemd need. Of course, very likely downstream distributions might need to alter this default list, add new entries and possibly map specific users to particular numeric UIDs.
    • A new condition ConditionNeedsUpdate= has been added. With this mechanism it is possible to conditionalize execution of services depending on whether /usr is newer than /etc or /var. The idea is that various services that need to be added into the boot process on upgrades make use of this to not delay boot-ups on normal boots, but run as necessary should /usr have been update since the last boot. This is implemented based on the mtime timestamp of the /usr: if the OS has been updated the packaging software should touch the directory, thus informing all instances that an upgrade of /etc and /var might be necessary.
    • We added a number of service files, that make use of the new ConditionNeedsUpdate= switch, and run a couple of services after each update. Among them are the aforementiond systemd-sysusers tool, as well as services that rebuild the udev hardware database, the journal catalog database and the library cache in /etc/ld.so.cache.
    • If systemd detects an empty /etc at early boot it will now use the unit preset information to enable all services by default that the vendor or packager declared. It will then proceed booting.
    • We added a new tmpfiles snippet that is able to reconstruct the most basic structure of /etc if it is missing.
    • tmpfiles also gained the ability copy entire directory trees into place should they be missing. This is particularly useful for copying certain essential files or directories into /etc without which the system refuses to boot. Currently the most prominent candidates for this are /etc/pam.d and /etc/dbus-1. In the long run we hope that packages can be fixed so that they always work correctly without configuration in /etc. Depending on the software this means that they should come with compiled-in defaults that just work should their configuration file be missing, or that they should fall back to static vendor-supplied configuration in /usr that is used whenever /etc doesn't have any configuration. Both the PAM and the D-Bus case are probably candidates for the latter. Given that there are probably many cases like this we are working with a number of folks to introduce a new directory called /usr/share/etc (name is not settled yet) to major distributions, that always contain the full, original, vendor-supplied configuration of all packages. This is very useful here, so that there's an obvious place to copy the original configuration from, but it is also useful completely independently as this provides administrators with an easy place to diff their own configuration in /etc against to see what local changes are in place.
    • We added a new --tmpfs= switch to systemd-nspawn to make testing of systems with unpopulated /etc and /var easy. For example, to run a fully state-less container, use a command line like this:

      # system-nspawn -D /srv/mycontainer --read-only --tmpfs=/var --tmpfs=/etc -b

      This command line will invoke the container tree stored in /srv/mycontainer in a read-only way, but with a (writable) tmpfs mounted to /var and /etc. With a very recent git snapshot of systemd invoking a Fedora rawhide system should mostly work OK, modulo the D-Bus and PAM problems mentioned above. A later version of systemd-nspawn is likely to gain a high-level switch --mode={stateful|volatile|stateless} that sets combines this into simple switches reusing the vocabulary introduced earlier.

    What's Next

    Pulling this all together we are very close to making boots with empty /etc and /var on general purpose Linux operating systems a reality. Of course, while doing the groundwork in systemd gets us some distance, there's a lot of work left. Most importantly: the majority of Linux packages are simply incomptible with this scheme the way they are currently set up. They do not work without configuration in /etc or state directories in /var; they do not drop system user information in /usr/lib/sysusers.d. However, we believe it's our job to do the groundwork, and to start somewhere.

    So what does this mean for the next steps? Of course, currently very little of this is available in any distribution (simply already because 215 isn't even released yet). However, this will hopefully change quickly. As soon as that is accomplished we can start working on making the other components of the OS work nicely in this scheme. If you are an upstream developer, please consider making your software work correctly if /etc and/or /var are not populated. This means:

    • When you need a state directory in /var and it is missing, create it first. If you cannot do that, because you dropped priviliges or suchlike, please consider dropping in a tmpfiles snippet that creates the directory with the right permissions early at boot, should it be missing.
    • When you need configuration files in /etc to work properly, consider changing your application to work nicely when these files are missing, and automatically fall back to either built-in defaults, or to static vendor-supplied configuration files shipped in /usr, so that administrators can override configuration in /etc but if they don't the default configuration counts.
    • When you need a system user or group, consider dropping in a file into /usr/lib/sysusers.d describing the users. (Currently documentation on this is minimal, we will provide more docs on this shortly.)

    If you are a packager, you can also help on making this all work:

    • Ask upstream to implement what we describe above, possibly even preparing a patch for this.
    • If upstream will not make these changes, then consider dropping in tmpfiles snippets that copy the bare minimum of configuration files to make your software work from somewhere in /usr into /etc.
    • Consider moving from imperative useradd commands in packaging scripts, to declarative sysusers files. Ideally, this is shipped upstream too, but if that's not possible then simply adding this to packages should be good enough.

    Of course, before moving to declarative system user definitions you should consult with your distribution whether their packaging policy even allows that. Currently, most distributions will not, so we have to work to get this changed first.

    Anyway, so much about what we have been working on and where we want to take this.

    Conclusion

    Before we finish, let me stress again why we are doing all this:

    1. For end-user machines like desktops, tablets or mobile phones, we want a generic way to implement factory reset, which the user can make use of when the system is broken (saves you support costs), or when he wants to sell it and get rid of his private data, and renew that "fresh car smell".
    2. For embedded machines we want a generic way how to reset devices. We also want a way how every single boot can be identical to a factory reset, in a stateless system design.
    3. For all kinds of systems we want to centralize vendor data in /usr so that it can be strictly read-only, and fully cryptographically verified as one unit.
    4. We want to enable new kinds of OS installers that simply deserialize a vendor OS /usr snapshot into a new file system, install a boot loader and reboot, leaving all first-time configuration to the next boot.
    5. We want to enable new kinds of OS updaters that build on this, and manage a number of vendor OS /usr snapshots in verified states, and which can then update /etc and /var simply by rebooting into a newer version.
    6. We wanto to scale container setups naturally, by sharing a single golden master /usr tree with a large number of instances that simply maintain their own private /etc and /var for their private configuration and state, while still allowing clean updates of /usr.
    7. We want to make thin clients that share /usr across the network work by allowing stateless bootups. During all discussions on how /usr was to be organized this was fequently mentioned. A setup like this so far only worked in very specific cases, with this scheme we want to make this work in general case.

    Of course, we have no illusions, just doing the groundwork for all of this in systemd doesn't make this all a real-life solution yet. Also, it's very unlikely that all of Fedora (or any other general purpose distribution) will support this scheme for all its packages soon, however, we are quite confident that the idea is convincing, that we need to start somewhere, and that getting the most core packages adapted to this shouldn't be out of reach.

    Oh, and of course, the concepts behind this are really not new, we know that. However, what's new here is that we try to make them available in a general purpose OS core, instead of special purpose systems.

    Anyway, let's get the ball rolling! Late's make stateless systems a reality!

    And that's all I have for now. I am sure this leaves a lot of questions open. If you have any, join us on IRC on #systemd on freenode or comment on Google+.

    June 17, 2014 04:13 PM

    Linux Audio Announcements - laa@linuxaudio.org

    [LAA] RhythmDelay: tap a rhythm into your delay, and much more.

    From: Bart Brouns <bart@...>
    Subject: [LAA] RhythmDelay: tap a rhythm into your delay, and much more.
    Date: Jun 17, 1:57 pm 2014

    Hi Everybody,


    I made a delay where you don't tap in a tempo but an actual rhythm.


    https://github.com/magnetophon/RhythmDelay

    The 'much more' refers to ways of manipulating the sound of the
    delay-taps.

    In the studio, I find that I almost never use a straight delay.
    It sounds way to clean and in your face, so I usually have a combination
    of filters, a widener, reverb, and a way of having different delay-times
    for L and R.




    Here I combined all that into one very flexible setup:

    Each tap has its own lp and hp-filters, zita-reverb, stereo-width and a
    delay-based panner.

    Each tap can have it's own settings for the insert-FX, but instead of a
    control-panel per tap I made just two, and a slider per tap to morph
    between them.



    Once you get the concept, it's a really quick and easy way of making
    everything from subtle polished delay effects to all-out dub-style
    madness.

    Have fun!!


    Cheers, Bart.


    PS:

    The following is a long-winded question that will probably be much
    easier to follow if you actually try out the effect before/ while
    reading this:


    I'd love to get some opinions and ideas on the feedback mechanism I
    implemented.
    In particular this: when the feedback amount is non-zero, and you are
    tapping a new rhythm, while making sound, I have two choices:
    - either I turn on and off the feedback tap after the feedback-delay.
    - or I do it before it.

    The first option is what I did now: it has the effect of starting to
    feedback the sound you just made right after you tap. Which is what
    you'd expect to happen in a normal delay, but has the downside that it
    breaks up the rhythmic pattern you're tapping if any tap is longer than
    the previous.

    The second option will only start feedbacking the sounds you made after
    you hit the tap button. This has the effect that the first time you tap
    a new rhythm, only the tapped rhythm is heard, and the feedback only
    starts for any sounds after the last tap.

    This decision is moot if you don't make sounds while tapping a new
    rhythm, but since I'd like to be able to use this live as well, I'd like
    to some ideas.





    _______________________________________________
    Linux-audio-announce mailing list
    Linux-audio-announce@lists.linuxaudio.org
    http://lists.linuxaudio.org/listinfo/linux-audio-announce

    read more

    June 17, 2014 02:00 PM

    June 15, 2014

    blog4

    Talk UnafraidTalk Unafraid

    HSTS with nginx and Varnish

    SSL is good. It’s not perfect, but it makes life harder for mass surveillance and all websites should be using it. Yes, I know this blog doesn’t – I’ll get around to it.

    I upgraded one of my sites to use HSTS, which is an extension to enforce usage of SSL where it’s available. This effectively means that after the first request via HTTPS, the browser should remember that domain uses SSL and should make sure any subsequent requests are HTTPS. HTTP requests get redirected to HTTPS immediately. This is great – not only does it mean that you’re less likely to have clients making requests in the clear when they should be using SSL, but it means that SSL stripping attacks will be foiled.

    This particular site is a bit complex because it uses Varnish to cache responses – mostly images, between 20kb and 4-5MB. There’s a 64GB in-memory cache to keep that site moving rapidly. Varnish, hovever, doesn’t support SSL – so we have to put nginx in front. Thus, an average request comes into nginx via HTTPS, nginx adds the X-Forwarded-For header with the IP of the client and sets X-Forwarded-Proto to ‘https’. Then it reverse proxies the request to Varnish in the clear. Varnish then returns the response from the cache, or forwards it on to nginx in the clear, where the response is either served from disk or proxied from the application servers.

    Because Varnish doesn’t speak HTTPS and doesn’t even support redirects we have to do a few little things in the configs I thought I’d document here for the sanity of whoever comes after me.

    First up we need to add the following to our nginx config, in our HTTPS server block.

    What this does is pass through the client IP and forwarding protocol to Varnish, and sets the Strict-Transport-Security header as defined in RFC 6797. This is half the battle – once we’ve got the request into Varnish and have a way to tell it’s come through the SSL termination layer we can treat that traffic appropriately in Varnish.

    In our Varnish config we simply toggle on the X-Forwarded-Proto header and throw an error with code 750 if it isn’t HTTPS, after setting X-Redir-Url on the request to a clone of the URI with a https schema. Then we rescue that in vcl_error, use the header on the request we just set to populate the Location field of the response and return a HTTP 301 code. Job done! It’s worth noting that we don’t verify the request with header is coming from a trusted upstream source – you can identify this sort of spoofing using ACLs and probably already have a nice example in your config if you’re using HTTP PURGE/BAN requests. My config doesn’t use this as forcing connections to use HTTP isn’t a significant security issue in this instance.

    Our client now gets redirected to HTTPS on the first HTTP request, and from that point forward will never make another non-SSL request. As it should be!

    It’s worth noting, of course, that you can break things with this. I’d strongly recommend a slow start – gradually increase your HSTS policy duration as you run into problems. I ran into problems with the includeSubdomains option of the HSTS header – I thought all subdomains of that site pointed at things that spoke SSL but forgot about one. I opted in the end for not using the includeSubdomains option as everything but that service runs through the same SSL termination point so gets HSTS regardless.

    by James Harrison at June 15, 2014 12:17 AM

    June 12, 2014

    Linux Audio Announcements - laa@linuxaudio.org

    [LAA] LAC'14 video archive

    From: Robin Gareus <robin@...>
    Subject: [LAA] LAC'14 video archive
    Date: Jun 12, 9:10 pm 2014

    Hi all,

    The video recordings of the LAC'14 presentations have just been uploaded
    to the conference website and are now directly linked from the archive:
    http://lac.linuxaudio.org/2014/program


    There are still a three videos missing and the workshop videos are also
    yet to come. Currently they are also only available as vp8/vorbis/webm
    (sorry IE and Safari users). But since it has been quite a while
    already, we decided to not hold back the release of these already
    finished videos any further.

    Once the collection is complete, we will provide a .torrent. Meanwhile,
    for those who prefer to download the videos incrementally, they are
    accessible via rsync://linuxaudio.org/ [1].

    Many thanks for Frank and Moritz to get those done in really outstanding
    quality this year. Kudos to the complete stream-team.

    enjoy,
    robin - for the LAC'14 team


    [1] example to get the 720p versions:
    rsync -Pa --exclude "*360p.webm" \
    rsync://linuxaudio.org/lac2014/ \
    lac2014/
    _______________________________________________
    Linux-audio-announce mailing list
    Linux-audio-announce@lists.linuxaudio.org
    http://lists.linuxaudio.org/listinfo/linux-audio-announce

    read more

    June 12, 2014 10:00 PM

    Create Digital Music » open-source

    littleBits Synth Kit Will Add USB Audio, CV, and MIDI; See Snap-Together Modular Live in NYC

    3NewSynthBits_3261

    littleBits has already won over some synth enthusiasts with snap-together modules you can combine via magnets, and a collaboration with KORG. But until now, the open source gizmos have been largely a world unto themselves. You could route audio in and out, but that’s it; any expansion was dependent on buying more littleBits modules.

    Over the course of this year, that will change. Already, there’s a US$36 Arduino module, opening up custom-coded functionality and computer connectivity.

    And by the end of the year, littleBits will add three modules that make the Synth Kit into more of a synth (or controller, if you like):

    MIDI: A minijack MIDI input lets you use keyboards and the like to play your littleBits synth. (Note that it’s input only, and since it’s minijack, requires a breakout – I assume that’ll be included, though it’s not in the pictures. Actually, I wish minijack were standard for MIDI connections by now.)

    USB provides bi-directional I/O, so you can also make a littleBits rig into a controller, using the sensors and so on.

    CV: Input, output for connections to analog gear.

    USB I/O: This one I didn’t expect: it’s actually an integrated audio interface, so you can connect sound directly to software without any audio cabling.

    (See pics at the end of the story)

    No word yet on pricing, but you can sign up now for a notification when the modules go on sale:
    http://littlebits.cc/bits/newsynthmodules

    The Synth Kit remains US$159.

    littleBits isn’t without some disadvantages. I found the connections a bit delicate; you have to make some effort to keep your rigs connected. (Mounting boards do appear to help; I’ll be testing those myself, but I’ve seen them in action on other rigs.) Also, really taking advantage of the modular capabilities invariably means buying more modules. But the setup is a whole lot of fun.

    There’s something about them, in other words, that has really captured imaginations.

    And some folks are going really crazy combining lots of modules.

    At SONAR in Barcelona this week, littleBits have a hands-on display.

    Even better, if you’re in the New York area, you can catch Hans Tammen and friends with littleBits performances on a grand scale. It’s all part of the Dark Circuits Festival, a really lovely-looking lineup of music.

    littlebitswide

    On June 19, you can catch a quartet of four members of the littleBits engineering team – Paul Rothman, Geof Lipman, Ed Bear and Sean Schumer – playing littleBits together (see pic below), all as part of a really nice program of music:

    [Jun 19] Parkins / Ostrowski, Vortex, and the littleBits Quartet at Spectrum

    littlebits-quartet

    On June 21, there’s a combined workshop performance – with a 20-piece littleBits orchestra. That’s 20 players, 20 kits, and one conductor.

    Using flashcards and hand signs, Hans Tammen creates large multi-movement pieces with large ensembles of electronic instruments for over a decade. As part of this year’s MakeMusicNY he will work with an ensemble of Korg littleBits synthesizer players. The littleBits are tiny synthesizer modules connected via magnets for quick changes in the signal chain, fitting into the littleBits modular system for infinite combinations of audio experience. We are looking for about 20 players to take part in the workshop and performance – you do not need to bring a kit because littleBits provides us with 20 kits to create a massive piece of synthesizer music!

    [Jun 21] MakeMusicNY and Dark Circuits Festival at The Firehouse

    Then, on June 22, there’s an epic 240-module littleBits rig Hans has built for a full-scale performance, played by a lot of good friends from the experimental music world:

    APHERESIS is a large multi-movement piece by Hans Tammen for 14 performers of custom-made electronic instruments. The piece is inspired by Earle Brown’s Available Forms, uses a score that is rearranged every time it’s performed, and fuses various contemporary electronic music styles and techniques. It combines contemporary electronic music practices such as circuit bending, no-input mixers, laptops, turntablism, analogue circuitry, network sniffers and synthesis to produce sounds electronically. It is performed by internationally renowned performers Matthew Ostrowski, Andrea Parkins, Dafna Naphtali, Miguel Frasconi, Phillip Stearns, Philip White, Joshua Fried, Shoko Nagai, Maria Chavez, Satoshi Takeishi, Joker Nies, Mario DeVega, Lars Graugaard and Michael Vorfeld.

    Prior to the APHERESIS performance, the ensemble will present their own version of “live coding” by creating a “littleBits Monster Synth” from 20 kits of the popular Korg littleBits synth. Starting with an empty table, the participants will create a piece by slowly connecting the modules, gradually assembling over 200 modules into an infinite maze of sonic possibilities, propagating in all directions, growing from the middle and springing up, unannounced, in seemingly impossible places. A camera from above will project the maze on the walls for the audience to follow the development, the music is distributed through a quad sound system.

    [Jun 22] Main Event: littleBits Monster Synth & Third Eye Dark Circuits Orchestra at Eyebeam’s CT-SWaM

    Now, one more look at those new modules:

    CV_3257 (1)

    MIDITriger_3254

    CV_3257

    And it’s time to trot out my littleBits etudes again. I’d better make some new ones. (new modules, please!) These are CC licensed, so do let me know if you make something out of the samples; I’d love to hear it!

    The post littleBits Synth Kit Will Add USB Audio, CV, and MIDI; See Snap-Together Modular Live in NYC appeared first on Create Digital Music.

    by Peter Kirn at June 12, 2014 03:49 PM

    June 11, 2014

    m3ga blog

    Moving from Wai 2.X to 3.0.

    Michael Snoyman has just released version 3.0 of Wai, the Haskell Web Application Interface library which is used with the Yesod Web Framework and anything that uses the Warp web server. The important changes for Wai are listed this blog post. The tl;dr is that removing the Conduit library dependency makes the Wai interface more easily usable with one of the alternative Haskell streaming libraries, like Pipes, Stream-IO, Iterator etc.

    As a result of the above changes, the type of a web application changes as follows:

    
      -- Wai > 2.0 && Wai  3.0
      type Application = Request -> IO Response
    
      -- Wai == 3.0
      type Application = Request -> (Response -> IO ResponseReceived) -> IO ResponseReceived
    
    

    Typically a function of type Application will be run by the Warp web server using one of Warp.run or associated functions which have type signatures of:

    
      run :: Port -> Application -> IO ()
    
      runSettings :: Settings -> Application -> IO ()
    
      runSettingsSocket :: Settings -> Socket -> Application -> IO ()Source
    
      runSettingsConnection :: Settings -> IO (Connection, SockAddr) -> Application -> IO ()
    
    

    Its important to note that the only thing that has changed about these Warp functions is the Application type. That means that if we have a function oldWaiApplication that we want to interface to the new version of Wai, we can just wrap it with the following function:

    
      newWaiApplication :: Manager -> Request -> (Response -> IO ResponseReceived) -> IO ResponseReceived
      newWaiApplication mgr wreq receiver = oldWaiApplication mgr wreq >>= receiver
    
    

    and use newWaiApplication in place of oldWaiApplication in the call to whichever of the Warp run functions you are using.

    June 11, 2014 10:16 AM

    June 06, 2014

    Linux Audio Announcements - laa@linuxaudio.org

    [LAA] Yet another "io GNU/Linux" iso released

    From: Manu Kebab <el.doctor@...>
    Subject: [LAA] Yet another "io GNU/Linux" iso released
    Date: Jun 6, 6:31 am 2014


    --nextPart3618610.NQ5lCBHNnt
    Content-Transfer-Encoding: 7Bit
    Content-Type: text/plain; charset="us-ascii"

    Hi,

    A new 64bit iso is up ;)

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

    Kernel 3.14.4, Jack2 as default sound server, e18 as desktop environment and a
    big collection of installed software... Full persistence for USB install (with
    encryption) and more cool stuff... A great nomade studio :)

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

    -> http://manu.kebab.free.fr/iognulinux.html
    -> https://sourceforge.net/projects/io-gnu-linux/


    Feedbacks welcome, enjoy :)

    MK

    --nextPart3618610.NQ5lCBHNnt
    Content-Type: application/pgp-signature; name="signature.asc"
    Content-Description: This is a digitally signed message part.
    Content-Transfer-Encoding: 7Bit

    -----BEGIN PGP SIGNATURE-----
    Version: GnuPG v2.0.22 (GNU/Linux)

    iEYEABECAAYFAlOROyoACgkQNH1Gr/cAWUWRXwCeLFYUsRlERr164oV+j2o6/9jg
    vb4An0KDWnx4RBCtUMPGYiqbM83gufFt
    =qc1p
    -----END PGP SIGNATURE-----

    --nextPart3618610.NQ5lCBHNnt--

    read more

    June 06, 2014 07:00 AM

    June 05, 2014

    Linux Audio Announcements - laa@linuxaudio.org

    [LAA] Open Source Audio Meeting in Cologne, Germany (User Group)

    From: Nils Gey <ich@...>
    Subject: [LAA] Open Source Audio Meeting in Cologne, Germany (User Group)
    Date: Jun 5, 7:00 pm 2014

    Dear musicians, programmers and normal people,

    I plan to create a user group, a regular meeting, in my home town
    Cologne, in Germany.

    The first meeting ever will be already on June 18th, 19:00.
    After that every two month or so. There are more dates on the website
    (see below).

    Here is a brief website with all the necessary information.
    http://cologne.linuxaudio.org/ (Any language is welcome but the chances
    are that most people will be from the area and therefore speak German.
    So the page is in German)

    If you intend to come you can put your name on this etherpad, but this
    is not required. Anybody can show up.
    http://yourpart.eu/p/linuxaudio-cologne

    Topics will be unorganized Q&A, showing off programs and music, sharing
    knowledge and tips and hopefully one day shorter or longer
    presentations, tutorials, workshops etc.
    I expect most people to use Linux but any OS is welcome, therefore I
    named it just "Open Source Audio" and not Linux Audio.

    So if you are in the area please join us! If you are not in the area but
    know people in the area, please tell them.

    Greetings,

    Nils
    http://cologne.linuxaudio.org/
    http://www.nilsgey.de

    P.S.
    Despite the domain saying linuxaudio.org this is an independently and
    privately organized event. It is not intended to replace or get in
    conflict with the Linux Audio Conference.

    _______________________________________________
    Linux-audio-announce mailing list
    Linux-audio-announce@lists.linuxaudio.org
    http://lists.linuxaudio.org/listinfo/linux-audio-announce

    read more

    June 05, 2014 08:00 PM

    [LAA] qompander: A great sounding compressor/expander with fast response

    From: Bart Brouns <bart@...>
    Subject: [LAA] qompander: A great sounding compressor/expander with fast response
    Date: Jun 5, 7:00 pm 2014

    Hi everybody,



    I ported http://www.katjaas.nl/compander/compander.html to Faust.

    It's a very nice sounding cross between an expander, compressor and
    limiter.

    Here it is: https://github.com/magnetophon/qompander




    Enjoy, and let me know what you think of it!

    Greetings,
    Bart.

    _______________________________________________
    Linux-audio-announce mailing list
    Linux-audio-announce@lists.linuxaudio.org
    http://lists.linuxaudio.org/listinfo/linux-audio-announce

    read more

    June 05, 2014 08:00 PM

    [LAA] Rivendell v2.9.0

    From: Fred Gleason <fredg@...>
    Subject: [LAA] Rivendell v2.9.0
    Date: Jun 5, 6:59 pm 2014

    On behalf of the entire Rivendell development team, I'm pleased to
    announce the availability of Rivendell v2.9.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 ***
    Changes:
    Cart Notes Display. 'Cart Notes' information can now be displayed in
    the 'Edit Events' dialog in RDAirPlay.

    RDLogManger Command Line Enhancements. A '-P' switch has been added
    to prevent existing logs from being overwritten by batched jobs.

    Report Enhancements. Added a 'Classical Music' as-played report,
    as well as the ability to filter all reports on the basis of daypart
    range.

    New Scheduler Code Support. Added an '--add-scheduler-code=' switch
    to rdimport(1) and the ability to specify a set of scheduler codes to
    be added to new carts on a per-dropbox basis in
    RDAdmin->ManageHosts->Dropboxes.

    RDLibrary Cart Status Highlighting. Carts whose dayparting indicates
    a start time in the future are now highlighted in cyan rather than red.

    New RML. An 'Append Log' ['AL'] RML has been added.

    Full Disc Ripper Enhancements. The Full Disc Ripper ('Rip Disk' in
    RDLibrary) has undergone a major overhaul, now allowing for
    multi-track rips to a single cut and streamlined assignments of
    selected tracks to new carts.

    Various bug fixes. See the ChangeLog for details.

    Database Update:
    This version of Rivendell uses database schema version 239, 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:

    http://www.rivendellaudio.org/

    Cheers!


    |----------------------------------------------------------------------|
    | Frederick F. Gleason, Jr. | Chief Developer |
    | | Paravel Systems |
    |----------------------------------------------------------------------|
    | Do not try to think outside of the box. That's impossible. |
    | Instead, realise the truth. There is no box. |
    | --Quoted by "larsmjoh" on GrokLaw.net |
    |----------------------------------------------------------------------|

    _______________________________________________
    Linux-audio-announce mailing list
    Linux-audio-announce@lists.linuxaudio.org
    http://lists.linuxaudio.org/listinfo/linux-audio-announce

    read more

    June 05, 2014 07:00 PM

    June 04, 2014

    Hackaday » » digital audio hacks

    Keep those filaments lit, Design your own Vacuum Tube Audio Equipment

    Vacuum Tubes Glowing RedIt was a cold January Saturday night in Chicago and we had big plans. Buddy Guy’s Legends bar was packed. We setup directly under one of the PA speakers less than 15′ from the stage. Time to celebrate. Skip the glass, one pitcher each and keep them coming. We’re about to make bootleg recording history. Conversation evolved into bloviation on what our cover art would look like, certainly it would be a photo of our battery powered tube mic pre-amp recently created in my basement lab. We had four hours to kill before Buddy’s appearance. Our rate of Goose Island and Guinness consumption would put us at three-sheets to the wind by 11. Must focus. It’s time, Buddy was on. Much fumbling about and forgetting how to turn on the Japanese-made 24 bit digital recorder with its nested LCD menus, cryptic buttons, and late 90′s firmware. Make it work. We did, just in time for the bouncers to notice the boom mike and battery packs. Wait, wait… maybe we should talk about why tube amps are worth this kind of trouble first.

    Yes, vacuum tubes do sound better than transistors (before you hate in the comments check out this scholarly article on the topic). The difficulty is cost; tube gear is very expensive because it uses lots of copper, iron, often point-to-point wired by hand, and requires a heavy metal chassis to support all of these parts. But with this high cost comes good economic justification for building your own gear.

    This is one of the last frontiers of do-it-yourself that is actually worth doing.

    Vacuum tubes work by thermionic emission, meaning that electrons are emitted by something really hot under vacuum. In this case a lightbulb filament or a lightbulb filament that heats up a cathode metal plate encircling the filament. These electrons are accelerated from the cathode to the plate, thereby flowing current from the cathode to the plate. This current is controlled by a control grid, literally a small wire mesh between the cathode and the plate that looks like window screen. For practical purposes the grid is similar to the gate of a field effect transistor although the physics are completely different. There are some enthusiasts who actually make their own tubes from scratch.

    It is easy to get sound out of vacuum tube audio circuitry. Tube circuits lend themselves to self biasing and simple first-order approximations. Buy parts today and listen to Jimmy Hendrix by Sunday evening.

    How a simple single-stage tube preamplifier works

    vacuum tube pre-amp

    Preamplifier. An example of a 20 dB audio gain stage.

    The audio input is fed directly into the grid of V1, which is also shunted with resistor R1. R1′s job is to both pull the grid of V1 to 0V potential and also provide a termination impedance to the audio input (in most cases 50K or 100K). R2 and R3 set the gain and bias point. A simple approximation for voltage gain is R2/R3 assuming the tube has a ‘high mu.’ mu is a measure of transconductance or the tube’s ability to amplify, in other words current output/voltage input. Current flowing through the tube sinks a current across R3. This voltage across R3 while this circuit is idling (or not amplifying) is equal to the bias voltage. This configuration is known as ‘self biasing.’ Old-salt engineers will tell you that designing with tubes is easier than transistors. They’re right.

    The output is AC coupled with C1 to block the plate voltage from feeding into whatever this circuit is wired to. Like a single-stage transistor amplifier the output is inverted, a rising voltage at the grid results in a falling voltage at the plate.

    Power it

    tube power supply

    Schematic of 120 VDC power supply with regulation.

    You will need 50-150V of B+ (or plate voltage, because it is connected to the plate of the tube via R2) and about 1 mA to power this preamplifier. You can achieve this with the following circuit that supplies a regulated 120 VDC using zener diodes.

    try two preamps with ur favorite power amp

    With two pre-amps you can make a stereo preamp or ‘hybrid’ power amplifier.

    It is important to note that tubes are high voltage low current and from a conventional/modern circuit design perspective the resistors seem very high, caps low, and current regulation approaches amateur at best. This power supply works because we only need 1 mA.

    Make two

    Connect the inputs to your audio source and the outputs to your favorite solid state amplifier. We now have a ‘hybrid amplifier,’ containing a tube front-end and a solid-state back end. Professional versions of this amplifier are for sale by a large consumer electronics manufacturer.

    Take it on the road, a true story from my college experience

    Battery operated portable tube preamp.

    Battery operated portable tube preamp.

    So back to the story I started before. My bootleg conspirators and I were well lubricated and about to get the best recording of a live concert to date when we were stopped by the bouncers.  After a short interrogation we were booted out, back onto the cold streets but with a feeling of satisfaction that, although we did not record the show, we had the best audio gear in town:

    Schematic of battery operated tube preamp.

    Schematic of battery operated tube preamp.

    In this design, two pre-amplifiers described above are used with a battery powered high voltage supply. The high voltage supply works by creating a square wave with a 555 timer. This square wave is above audible frequency, around 40 Khz. The square wave is fed into a small audio power op-amp. The output of this op-amp is back-fed into the secondary of an audio output transformer, generating high voltage AC 170V at 40 Khz. This signal is rectified, filtered, and regulated in a conventional sense. The entire system runs on 8 AA batteries and should operate for approximately 4 hours continuously. Everything you need to make your own is here in this PDF.

    Power Amplifiers

    Eventually you may want to create a power amplifier. There are a number of classes and variants of tube audio power amplifiers:

    • Class B are push-pull amplifiers, similar to conventional solid state amplifiers, where there is a pushing tube and a pulling tube being driven 180 deg out of phase.
    • The class AB is biased so that the output devices are on all the time, thereby reducing or eliminating cross-over distortion which occurs when one tube hands the load off to the other.
    • Class A amplifiers are basically a high power version of our pre-amp above, where instead of resistor R2 we have an audio output transformer. Lots more power is burned needlessly in Class A amplifiers because they are always on, they either let go of the load or pull it closer to 0 potential. When not doing anything they sit half-mast, burning lots of power. Many prefer class A because there is no cross over distortion and they are very simple to design.
    • More obscure types of amplifiers include transformer-less, where lots of tubes are in parallel in a Class A configuration to directly drive a 4-8 ohm loudspeaker load.

    Almost all tube amplifiers require a transformer to match the high impedance of the tubes (3K or so) to the low impedance of modern loudspeakers (4-8 ohms).

    Block diagram of a typical tube power amplifier.

    Block diagram of a typical tube power amplifier.

    Feedback can be applied to all amplifier types, where just like an op-amp circuit some of the output signal is fed back to the input, allowing the amplifier to compensate for non-linearities. Feedback provides a much cleaner signal and improved performance. This is not always desirable depending on your goal. Without feedback expect on the order of 7% total harmonic distortion. With feedback and high gain expect 0.5% total harmonic distortion.

    power amp schematic

    Schematic of a class AB tube power amplifier with negative feedback.

    A typical tube power amplifier is a class AB with feedback. In this, there is a gain stage that also functions as the differential amplifier when feedback loop is closed. This is followed by what is known as a ‘phase splitter,’ which is basically a buffer or small amount of gain using two triodes providing both in-phase and out-of-phase output. The two outputs drive the output power tubes at 0 and 180 deg phase respectively. The output tubes push and pull on the output transformer. Tubes can only pull, so the output transformer is powered from a center tap on its primary winding. Finally, the output is fed both to a loudspeaker and through a feedback network to the first stage.

    A working example of this is shown in the schematic with details on its implementation (PDF).

    Tube home theater

    With these pre-amplifier and power amplifier circuits you can scale your design to a complete home theater system with 5.1 sound. For technical details of its implementation, check out this PDF. You can also check out my project which was featured early last year.

    mono_block_front Photo of vacuum tube home theater system. tube home theater block_diagram

    Let them shine

    quad power amplifier photo

    Four-channel power amplifier located at bottom of home theater system, this is simply four of the class AB power amplifiers described previously.

    Just like the reality TV shows where skilled craftsman make motorcycles or hot rods you too can customize the look of your tube amplifier. Place the tubes on the top of the chassis so you can watch them glow. Co-locate the output, power, and chokes on top as well. It’s fun to watch them glow in the dark while playing ‘Dark Side of the Moon.’

    Where to find parts

    Audio tubes are easy to find and continue to be manufactured in Eastern Europe, Russia, China, and others. Transformers of all types including audio output and power are readily available through Hammond Manufacturing and other sources. A new movement in the tube audio community is to find obscure pairs of output transformers and make single-ended non-feedback amplifiers. Recently, manufacturers have started to remanufacture high voltage axial leaded caps and other old-school parts. You can find this stuff at Antique Electronics Supply, Just radios, and even Mouser and Digi-Key (less expensive for same stuff but requires a lot of filtering and digging through the catalog).

    Learn fast

    There’s a lot of material on tube design, but these are my personal favorites:

    Try vacuum tubes in your next audio project. Keep those filaments lit.


    DSC_0318Gregory L. Charvat, Ph.D is author of Small and Short-Range Radar Systems, visiting research scientist at Camera Culture Group Massachusetts Institute of Technology Media Lab, co-founder of Hyperfine Research Inc. and Butterfly Network Inc., editor of the Gregory L. Charvat Series on Practical Approaches to Electrical Engineering, and guest commentator on CNN, CBS, Sky News, and others. He was a technical staff member at MIT Lincoln Laboratory from September 2007 to November 2011, where his work on through-wall radar won best paper at the 2010 MSS Tri-Services Radar Symposium and is an MIT Office of the Provost 2011 research highlight. He has taught short radar courses at MIT, where his Build a Small Radar course was the top-ranked MIT professional education course in 2011 and has become widely adopted by other universities, laboratories, and private organizations. Starting at an early age, Greg developed numerous radar systems, rail SAR imaging sensors, phased array radar systems; holds several patents; and has developed many other sensors and radio and audio equipment. He has authored numerous publications and received a great deal of press for his work. Greg earned a Ph.D in electrical engineering in 2007, MSEE in 2003, and BSEE in 2002 from Michigan State University, and is a senior member of the IEEE, where he served on the steering committee for the 2010, 2013, and 2016 IEEE International Symposium on Phased Array Systems and Technology and chaired the IEEE AP-S Boston Chapter from 2010-2011.


    Filed under: digital audio hacks, Featured

    by Gregory L. Charvat at June 04, 2014 02:01 PM

    Linux Audio Announcements - laa@linuxaudio.org

    [LAA] Aqualung 1.0-rc1 released today

    From: Tom Szilagyi <tomszilagyi@...>
    Subject: [LAA] Aqualung 1.0-rc1 released today
    Date: Jun 4, 11:57 am 2014

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

    Aqualung is an advanced music player for GNU/Linux (also running on other
    UNIX-alikes). It plays audio CDs, internet radio streams and podcasts as
    well as regular soundfiles in just about any audio format and has the
    feature of inserting absolutely no gaps between adjacent tracks.

    Aqualung R-1300 has been released today as 1.0-rc1, as the first milestone
    in an anticipated (short) series of release candidates leading to the final
    1.0 release of Aqualung. With this release, we celebrate 10 years of
    Aqualung!

    This release contains changes from the last 2 years and 4 months -- and, as
    you may imagine, has been long long overdue. It would not have been
    possible to make it to this point without the work of core devs Jamie
    Heilman, Jeremy Evans and Peter Szilagyi, as well as numerous contributors
    who sent us patches, bugreports, translations and encouragement. I would
    like to take this opportunity to thank all of you.

    A condensed selection of changes that went into this release is available
    in the ChangeLog, directly accessible at:
    http://aqualung.factorial.hu/ChangeLog

    The release tarball is available from SourceForge mirrors:
    http://sourceforge.net/projects/aqualung/files/aqualung/1.0-rc1/

    For further info please visit the Aqualung homepage:
    http://aqualung.factorial.hu

    Enjoy,
    Tom

    --089e0103defa2ed38104faf1297a
    Content-Type: text/html; charset=UTF-8

    Aqualung is an advanced music player for GNU/Linux (also running on other UNIX-alikes). It plays audio CDs,
    internet radio streams and podcasts as well as regular soundfiles in just
    about any audio format and has the feature of inserting absolutely no gaps between adjacent tracks.

    Aqualung
    R-1300 has been released today as 1.0-rc1, as the first milestone in an
    anticipated (short) series of release candidates leading to the final
    1.0 release of Aqualung. With this release, we celebrate 10 years of
    Aqualung!


    This release contains changes from the last 2 years and 4
    months -- and, as you may imagine, has been long long overdue. It would
    not have been possible to make it to this point without the work of
    core devs Jamie Heilman, Jeremy Evans and Peter Szilagyi, as well as
    numerous contributors who sent us patches, bugreports, translations and
    encouragement. I would like to take this opportunity to thank all of
    you.


    A condensed selection of changes that went into this release is available in the ChangeLog, directly accessible at: http://aqualung.factorial.hu/ChangeLog



    The release tarball is available from SourceForge mirrors:
    http://sourceforge.net/projects/aqualung/files/aqualung/1.0-rc1/



    For further info please visit the Aqualung homepage:
    http://aqualung.factorial.hu

    Enjoy,
    Tom


    --089e0103defa2ed38104faf1297a--

    read more

    June 04, 2014 12:00 PM

    June 01, 2014

    Recent changes to blog

    Guitarix gets LV2 support

    Within the latest development branch of guitarix, you can load now LV2 plugs into the racks. But there is no GUI support, guitarix will build the internal UI for the plugs in the same way it does for LADSPA and gx plugs. As well, no Extension support is added, only plain DSP plugs be supported.
    It extend the large list of usable plugs for the guitarix racks a bunch, and keep the philosophy of click-less, glitch-free, ultra fast preset switching alive.

    Rock on

    by brummer at June 01, 2014 04:35 AM

    May 29, 2014

    Linux Audio Announcements - laa@linuxaudio.org

    [LAA] Yoshimi V 1.2.1 released

    From: Will Godfrey <willgodfrey@...>
    Subject: [LAA] Yoshimi V 1.2.1 released
    Date: May 29, 8:10 pm 2014

    Tarball on sourceforge.

    There are a number of small tweaks under the bonnet, mostly to aid compilation.

    There are new drum sounds from Dario Straulino, and an alternative SVG desktop
    icon from Andrew Ter-Grigoryan (sorry it too so long).

    The most significant (although quite small) change is in settings - the option
    to enable a part when doing a MIDI program change.

    This means you can start up a 'bare' yoshimi, and, provided your banks are well
    organised, load whatever patches to whatever part you like, from any bank
    entirely from a sequencer, or suitably capable hardware synth/controller.

    Bank changes are always silent, and program changes are if you only change a
    part that is not actually sounding at that time.

    --
    Will J Godfrey
    http://www.musically.me.uk
    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
    Linux-audio-announce@lists.linuxaudio.org
    http://lists.linuxaudio.org/listinfo/linux-audio-announce

    read more

    May 29, 2014 09:00 PM

    May 28, 2014

    Create Digital Music » Linux

    Pianoteq 5 Improves Piano Modeling, Without Eating Up Your Hard Drive

    K2

    If you want a fake piano, you can have a fake piano. You can have increasingly-good models and samples in hardware, but you can really get a fake piano on your computer. You can buy entire hard drives just to store the gigabytes of samples. You can load massive instances of Kontakt with different recorded sounds for every note, every articulation. You can have new pianos, old pianos, countless Steinway samples. You can even have a ridiculously-tall upright.

    Or, you can have Pianoteq. Whereas others gobble hard drive space, Pianoteq uses sophisticated modeling techniques that skip the samples, meaning it can fit onto a flash drive. It’ll run on Linux – I’ve gotten it running convincingly on a netbook. And because it uses models, you can also load any number of wild and oddball historical models and other instruments if you like, without having to clear half your drive. You can modify the models to do impossible things.

    And most importantly, what I’ve always found with Pianoteq was a selection of instruments I really loved to play. Whatever comparisons you could make about sound, Pianoteq always felt alive in a way software instruments often didn’t.

    And now, following an aggressive cadence of releases, Pianoteq 5 makes the software new all over again:

    interface_bluethner_closed

    It sounds better. Gradually, slowly, Pianoteq has improved its sound. Now, the developers have gone after two of the most significant details – the attack of notes, and the way the soundboard resonates. It certainly sounds clearer, in a nice way.

    There’s a new K2 model. Here’s the thing: software models of pianos, whether sampled or using physical models or some combination, are becoming their own instruments. The Grand Piano K2, apparently modeled on the popular Kawaii, nonetheless combines several source instruments. I’d been mostly defaulting to the Steinway (never been a Yamaha piano fan), so I’m keen to spend some time with this one.

    Party. In Austria. Like it’s 1799. The Kremsegg Schloss Museum has devoted some new historical instruments. These are rather fun to try out with, especially with Pianoteq’s various point-and-click tuning models, even if you aren’t trying to reproduce 18th- and 19th-century music. In the mix this time: pianofortes J. Dohnal (1795), a J. Broadwood (1796), and grand pianos, including an I. Besendorfer (1829), an I. Pleyel (1835), a J. Frenzel (1841), an S. Erard (1849), a J.B. Streicher (1852) and a C. Bechstein (1899).

    all-microphones

    Better directional mic models. This wasn’t as much of a strong suit in previous versions, so it’s welcome – you get fifteen mic models for directional sound, and the ability to rotate them in 3D or attach them together, with polarity/proximity effect controls. In other words, this is closer to how you’d mic things in the acoustic environment.

    micros

    You can also buy the models you want, choosing acoustic, electric, or chromatic (think vibraphone). Additional instruments run you $59. I rather like having all of them, however, and it’s not a horribly expensive proposition – and as I said, takes up almost no drive space.

    I know Pianoteq can divide people: they either immediately take to it, or not. I’m absolutely in the former camp, utterly addicted to it, as one of the few instruments I demand on my machine at all times. But it’s easy enough to give it a try: there’s a generous free trial, and the best way to see if it’s for you is to play it.

    Enjoy:

    https://www.pianoteq.com/pianoteq5

    All that, and steelpans. Seriously, they have a lot of models in here. It's more than just a piano instrument.

    All that, and steelpans. Seriously, they have a lot of models in here. It’s more than just a piano instrument.

    One artist I know shares my passion for the instrument is Rutger Muller. His Von Nohrfeldt project is a fascinating contemporary classical – techno – ambient hybrid, miles away from even a lot of the post-classical music you hear these days. This is driving, jazz-inflected experimental electronic music deeply rooted in classical instrumentation and form. And so, for something very different from the Pianoteq sound samples, here’s his work (which I hope we cover in more detail soon; they’re doing some touring in festivals).

    http://vonnohrfeldt.com/

    Von Norhfeldt @ Facebook

    The post Pianoteq 5 Improves Piano Modeling, Without Eating Up Your Hard Drive appeared first on Create Digital Music.

    by Peter Kirn at May 28, 2014 05:46 PM

    May 23, 2014

    Talk UnafraidTalk Unafraid

    Tinkering with the RFµ-328

    The RFµ (or RFu, for the purposes of people being able to Google this without trying to type µ) 328 is a really neat little board from wireless vendor Ciseco. I picked one up for a project I’m doing where I need a low power microcontroller and some way to talk to a base station with power. This is basically what this board is – an integrated ~896MHz radio module and microcontroller. The radio module works as a serial link so it’s really easy to work with, and the microcontroller is the Arduino compatible ATmega 328 chip, complete with the Arduino Uno bootloader.

    There were some stumbling blocks I figured I’d document here, though, to get to the point where you can throw code at this thing and have it work, entirely over the air.

    First up – I’m doing this on my Windows box using a SRF Stick, a USB stick which shows up as a serial port in Windows. I had to go into Device Manager and set the baud rate there to 115200 baud, and disable hardware flow control (8N1 parity, of course). Next a bit of configuration is needed to set up the SRF Stick for remote over the air programming. Grab PuTTY or your favourite other serial terminal tool and point it at COM18 or whatever your SRF Stick has shown up as.

    Programming the SRF is simple – you type “+++” (without quotes) and wait for it to say OK. Then you enter the command, and hit enter. You have about 5 seconds after it says OK to get the command input, so you may prefer to paste it into PuTTY (right mouse button by default) from your clipboard. After those 5 seconds it drops out of config mode. The commands you need to run are, in order:

    • ATRP 1
    • ATRI –
    • ATRC 3
    • ATAC
    • ATWR

    These commands: enable remote reset, set the remote ID to –, set the channel to 3, apply the changes and writes them to memory. After this, unplug and plug in your SRF Stick. Next grab the Arduino IDE, set it to the Uno bootloader and point it at COM18 (or whatever your SRF Stick is). If you want some more info and details on how to do this on a Slice of Pi module or other non-USB module, look here.

    Now let’s prep the RFµ-328. You can connect 3V3 directly to pin 1 and ground to pin 10 (pinout) – how you’re wiring this up I leave as an exercise to the reader but in my case I used the Ciseco development board (having put the fine pitch headers in and soldered the module directly to those pins, to reduce the height of the device). I then had a Cisceo PowerPOD which is just a little 3V3 switching regulator to provide solid 3V3 out from my power source (a 3.6 nominal volts LiPoly battery with 1000mA of capacity).

    Once you’ve powered it  you’re basically good to go – the default config is set up to pass serial through to the µC directly with the ID of — on channel 3. You can configure it further if you like but that’s out of scope of this guide.

    Once you’ve got the device powered you probably want some sort of indication it’s working – so clip an oscilloscope or multimeter onto a pin, grab the Arduino ‘Blink’ program and hit upload. If it goes accordingly, you’ll see a pin wiggling as intended. Congrats, you’re up and running!

    There is one other trick which is that to use the radio for talking back, you’ll need to pull pin 8 high. This link has some example code for this – basically set pin 8 as an output and pull it HIGH before you do Serial.begin!

    It’s quite a nice little board (and it is tiny, which is great for space constrained projects). I suspect some power users might want something with a bit more flexibility to allow for  use of an external directional antenna but for low range low power stuff this is a good starting point.

    by James Harrison at May 23, 2014 07:42 PM

    Linux Audio Announcements - laa@linuxaudio.org

    [LAA] io GNU/Linux LiveDVD/USB ... You have an update available :)

    From: Manu Kebab <el.doctor@...>
    Subject: [LAA] io GNU/Linux LiveDVD/USB ... You have an update available :)
    Date: May 23, 5:22 pm 2014

    Hi all,

    I've uploaded a new iso of "io GNU/Linux", a LiveDVD/USB focused on multimedia
    (Debian based).

    Kernel 3.14.4 (64-bit only, 32-bit to come), Jack2 as default sound server,
    e18 as desktop environment and more nice stuff...

    For more infos: packages list, screenshots, video, howto etc... Please visit:
    -> http://manu.kebab.free.fr/iognulinux.html
    -> https://sourceforge.net/projects/io-gnu-linux/


    Enjoy :)

    MK

    _______________________________________________
    Linux-audio-announce mailing list
    Linux-audio-announce@lists.linuxaudio.org
    http://lists.linuxaudio.org/listinfo/linux-audio-announce

    read more

    May 23, 2014 06:00 PM

    May 22, 2014

    Create Digital Music » Linux

    Renoise Community Already Have Their Own Tool for CDP; Free, Easy Sound Mangling Results

    renoisecdp

    Not to be out-geeked, it seems that while BT is stumbling around the command line, the community at Renoise have built a free tool around the archaic sound-mangling goodness of the now-available-for-free CDP (Composers Desktop Project).

    For those of you just joining us – that’s a strange and wonderful tool that processes sound files into crazy distorted, morphed new forms in various ways.

    The Renoise forum is all over this, having used Lua to code up a front end that makes processing files part of the workflow in Renoise. It’s … kind of incredible. Thank UK-based user afta8 and other forum members, and follow the discussion:

    Idea, Now new Tool (3.0): CDP lua tool

    I hear various people gripe about forum readers who they claim don’t make music. But here, it seems, people have invested time in building a tool that really does help them make music, coding time paying dividends in sonic creations, and then take extra time to support other people making music. I think that’s admirable, regardless of where you sit on the geek spectrum. And as BT demonstrated in the video, there’s no reason to fear different tools for sonic exploration, if you love sound.

    I also wonder if BT might give Renoise a try now.

    The post Renoise Community Already Have Their Own Tool for CDP; Free, Easy Sound Mangling Results appeared first on Create Digital Music.

    by Peter Kirn at May 22, 2014 10:58 AM

    May 21, 2014

    GStreamer News

    GStreamer Core and Plugins 1.3.2 development release

    The GStreamer team is pleased to announce the first release of the unstable 1.3 release series. The 1.3 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. The unstable 1.3 release series will lead to the stable 1.4 release series in the next weeks, and newly added API can still change until that point.

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

    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, gst-libav, or gst-rtsp-server, or

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

    May 21, 2014 03:00 PM

    blog4

    Create Digital Music » Linux

    Watch BT Reveal Sound Design Tricks with Free, Geeky CDP – Then Learn it Yourself

    COMMAND LINE INTERFACE!!! BT)

    Put your hands up for the COMMAND LINE INTERFACE!!! 3 3 3 (um... photo courtesy BT)

    From the mysterious underworld of 80s sound software, it’s a library of free sound transformation tools so cool you’ll happily head to the command line to run them – no real-time preview to be found.

    No, seriously. Even if the fanciest you get is changing a preset in Logic, you want to hear about this.

    Self-professed addict of sound geekery BT took to a packed room at New York’s Cielo to tell an assembled group of aspiring producers why they should embrace the Terminal. His video is a fantastic introduction to the tool. Dubbed Composers Desktop Project – after the UK-based cooperative that maintains the tool – this is open source (LGPL) software for any platform you like that performs archaic alchemy on your audio files.

    But that’s not what’s important. What’s important is that the sonic results are brain-exploding in their transformational powers.

    Hosted by Dubspot, one of our favorite sources of knowledge (and now going multi-city as well as online), BT uses this as a centerpiece to a surprisingly deep-yet-beginner-friendly sound design workshop. Watch:

    About the software – there is actually a GUI, called SoundLoom. But much of what you want here primarily is simply a library of sound transformation and editing functions, which you can run from the terminal on OS X, Windows, or Linux. Downloads and documentation:

    http://www.unstablesound.net/cdp.html

    It’s not terribly user-friendly, so what you want is the two-part workshop series PDFs, which get much clearer.

    http://www.composersdesktop.com/workshops.html

    And these get into why this stuff is cool. Filled with audio examples, you get into the meat of what this is about. The basics are covered, but then you get into weird implementations of distorted repetition and re-pitching, spectral and stepped time stretching, odd transitions and morphing.

    None other than composer Trevor Wishart steps in for one of the workshops. And here’s why the texture program is cool:

    Here are some of the many musical result swhich can be achieved with this set of programs:
    o many ways to work with note events whose parameters are se-lected at random within (time-varying) user-defined limits
    o texture densities from widely-spaced to tight ‘granular’
    o timing scatter or quantisation controls
    o able to use the whole length of the input sound for each note event
    o multiple soundfile inputs accepted
    o can ‘snap’ granular densities to user-defined chords – or a changing set of chords
    o able to write legato or staccato melodic motifs o able to create canonic (imitative) effects
    o able to create motifs and attach them to pre-defined melodic lines
    o able to use a rhythm as the basis for a texture
    o can repeat rhythmic templates on which short motifs, melodic phrases or groups of note-events take place
    o you can work with groups of note events within the overall texture
    o most parameters accept time-varying contours
    o comes into its own when texture designs are matched to trans- formed sounds in order to create new (and sometimes serendipitous) sound complexes
    · In brief, the Texture programs combine aspects of mixing, sequencing, granulation, and collage.

    Sounds good to me. For more:
    http://www.dubspot.com/sound-design/

    On the dubspot blog: Sound Design Tutorial w/ BT Pt. 1: Digital Signal Processing Using Mac OS X Terminal

    http://www.btmusic.com/

    I’m curious, though, has anyone pondered porting this to a real-time implementation, much has been done with tools like Csound and Soundhack? (In fact, memo to self: would be kind of interesting to bundle these into a mobile app.)

    The post Watch BT Reveal Sound Design Tricks with Free, Geeky CDP – Then Learn it Yourself appeared first on Create Digital Music.

    by Peter Kirn at May 21, 2014 11:52 AM

    May 18, 2014

    Create Digital Music » open-source

    A Big Ass MIDI Cube with Hakan Lidbo, Live at MIDI Hack Stockholm [Video, Code]

    It’s a big-ass MIDI cube.

    Okay, sometimes the name kind of sums up all of it. But among various wonders at MIDI Hack Day here in Stockholm this weekend, “developer/designer/entrepreneur” Per-Olov Jernberg has teamed up with artist Håkan Lidbo to bring a giant, inflatable green cube into the offices of Spotify and transform is into a musical instrument.

    This is what I would have at my birthday parties if I could go back in time. Or, really, now. And you can, too, because code in Processing is already available. Good, clean fun – with oversized musical instruments, a recent fascination of Håkan’s work.

    The details:

    Using TI SensorTags (Bluetooth Low Energy Beacons) to detect the orientation of a large inflatable cube, send that data as midi to Ableton Live.

    Using:
    * TI SensorTags
    * Core Bluetooth (Apple’s framework, that is)
    * Objective-C
    * Node JS
    * Ableton Live

    Processing Sourcecode for all the different projects are available on github: https://github.com/possan/sensortag-midi

    hakanlidbo.com
    possan.se

    The post A Big Ass MIDI Cube with Hakan Lidbo, Live at MIDI Hack Stockholm [Video, Code] appeared first on Create Digital Music.

    by Peter Kirn at May 18, 2014 12:12 PM

    zthmusic

    Making of: Through the Wormhole

    Hi and welcome to this series on the making of the Lost Time EP. I will cover each song on the EP in a separate post, going through everything from the creative and the technical process, to collaborating with people … Continued

    The post Making of: Through the Wormhole appeared first on zthmusic.

    by zth at May 18, 2014 09:50 AM

    May 16, 2014

    Linux Audio Announcements - laa@linuxaudio.org

    [LAA] Rivendell v2.8.2

    From: Fred Gleason <fredg@...>
    Subject: [LAA] Rivendell v2.8.2
    Date: May 16, 5:37 pm 2014

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

    On behalf of the entire Rivendell development team, I'm pleased to announce
    the availability of Rivendell v2.8.2. 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 ***
    Changes:
    This is a maintenance release of Rivendell. It fixes several bugs,
    but provides no new functionality. Some of the fixes include:

    UTF-8 Character Handling. Improved handling of multi-byte UTF-8
    characters, especially in the RLM subsystem.

    More robust MPEG-1 import support (contributed by Chris Smowden).

    See the ChangeLog for additional details.

    Database Update:
    This version of Rivendell uses database schema version 234, 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:

    http://www.rivendellaudio.org/

    Cheers!


    |-------------------------------------------------------------------------|
    | Frederick F. Gleason, Jr. | Chief Developer |
    | | Paravel Systems |
    |-------------------------------------------------------------------------|
    | Obstacles are what you see when you take your eyes off the road. |
    | -- Anonymous |
    |-------------------------------------------------------------------------|

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

    On behalf of the entire Rivendell =
    development team, I'm pleased to announce the availability of
    ss=3D"">Rivendell
    v2.8.2
    pan>. =C2=A0Rivendell
    is a full-featured radio automation system targeted for use in=20
    professional broadcast environments. It is available under the GNU=20
    General Public License.



    >From the NEWS file:

    *** snip snip ***
    Changes:
    =C2=A0=C2=A0 This is a maintenance release=
    of Rivendell.=C2=A0 It fixes several bugs,
    =C2=A0=C2=A0 but provides no=
    new functionality.=C2=A0 Some of the fixes include:

    =C2=A0=C2=A0 UT=
    F-8 Character Handling.=C2=A0 Improved handling of multi-byte UTF-8

    =C2=A0=C2=A0 characters, especially in the RLM subsystem.

    =C2=A0=C2=
    =A0 More robust MPEG-1 import support (contributed by Chris Smowden).

    r>=C2=A0=C2=A0 See the ChangeLog for additional details.

    Database Up=
    date:
    =C2=A0=C2=A0 This version of Rivendell uses database schema versio=
    n 234, and will

    =C2=A0=C2=A0 automatically upgrade any earlier versions.=C2=A0 To see the c=
    urrent schema
    =C2=A0=C2=A0 version prior to upgrade, see RDAdmin->Sys=
    temInfo.

    =C2=A0=C2=A0 As always, be sure to run RDAdmin immediately =
    after upgrading to allow
    =C2=A0=C2=A0 any necessary changes to the data=
    base schema to be applied.

    *** snip snip ***



    Further information, screenshots and download links are available at:



    http://www.riv=
    endellaudio.org/




    Cheers!


    |------------------------------------------ [message continues]

    read more

    May 16, 2014 06:00 PM

    KXStudio News

    Introducing JackAss

    JackAss is a VST plugin that provides JACK-MIDI support for VST hosts.
    Simply load the plugin in your favourite host to get a JACK-MIDI port.
    Each new plugin instance creates a new MIDI port.

    Here's JackAss loaded in FL Studio:




    And an example setup in Carla for it:



    JackAss sends the notes from the host to its JACK-MIDI port.
    It also exposes 50 parameters, which send a MIDI CC message when changed.
    You can use this to easily control external applications that accept JACK-MIDI input and possibly CC for automation (like Carla).

    Additionally there's a JackAssFX plugin, which only exposes parameters to send as MIDI CC, in case you don't need MIDI/notes.

    JackAss currently has builds for Linux, MacOS and Windows, all 32bit and 64bit. Just follow this link.
    As a bonus, you also get special Wine builds - load it in a Windows application running in Linux via Wine and you get a real, native JACK-MIDI port from it!

    You can find JackAss source code and bug tracker in Github: https://github.com/falkTX/JackAss/.

    PS: Why JackAss? Because it outputs to JACK. ;)

    by falkTX at May 16, 2014 05:38 PM

    May 14, 2014

    Create Digital Music » open-source

    Play a Russian Folk Instrument with Your Mind, Or Turn Seashell Patterns, Likes Into Generative Art

    ::vtol:: “turbo-gusli” demo performance from ::vtol:: on Vimeo.

    Musical instruments: make a move, get a sound.

    Or, musical instruments: apply an algorithm, get a sound. Read the tattoos on your arm as a score, turn the black-and-white patterning of a seashell into generated audiovisual artwork, apply brainwaves to a folk instrument and let a robot play it…

    Such are the mental excursions of one ::vtol::, aka Moscow’s Dmitry Morozov. He’s been busy over the past year or so, wearing robots that interface with tattoos to make music and constructing surround sound umbrellas. And we still have more crazy-science goodness to share.

    The “turbo-gusli” or “gusli-samogudy” – top – takes a Russian folk instrument and has it play itself. Built with Arduino and Pd and inspired by the folk tale notion of a self-playing instrument, this robotic instrumental player reads your thoughts via EEG adapter.

    - servo motors x6
    - dc motor x1
    - stepper motor x1
    - solenoids x3
    - spings x8
    - strings x38
    - arduino uno x2
    controlling software – pure data

    http://vtol.cc/filter/works/turbo-gusli

    Via Animal New York’s Sophie Weiner, who’s been following this stuff.

    More, in videos:

    ::vtol:: “turbo-gusli” + emotiv EPOC neuro EEG headset from ::vtol:: on Vimeo.

    ::vtol:: “turbo-gusli” setup from ::vtol:: on Vimeo.

    turbo-gusli

    The EGOphone responds to online social interaction with glitchy musical serenades. Add Facebook, Twitter and VKontakte likes [VKontakte is second only to Facebook as the popular social network in Russia], and you get a sonic answer.

    ::vtol:: “egophone” from ::vtol:: on Vimeo.

    hardware:

    - servo motor
    - arduino uno
    - piezo disk
    - 2 channel sound system
    - luminescent lamp
    - relay

    soft:

    - Pure Data
    - Chrome

    http://vtol.cc/filter/works/egophone

    egophone

    Lastly, conus takes the possibilities of Cellular Automata – the famous generative algorithm – to a new level. Rather than directly working with the algorithm, it reads it from its natural habitat, scanning seashells and making visual and sonic output from what it sees.

    ::vtol:: conus from ::vtol:: on Vimeo.

    Pattern analysis – VVVV
    Video generators and processors – DIY Cellular Automata Video synth (code by critter and guitari), ::vtol:: tv-404
    Sound – DIY synths, Clavia Nord Modular g2, 6-channel sound system
    Other equipment – steel, motors, plastic, DIY microscopes and electronics.
    Special thanks to: Alexandra Gavrilova (stain.ws), Boris Kislitsin.
    Laboratoria Art&Science, Moscow, 2013
    Read More…

    Starting with a mollusk whose black and white patterns neatly follow the cell-by-cell rules of the algorithm, the artist makes the artificial out of the natural – or is that the other way around? Topping a metal sculptural creation with brightly-colored displays, the installation itself is worthy of the early Russian avant-garde, a mini-architectural tower of algorithmic output.

    conus_1

    conusshell

    I can’t wait to see what vtol does next. Catch him in a performance, opening, or workshop near you.

    http://vtol.cc/

    The post Play a Russian Folk Instrument with Your Mind, Or Turn Seashell Patterns, Likes Into Generative Art appeared first on Create Digital Music.

    by Peter Kirn at May 14, 2014 05:22 PM

    Scores of Beauty

    The Pleasantry of LilyPonding

    Sometimes I wonder why I work with LilyPond. Often it means investing many tedious hours in music typesetting, and any given small issue can take a lot of time and deep research to solve. Yet I still use LilyPond, and I love it. But why?

    Of course there are different answers to this; among them the “usual suspects” such as the beautiful engraving results and maybe the fact that I still feel at home writing my music as text. But recently I was pointed to yet another answer. I sat in a regional train and two young guys opposite me were talking about computer games they were playing. They made me realize why one would spend so much of one’s lifetime with LilyPond and actually enjoy it: it’s (also) a game!

    You’ve got some task set. There are obstacles to remove. Sometimes you encounter dead ends or leap to another level. There are hidden treasures in the docs or issue tracker. You may suffer disappointments or achieve success. In a sense you even have a number of lives, so you can actually lose a game occasionally – i.e. give up on a project. And the final reward is the score – of course the musical score and not the high score. :-) It’s like a melange of a logical puzzle and a strategy game, with the pleasant side effect that it is not just for fun, but you get a result which can be ported to “real life” and has an actual use for other people!

    Apart from the game aspect the pleasantry is also brought about by the artwork which continues to live in there, only it’s not crafted by hand or through mechanical processes as in earlier centuries, but through logics, computing, and (more or less industrial) printing. While working on your files you may enjoy the music you’re typesetting plus the beauty of Lilypond’s music engraving.

    So, given the variety of reasons which might make people stick with LilyPond, maybe it’s not as nerdy perhaps as it may seem…

    by Simon Albrecht at May 14, 2014 05:18 PM

    ardour

    Ardour 3.5.380 released

    Ardour 3.5.380 is (another) CRITICAL bug fix release. ALL USERS ARE RECOMMENDED TO UPGRADE. Additionally, ALL LINUX DISTRIBUTIONS SHOULD IMMEDIATELY UPGRADE/UPDATE TO THIS RELEASE. Distributing earlier versions of 3.5 at this point is irresponsible and risks our users' data.

    This release includes several absolutely vital fixes for bugs could lead to audio and MIDI files being irreversibly deleted from disk. We do not know precisely how these losses happened - no user ever found a reliable recipe to recreate all of them - but reports from several different users did lead to a careful code review which uncovered some potential for file loss. One very repeatable loss of a MIDI file after unlinking a copy of a MIDI region was very definitely fixed.

    There are a few other minor fixes and improvements described below.

    As usual you can download it from the usual place, and as usual subscribers get this update without cost. Thanks to everyone for their support (and encouragement).

    read more

    by paul at May 14, 2014 02:39 AM

    May 13, 2014

    Scores of Beauty

    Les fonctions musicales 4. La récursivité

    Traduction d’un article de Urs Liska

    Nous conclurons aujourd’hui cette série d’articles sur les fonctions musicales avec LilyPond. J’ai pris soin de prendre mon temps dans les explications, parce que c’est justement ce qui manque à la documentation de Lilypond – par ailleurs excellente. Disons qu’en son temps, j’aurais aimé avoir ce genre d’explications…

    Dans le premier article, nous avons vu comment insérer une fonction musicale dans les fichiers source LilyPond. Dans le second, nous avons commencé à écrire une fonction qui colorie une expression musicale donnée avec une couleur de notre choix, en ayant toutefois pratiqué du codage en dur et beaucoup de redondance. Le troisième article a été l’occasion d’aborder la factorisation et l’utilisation des listes. Nous n’avons pas pu atteindre notre but comme souhaité, ce qui sera fait dans ce quatrième article.

    Dans un commentaire sur l’article précédent, Jay Anderson nous a montré une solution qui ne nécessite pas le recours à la récursivité : j’ai toutefois décidé de continuer sur la lancée qui était la mienne, mais gardez en mémoire que ce que je propose dans ce quatrième billet n’est pas LA solution, mais une parmi d’autres. La solution de Jay est sans doute la plus concise bien que requierant de nombreuses autres connaissances, en particulier l’utilisation de variables locales, qui diffère complètement d’autres langages de programmation. L’utilisation de variables locales en Scheme devrait faire l’objet d’un article à part, voire d’une autre série d’articles.

     La récursivité

    Scheme est un dérivé du langage LISP – qui signifie « LISt Processing ». Le concept de listes, en Scheme comme dans tous les dérivés de LISP, est absolument incontournable. Aujourd’hui, je commence à en entrevoir les avantages, mais j’insiste sur le fait qu’il faut s’accrocher pour comprendre l’esprit de Scheme et, tant que vous n’avez pas intégré certains aspects spécifiques à ce langage, il vous sera difficile de vous en sortir. L’utilisation des listes fait partie de ceux-là.

    Pour résoudre le problème en cours, appeler la fonction colorierDesSymboles pour chaque symbole de la liste, nous ferions ceci en Python :

    for symbole in ma-liste-de-symboles:
        colorierSymbole(symbole, ma-couleur)

    ce qui peut être directement traduit en français par : Pour chaque symbole de la liste ma-liste-de-symboles, passer à la fonction colorierSymbole les paramètres symbole et ma-couleur. En Scheme, vous allez faire tout autre chose en passant la fonction récursivement.

    Les fonctions récursives sont des fonctions qui s’appellent elles-mêmes avec les paramètres modifiés. Le point très important est d’insérer dans le processus un point d’arrivée, sans quoi la boucle tourne indéfiniment. Le squelette d’une telle fonction est le suivant :

    • tester si on est arrivé à la fin et s’arrêter si cela est vrai ;
    • faire quelque chose avec les paramètres et appeler la fonction avec les paramètres modifiés.

    Utiliser la récursivité sur une liste, c’est la plupart du temps faire quelque chose avec le premier élément de cette liste et appeler la fonction sur le reste de la liste. Le test du point d’arrivée est là pour vérifier s’il y a encore des éléments dans la liste.

    Comme notre problème actuel est un peu complexe, étudions d’abord une fonction Scheme générique :

    #(define (affiche-noms ma-liste-de-noms)
       (if 
        ;; vérifions s'il y a encore des noms dans la liste
        (null? ma-liste-de-noms)
          ;; non : nous sommes en fin de liste.
          ;; on laisse une ligne vide et on arrête
          (newline)
          ;; oui : il y a encore des éléments à traiter
          ;; fabriquons une expression composée
          (begin
           ;; affichons le premier élément et insérons une nouvelle ligne
           (display (car ma-liste-de-noms))
           (newline)
           ;; appelons récursivement la fonction 
           ;; avec le reste de la liste
           (affiche-noms (cdr ma-liste-de-noms))) ;; fin de la section "begin"
          ) ;; fin de la section "if"
       )

    Voici donc une fonction Scheme nommée affiche-noms et qui a pour paramètre ma-liste-de-noms. Vous aurez noté que, contrairement aux autres fonctions que nous avons vues, celle-ci ne comporte pas de typage de paramètre ; c’est que le corps de cette fonction récursive sait qu’elle attend une liste. Les commentaires dans le code vous expliquent tout et complètent ce qui a été dit plus haut. Quelques remarques supplémentaires : pour que la section if puisse être fermée en Scheme/LilyPond, il faut lui ajouter des sections then et else, ce qui peut être omis dans d’autres dérivés Scheme. Aussi faut-il que vous soyez familiers avec les opérateurs car et cdr, ainsi qu’avec leur dérivés. car retourne le premier élément d’une paire ou d’une liste ; cdr retourne le second élément d’une paire, ou tous les éléments d’une liste excepté le premier – autrement dit le reste de la liste. En Scheme, on peut considérer qu’une liste est une paire avec comme premier élément le premier élément de la liste (car), et en second élément la liste des éléments restants de la liste (cdr).

    On peut maintenant appeler la fonction ainsi : #(afficher-noms '(NoteHead Slur Flag Beam)) et voir une jolie liste affichée dans la console.

     Application à notre problème

    Rappelez-vous, nous souhaitons écrire une fonction \colorierDesSymboles qui prend comme paramètre une liste de noms de symboles et une couleur. Dans l’article précédent, nous avons écrit le début de la fonction, sa signature. Nous allons maintenant profiter de ce qui est dit plus haut pour en compléter le corps. Cela donne :

    colorierDesSymboles =
    #(define-music-function (parser location ma-liste-de-symboles ma-couleur)
       (symbol-list? color?)
       (if (null? ma-liste-de-symboles)
           ;; donne une expression vide
           #{ #}
           #{
             % colorie le premier symbole de la liste restante (car)
             \colorierSymbole #(car ma-liste-de-symboles) #ma-couleur
             % appelle récursivement la fonction sur le reste de la liste (cdr)
             \colorierDesSymboles #(cdr ma-liste-de-symboles) #ma-couleur
           #}))

    Nous écrivons donc une fonction qui prend pour paramètres une liste de symboles et une couleur. Quand la liste à traiter est vide, elle renvoit une expression vide et la boucle s’arrête (c’est très pratique : on peut ainsi écrire une expression vide pour arrêter la boucle, ce que nous ne pouvons pas faire en pur Scheme/LilyPond). S’il y a encore au moins un élément dans la liste, elle appelle la fonction \colorierSymbole en lui passant le premier élément de la liste restante (opérateur car) et la couleur en paramètres, et appelle ensuite récursivement la fonction \colorierSymbole sur la liste restante privée de son premier élément (opérateur cdr).

    Il nous suffit maintenant d’écrire la fonction récursive \decolorierDesSymboles de la même façon. Je ne vais pas consacrer le reste de l’article à détailler cette fonction une nouvelle fois, mais vous pouvez télécharger l’exemple complet et inspecter le code.

     Nettoyons encore !

    Bien ! Nous avons réussi à créer cette fonction qui prend en paramètre une expression musicale quelconque et lui applique une couleur de votre choix. Mais je ne vous lache pas encore : il y a encore quelques améliorations à apporter concernant les bonnes pratiques de codage. Le premier point concerne encore un peu de factorisation, le second permettra de rendre la fonction un peu plus générique.

     Factorisons encore un peu plus

    Une chose qui me chagrine encore dans ce que nous venons d’écrire, c’est la répétition de certains bouts de code pour colorier et décolorer. Il serait judicieux de les regrouper en une fonction unique à laquelle on rajoutera un paramètre indiquant si l’on souhaite ajouter ou retirer la couleur.

    Tout d’abord, modifions \colorierSymbole en lui ajoutant un paramètre couleur-plus de type booléen. S’il prend pour valeur #t (True), c’est \override qui s’applique, sinon c’est \revert :

    colorierSymbole =
    #(define-music-function (parser location symbole ma-couleur couleur-plus)
       (symbol? color? boolean?)
       (if couleur-plus
           #{
             \temporary \override #symbole #'color = #ma-couleur
           #}
           #{
             \revert #symbole #'ma-couleur
           #}))

    La modification de \colorierDesSymboles est encore plus simple. Nous n’aurons pas besoin d’ajouter une nouvelle condition, mais juste de compléter la liste des paramètres avec le booléen couleur-plus, que nous passerons à \colorierSymbole.

    colorierDesSymboles =
    #(define-music-function (parser location ma-liste-de-symboles ma-couleur couleur-plus)
       (symbol-list? color? boolean?)
       (if (null? ma-liste-de-symboles)
           ;; donne une expression vide
           #{ #}
           #{
             % colorie le premier symbole de la liste restante (car)
             \colorierSymbole #(car ma-liste-de-symboles) #ma-couleur #couleur-plus
             % appelle récursivement la fonction sur le reste de la liste (cdr)
             \colorierSymbole #(cdr ma-liste-de-symboles) #ma-couleur #couleur-plus
           #}))
    

    Voilà, notre fonction générale appelle correctement la sous-fonction. Cela dit, pour enlever la couleur, nous appelons aussi \colorierSymbole avec le paramètre ma-couleur, alors que \decolorierSymbole n’utilisait pas ce paramètre ; ceci est incohérent. Normalement, il ne faut pas introduire d’incohérence en programmation, mais laissons cela pour aujourd’hui, d’abord parce que ce n’est pas très grave dans ce cas, et ensuite parce que cela ne va pas gêner l’utilisateur (il ne voit pas ce code). Une solution propre serait d’utiliser des paramètres optionnels qui feront l’objet d’un article ultérieur. Comme d’habitude, je vous fournis le code complet en téléchargement, et vous pourrez voir comment il faut faire.

     Utilisation d’une liste générique de symboles (grobs)

    La dernière chose à faire pour améliorer notre fonction concerne la liste d’objets musicaux à passer en paramètre. Elle n’est pas pratique à utiliser : il faut taper beaucoup de noms, et nous en oublions. Heureusement, LilyPond fournit un moyen de rendre tout cela générique : la fonction all-grob-descriptions. Elle retourne une liste de paires, chaque paire étant constituée d’un nom de symbole et d’une liste de ses propriétés. Utilisons maintenant ce que nous avons appris : map, lambda, car et cdr.

    Nous avons besoin de la liste complète des symboles, c’est-à-dire de la liste des premiers éléments de la liste all-grob-descriptions. Il nous faut donc faire map sur cette liste, et transférer les car dans une autre liste. C’est justement ce que fait map, souvenez-vous. Nous allons aussi utiliser lambda pour créer une telle fonction.

    (map (lambda (gd) (car gd)) all-grob-descriptions)

    C’est tout ! La fonction passée en paramètre de lambda récupère tous les premiers éléments de all-grob-descriptions et map fournit la liste de ces éléments. Nous avons donc récupéré la liste des noms de tous les symboles (grobs) de Lilypond ! Vérifiez cela en plaçant dans un fichier .ly :

    #(display (map (lambda (gd) (car gd)) all-grob-descriptions))

    et en compilant ce fichier. Vous n’obtiendrez pas un PDF, mais juste la liste dans la console.

    La dernière étape consiste à insérer cette ligne dans une nouvelle fonction Scheme et à l’appeler quand nous aurons besoin de cette liste de symboles :

    tousLesSymboles =
    #(define-scheme-function (parser location)()
       (map (lambda (gd) (car gd)) all-grob-descriptions))
    
    colorierMusique =
    #(define-music-function (parser location ma-couleur ma-musique)
       (color? ly:music?)
       #{
         \colorierDesSymboles \tousLesSymboles #ma-couleur ##t
    
         #ma-musique
    
         \colorierDesSymboles \tousLesSymboles #ma-couleur ##f
       #})

    Une remarque importante : l’utilisation de \tousLesSymboles ralentit significativement la compilation de notre fichier test. Je n’ai pas vérifié pour un fichier musique plus lourd, mais il vous faudra étudier, dans le cadre d’un projet plus vaste, s’il ne vaut pas mieux écrire une liste de symboles à la main plutôt qu’utiliser all-grob-descriptions.

    Voici donc le fichier final – bien plus concis que le premier ! – et la partition qui en résulte (identique à celle précédemment rencontrée, ce qui est normal !).

    \version "2.18.0"
    
    colorierSymbole =
    #(define-music-function (parser location symbole ma-couleur couleur-plus)
       (symbol? color? boolean?)
       (if couleur-plus
           ;; ou bien appliquer la couleur au symbole
           #{
             \temporary \override #symbole #'color = #ma-couleur
           #}
           ;; ou la retirer
           #{
             \revert #symbole #'ma-couleur
           #}))
    
    colorierDesSymboles =
    #(define-music-function (parser location ma-liste-de-symboles ma-couleur couleur-plus)
       (symbol-list? color? boolean?)
       (if (null? ma-liste-de-symboles)
           ;; donne une expression vide
           #{ #}
           #{
             % colorie le premier symbole de la liste restante (car)
             \colorierSymbole #(car ma-liste-de-symboles) #ma-couleur #couleur-plus
             % appelle récursivement la fonction sur le reste de la liste (cdr)
             \colorierSymbole #(cdr ma-liste-de-symboles) #ma-couleur #couleur-plus
           #}))
    
    tousLesSymboles =
    #(define-scheme-function (parser location)()
       ;; crée une liste avec tous les noms de symboles de Lilypond
       (map (lambda (gd) (car gd)) all-grob-descriptions))
    
    colorierMusique =
    #(define-music-function (parser location ma-couleur ma-musique)
       (color? ly:music?)
       #{
         \colorierDesSymboles \tousLesSymboles #ma-couleur ##t
    
         #ma-musique
    
         \colorierDesSymboles \tousLesSymboles #ma-couleur ##f
       #})
    
    
    ma-musique = \relative c' {
      c4. d8 e16 d r cis( d4) ~ | d1 \fermata
    }
    
    \relative c' {
      \colorierMusique #blue \ma-musique
      \colorierMusique #red { c4 c } d \colorierMusique #green e\f
      \colorierMusique #magenta \ma-musique
    }
    (Click to enlarge)

    (Cliquez pour agrandir)

    Comme vous pouvez le voir, notre projet initial, monolithique, s’est transformé en une série de petites fonctions ; nous pourrions encore factoriser et enlever les commentaires code. Ce procédé est courant avec Scheme : définir des fonctions de façon pyramidale, avec la plus générale à la base et les plus petites en tête de fichier. Cela est dû à la nature de Scheme qui manipule des expressions évaluées plutôt que des commandes exécutées. En Scheme, on n’écrit généralement pas des successions de commandes ou des boucles au sein d’une même fonction, mais plutôt une fonction qui appelle d’autres composants plus petits.

    Bien entendu – et cela est important aux yeux de bon nombre des lecteurs – cette fonction va par la suite être isolée dans un fichier à part ; le fichiers musical source y fera appel grâce à \include, de façon à ce que le code musical ne soit pas pollué par de nombreuses lignes de Scheme.

    Voilà, nous sommes arrivés à la fin de cette série d’articles. J’espère que vous avez eu plaisir à les lire et que vous avez appris quelque chose. Peut-être qu’écrire des fonctions Scheme vous fait moins peur désormais – ce sera en tous cas ma récompense ! Cela a été le cas pour moi, du moins. Personnellement, j’ai passé un cap dans
    l’utilisation de Scheme – et j’attends maintenant le prochain moment où je n’arriverai plus à coder des fonctions apparemment simples…

    N’hésitez pas à faire évoluer ces tutoriels grâce à vos commentaires, en posant des questions ou en ajoutant vos propres exemples. Et si vous avez des choses à dire sur ce sujet ou d’autres aspects de Scheme, contribuez en écrivant votre propre tuto !


    Commentaires après la version anglaise

    ming April 4, 2014 at 11:30

    Urs : Merci pour ce code très bien fait. Maintenant, je comprends mieux
    comment Scheme fonctionne, et cela va m’aider énormément la prochaine
    fois que je lirai du Scheme.

    Jay Anderson : les solutions n’utilisant pas la récursivité
    m’intéressent. Peux-tu nous donner un exemple soit par la liste de
    diffusion, soit sur le blog, pour expliquer aux débutants comment faire ?


    Réponse ↓
    Urs Liska April 4, 2014 at 11:31

    Jay a donné un exemple dans l’article précédent.


    Réponse ↓
    ming April 4, 2014 at 11:45

    Jay Anderson:
    Désolé je n’avais pas vu. Merci pour l’exemple en commentaire de l’article 3 !


    Réponse ↓
    Paul Morris April 4, 2014 at 17:14

    Belle série d’articles ! Quelques commentaires :

    1 — On peut simplifier :

    (map (lambda (gd) (car gd)) all-grob-descriptions)

    en écrivant :

    (map car all-grob-descriptions)

    on peut passer car directement à map sans l’envelopper dans une fonction lambda.

    2 — Cela aussi peut être simplifié :

    tousLesSymboles =
      #(define-scheme-function (parser location)()
      (map (lambda (gd) (car gd)) all-grob-descriptions))

    en faisant :

    tousLesSymboles = #(map car all-grob-descriptions)

    3 — Tu écris :

    pour que la section if puisse être fermée en Scheme/Lilypond, il faut lui ajouter une section then et else, ce qui peut être omis dans d’autres dérivés Scheme.

    Mais est-ce vrai ? Le code suivant fonctionne correctement sans section else :

    \version "2.18.0"
      #(if (= 0 0)
          (display "yes"))

    Réponse ↓
    Urs Liska April 5, 2014 at 13:47

    pour 1) et 2): Effectivement, j’ai constaté que cela marche, mais je ne comprends pas pourquoi. Si j’ai bien compris, (car all-grob-descriptions) est une paire constituée du nom de symbole et d’une liste comportant toutes ses propriétés et interfaces. Le car de cette paire est le nom du symbole. Je pensais donc passer la paire à la fonction lambda qui retourne le nom du symbole.

    pour 3): un peu plus tard…


    Réponse ↓
    Jay Anderson April 6, 2014 at 02:16
    pour (2) il faut savoir que car est déjà une fonction. Donc (lambda (gd) (car gd)) et car sont équivalents. il est donc normal que (map (lambda (gd) (car gd)) all-grob-descriptions)) et (map car all-grob-descriptions)) donnent le même résultat. Note aussi que cela définit le résultat de ce calcul en une passe. Tes problèmes de performance en seraient-ils résolus ?


    Réponse : ↓
    Urs Liska April 6, 2014 at 05:26
    Eh bien nous avons ici un bon exemple de la difficulté à comprendre Scheme en profondeur ;-)
    Ce qui m’a mis dedans, c’est que (car all-grob-descriptions) est lui-même une paire :

    (car all-grob-descriptions)
    (Accidental (alteration . #<procedure accidental-interface::calc-alteration (grob)>) (avoid-slur . inside) (glyph-name . #<procedure accidental-interface::glyph-name (grob)>) (glyph-name-alist (0 . "accidentals.natural") (-1/2 . "accidentals.flat") (1/2 . "accidentals.sharp") (1 . "accidentals.doublesharp") (-1 . "accidentals.flatflat") (3/4 . "accidentals.sharp.slashslash.stemstemstem") (1/4 . "accidentals.sharp.slashslash.stem") (-1/4 . "accidentals.mirroredflat") (-3/4 . "accidentals.mirroredflat.flat")) (stencil . #<primitive-procedure ly:accidental-interface::print>) (horizontal-skylines . #<unpure-pure-container #<primitive-procedure ly:accidental-interface::horizontal-skylines> >) (vertical-skylines . #<unpure-pure-container #<primitive-procedure ly:grob::vertical-skylines-from-stencil> #<primitive-procedure ly:grob::pure-simple-vertical-skylines-from-extents> >) (X-extent . #<primitive-procedure ly:accidental-interface::width>) (Y-extent . #<unpure-pure-container #<primitive-procedure ly:accidental-interface::height> #<primitive-procedure ly:accidental-interface::pure-height> >) (meta (name . Accidental) (class . Item) (interfaces grob-interface accidental-interface font-interface inline-accidental-interface item-interface)))

    Et je pensais qu’en le passant directement à map, je retrouverais à nouveau une paire. Mais ce qui se produit réellement est que map récupère chaque élément de la liste en paramètre et renvoie en paramètre à la fonction chacun de ces éléments. Donc map envoie toutes ces paires à car, et car se charge d’extraire les premiers éléments de chaque paire, donc le nom de symbole.


    Réponse ↓
    Urs Liska April 6, 2014 at 05:49
    OK ! grâce à tous ces renseignements je vais retirer tous les appels à allGrobNames et les remplacer par #(map car all-grob-descriptions) directement dans colorierMusique. De fait, le temps de compilation est réduit très significativement.

    Cela dit, j’ai réalisé que cette liste est générée deux fois et qu’il y a encore redondance et donc allongement du temps de compilation. Je devrais utiliser let. Pour ceux qui veulent comprendre, voyez le commentaire de Jay dans un futur article :-)

    La fonction principale ressemble maintenant à ça :

    colorierMusique =
    #(define-music-function (parser location ma-couleur ma-musique)
       (color? ly:music?)
       (let ((gd (map car all-grob-descriptions)))
         #{
           \colorierDesSymboles #gd #ma-couleur ##t
    
           #ma-musique
    
           \colorierDesSymboles #gd #ma-couleur ##f
         #}))

    Une autre piste serait de définir la liste des symboles comme variable globale calculée au premier appel de la fonction colorierMusique. Pour l’instant, elle est recalculée à chaque appel.


    Réponse ↓
    Ralf Mattes April 6, 2014 at 21:12

    Pour éviter de recréer la liste à chaque appel de colorierMusique, tu peux la calculer une bonne fois pour toutes lors de la définition de la fonction et la clôturer, de telle sorte que ta fonction musicale devienne une fermeture (closure).

    colorierMusique =
    #(let ((noms-de-symboles (map car all-grob-descriptions)))
       (define-music-function (parser location ma-couleur ma-musique)
         (color? ly:music?)
         #{
           \colorierDesSymboles #noms-de-symboles #ma-couleur ##t
           #ma-musique
           \colorierDesSymboles #noms-de-symboles #ma-couleur ##f
         #}))

    Tu éviteras ainsi de polluer l’espace de nommage global. Imagine que tu appelles ta variable GNoms etque quelqu’un définisse sa propre fonction qu’il appelle GNoms lui aussi.


    Réponse ↓
    Urs Liska April 6, 2014 at 22:12
    Merci pour cette solution. Cela semble être une bonne idée. Mais pourrais-tu expliquer plus en détail ce qui se passe ? J’ai compris que tu as créé une variable locale noms-de-symboles et que tu as défini la fonction à l’intérieur de sa définition. Mais je ne comprends pas ce qui se passe en dehors de la fonction avec
    ces variables et ce code.


    Réponse ↓
    Paul Morris April 7, 2014 at 21:41
    Belle technique ! Voici ce que j’aicompris : let est évalué, mais que retourne-t-il ? Il renvoie une fonction musicale. Dans cette fonction, noms-de-symboles a déjà été évalué quand let l’a été. Ainsi, la valeur de noms-de-symboles est donc effectivement incluse dans la fonction retournée et stockée dans la variable colorierMusique.

    Voir La fermeture informatique

    by Jean-Marc Legrand at May 13, 2014 07:23 AM

    May 11, 2014

    Csound

    MIDI Output Timing

    Poking around on the Web, looking for OSC-to-CV converters, I found this
    YouTube video:

    https://www.youtube.com/watch?v=pOeAzgHrPTk

    It appears to be only a prototype, however, using a piece of hardware called
    mbed. I don’t see any indication that the device shown in the video is being
    marketed.

    If I were going to use MIDI to connect a computer to something like the
    Moogerfoogers, I think I’d be tempted to use Pd rather than Csound. I don’t
    really care for the Pd graphic UI, but in its original incarnation Pd was
    created as a MIDI processor, so it’s a reasonable guess that the current
    MIDI functionality still has decent timing.

    by cskonopka at May 11, 2014 07:30 AM

    RIB-Csound

    I’ve spend the last few days hacking an open source framework called
    Rapid Interface Builder for Csound. I’ve modified the original project
    so that you can now build and bundle Csound packages directly. The
    idea here is that you write a Csound instrument and then design web
    page around it. When you have finished designing your page hit export
    and RIBCsound will export a complete .zip file containing everything
    need to run the Csound enabled site/web-app.

    You can find a video demo here:
    https://vimeo.com/80376134

    And you can try it out here:
    http://rorywalsh.github.io/RIBCsound/index.html

    And you can fork the code from here:
    https://github.com/rorywalsh/RIBCsound

    I’ve only provided support for sliders, or ‘range’ widgets for now but
    adding support for other GUI widgets shouldn’t be so tricky. Please
    fork it and notify me of any changes. The RIB app seems to be really
    well put together and I think it could provide a really solid chassis
    for a community driven web-enabled Csound IDE(perhaps we could call it
    CsChromizone!) . I can see lots of potential here for sharing
    instruments, adding modules, etc. Let me know what you think.

    Rory Walsh

    by cskonopka at May 11, 2014 07:29 AM

    Quasar Csound Installation

    http://dl.dropboxusercontent.com/u/2374752/csound/quasar.html

    by cskonopka at May 11, 2014 07:14 AM