#plpheads

Deep in the modular trenches of bidule

ChannelStripStereo

If you’re wondering what comes after Heads, it’s DAPS.  DAPS stands for Digital Audio Performance Station (think DAW for performance).  That’s all I’m going to say about it for now.  But considering I’m in a sharing mood I just uploaded the ChannelStripStereo group which comes from my DAPS to github.  It’s a 3 Band EQ and Compressor group.  The compressor section is sourced from the ds_Comp by Dano.  I’m probably going to be doing a lot more with this in the future, so this is it in its most basic state.

Get the ChannelStripStereo group from the github repository.

5

imlr: First Look

by Primus Luta

It’s been a long time since I’ve updated either this blog or the tutorial series, and considering how much work I’ve actually done in that time I’m starting to feel a little guilty.  So in an effort to dissuade some of that guilt I just posted up the imlr group to the github repository.  It comes with no tutorial, no video, and no instructions.  But if you’ve done the other parts of the tutorial which currently are online you should be able to open it up and figure out what’s going on.  Here’s a screenshot of the GUI:

imlr

imlr is a single row of the nsMpLR.  nsMpLR is a modified rebuild of the original mlr application built by tehn.  Where nsMpLR differs is that it’s much more focused on the idea of sampling rather than looping.  Each row represents a long sample and the individual columns in the row allow you to isolate sounds ‘in’ the sample.  nsMpLR uses four imlr groups combined with a controls and a sequencer.  To be honest imlr on its own is a bit ho-hum unless you are interested in how things work.

To make it work though, you’ll need to have a MonomeControl group (start of tutorial in this link, group is in the repositroy) in your layout, sending all of the OSC data.  Then you’ll need something sending a ’1′ to the first input of the imlr.  In the nsMpLR this first input is the page input saying that you are currently on the page in which the nsMpLR is running.  The second input is a bang. Choose a sample, and change the ID# to represent the row you want the sample on. Now if you start pressing buttons in that row it will trigger the sample from the appropriate position.  If you open up the slices window you can change where in the sample each of the buttons trigger.  There are ADSR controls and a smoother for preventing annoying clips when jumping around.  Note this is not designed as a looper so if that’s what you’re looking for, it’s not going to be readily accessible.

Now if you want to really dig into it you will find quite a few gems. You can turn it into a looper by going inside and checking one little box on one little group, but I’m not going to tell you that *evil grin*, try to figure it out for yourself.  You’ll notice some of the groups inside of it are muted.  Two of them are pitch controls managed (for now) in the nsMpLR group.  The last one is the ColValSeq which is a part of the sequencer engine for nsMpLR.  Definitely worth checking out if you’re really into the how things work side of things.  Also worth noting is that in the broader group, just about every function in the GUI is controllable from the monome.

You can get the imlr group from the plpheads repository on github.

0

So as the tutorials move into the second section we start getting into the heartier parts of the series.  Section one was really about getting familiar with the environment and how communication within it works, but now we’ll start focusing on how to utilize it to create the cool stuff.

To start out in section two we will be building our Control Center.  This group will be the nucleus of all of the instruments we create sending critical information across layouts and even plugin instances to keep all of the instruments working together.  

The first tutorial of this section will explain how to build a simple metronome which will be our time clock when working with Bidule in standalone mode.  This simple group will be quite useful not just for Heads Instruments but for any time dependent layout you might build in Bidule.

The second tutorial focuses around a method for transmitting information which will be managed in the Control Center to all other groups and instruments without the necessity of endless cabling.  In the past I’ve had groups with up to twelve inputs and outputs in order to pass all of the appropriate information around.  Needless to say managing those proved to be quite tedious, and so I came up with a way to use OSC to minimize the amount of cabling.  The really amazing thing about this method is that it is broadcast across the network so that you aren’t locked into the singular layout for the sharing of this information.  This becomes particularly useful when working with Bidule as a plugin as multiple plugin instances can all be synced to the same information.

These first two tutorials of this section are online now.  As we move forward, the next steps will be to translate our metronome into a visual display on the monome and create a paging system for loading multiple instruments simultaneously.  Stay tuned.


That’s basically the way I was introduced to Open Sound Control.  It was (is) going to be THE protocol for digitla music connectivity.  That’s a pretty big statement, and when I first heard it I was quite skeptical.  I mean MIDI is a mainstay, but having been developed long before the digital revolution completely changed the face of music, it has many limitations.  Of course there’s always the possibility that a MIDI 2.0 protocol will pop up one day, but in the meantime, looking to the future OSC seems to be well on its way to establishing itself as the “Sound Control” standard.

So what is it that makes OSC so different from MIDI.  Well the primary thing is that it is based on network protocols, the backbone of computer connectivity in this digital world.  But beyond that it presents a level of flexibility which simply leaves MIDI in the dust.  Where MIDI is confined to a limited (albeit extensive) message set, OSC is designed to be open so that the messages can be defined by hardware developers, software developers, and even the user.  What OSC can control is literally only limited by the imagination of the user.

Recently the iPhone and its OSC support has taken the protocol mainstream, but there have been a number of both hardware and software developers who have been ahead of the curve in OSC.  With the rise of iPhone applications using OSC one can only predict there will be a rise in OSC in the coming years.  Indeed one of the biggest limitations in the past of OSC is that development has been restricted to ths small set of hardware and applications that support it.  But with Hardware from Jazz Mutant and soft-synths like Circle Synth popping up with OSC support, I invision a future where full studio setups are communicating to each other via OSC the way they do now with MIDI.

But enough about the future, for right now there’s still a lot that can be done with Open Sound Control, and the Bidule tutorials is now ready to start showing you how.  The fourth tutorial in the series is now online providing an introduction to using OSC in Bidule by setting up the OSC Servers to support monome communication.  The majority of the tutorials from this point forward will be built on this OSC foundation, though I will be adding a new section for non monome related tutorials as well to supplement.  I hope you enjoy it and the rest of the series.  If you’d like to learn more about OSC be sure to check out the introduction page over at OpenSoundControl.

I decided to augment the Bidule Tutorial Syllabus just a bit to include a lesson on the creation of one of my favorite groups – MSE|D or Mid-Side Encode|Decode.  This was one of my earliest experiments in Bidule.  At the time I was working on a few mastering projects and falling madly in love with the TC Electronic MD3 Plugin.  The MD3 is considered one of the top in the box mastering compressor/limiters and one of the reasons for this is its Mid-Side capabilities.

With the MD3 you can take your audio signal and split it into its Mid-Side equivilent.  These signals can then be processed with the compressor/limiter processing in the plugin before being decoded back to stereo.  With this you are able to add compression to the Mid and Side signals indpendently allowing for tailored compression of the stereo image.  It is a really powerful tool, albeit a bit on the expensive tip.

It was based on this that I started experimenting to see if I could create the Mid-Side encode and decode groups in Bidule so that custom effects processing could be inserted between the encode and decode stages for even more tailored processing.  The results were pretty amazing.  Using Bidule as a plugin the group can be added into pretty much any signal chain from individual tracks to final mixes.

The latest tutorial I’ve posted breaks down how to build this basic group.  With the basic group you can then tailor your signal chain to your own arsenal of plugin utilities.

Creating a Mid-Side Encode Decode Group

If you haven’t seen it already the first tutorial Direct Cabling and Your Default Layout was posted a couple of weeks ago.  I just posted the second tutorial Parameter Linking – Building the TrigIn and abc Groups.  These both go over some basic concepts and introduce some of Bidule’s Building Blocks.  There’s no monome material in these tutorials, but that is on the way, just check the syllabus.  I’ve actually got a tutorial on creating M/S (Mid/Side) Encode and Decode groups which I’ll add to the syllabus for the next lesson.  Lots of great stuff in store so stay tuned.

The Latest Version of Bidule features an OSC Monitor and WaveViewer

The Latest Version of Bidule features an OSC Monitor and WaveViewer

Today if you go over to the Plogue site you will see the announcement for the latest release of Plogue Bidule.  In addition to a number of bug fixes there are some amazing updates which have gone into this latest release.  On the eye candy side of things Bidule finally gets a waveform viewer module with the WaveViewer shown in the image above.  Additionally there is a new Audio Buffer module which also visualizes the Waveform.  Great additions to the Bidule arsenal and also a good indication of more visual goodness to come.

In its ever growing commitment to fully support OSC, a new tool has been added for monitoring OSC communication.  The OSC Monitor behaves like many third party options, showing not only the OSC messages sent by and to Bidule, but also picking up any additional messages being transmitted as well.  A great resource when trying to get multiple OSC enabled devices or pieces of software communicating with each other.

Perhaps the biggest update of all in this version is the introduction of Multi-Core Processing support up to 8 Cores.  Previous versions of Bidule only allowed for processing on two cores, but now the MP Assign command lets you not only utilize up to 8 cores but also select which processors you’d like to use.  As a bonus there’s also a new DSP Adapter function which allows you to run a limited set of modules at a buffer size of 1 sample.

All an all it is a very welcome update.  As with all publically released versions, this one comes with a time sesitive trial period, for new users to explore Bidule over the next three months without purchase.  Simply make your way to the Plogue site to download this version today.  If you’re looking for encouragement, also starting today, I’ve launched the first tutorial in a series which will be utilizing instruments that I’ve developed in Bidule for the Heads Project as examples.  The series will be starting from the most basic concepts and progressing toward the more complex over the next months.  If you’ve ever wanted to get your feet wet in Bidule now would be the time.

Lastly I had the extreme pleasure of having a conversation with Sebastien Beaulieu, co-founder and lead Bidule developer over at Plogue.  He gave me some great insight into the origins of Bidule, the business and development model of Plogue, and some ideas of what we can expect in the future.  You can read the full interview here on CDM.

I’m starting this today having completed mixing the album for The Heads Project.  If you don’t already know, The Heads Project is a body of music, the majority of which was composed using a set of instruments developed in bidule for the monome.  The recording of the project itself is a hybrid of these instruments with more traditional (and not so traditional) instrumentation, but all of the songs themselves come from ideas which were born from the Heads Instruments.  More detailed information about the Heads Project will be released through my personal AvantUrb site.

Over the coming months we’ll be releasing a lot of media about the process in creation of this body of work, but here specifically we’re going to focus on the instruments themselves.  By following along, one will not only get a first look at the inner workings of the instruments, but will be guided through tutorials on how to build them.  My intent is to go one by one through each instrument and provide the step by step instructions for recreating it, culminating in the final release of the instrument itself.  Even further, while this can be seen from a tutorial perspective, the whole thing will be open, and so if one is active with the lessons it is quite possible that they could end up contributing to the final instrument.

My rationale for releasing the instruments in this manner is two fold.  First is my sincere desire to share what I’ve learned in the three years I’ve spent developing these instruments.  It is my hope by putting this out there, more people will get involved in the Bidule community, that we might continue to push the bounds of possibility in one of the most flexible modular audio environments out there.  It is easily the most organic software that I’ve ever had the opportunity to work with and a large part of that is because of the communal nature of development.  Since I began I’ve literally seen it evolve around the desires of the community, including my own for this project.  It is my hope that by growing that community the evolutionary possibilities will too grow, helping the platform reach its potential not just for today but for the next decade.

Altruisms aside, a large part of this will be to help me get the instruments themselves to releasable states.  As I said above the album has been mixed, and it uses the instruments, however none of them were recoreded in their completed versions, but rather, at best buggy alpha versions.  They still sound great, but for the actual release of the instruments I’d like them to be somewhere closer to perfect.  By recreating them each for this space, it affords me the time to optimize, clean-up and even improve upon them.  Doing so publicly will also allow for feedback and input from others so that each instrument can reach its maximum potential.

If you are looking to fully participate in this series you will want to create an account over at github.  All of the collaboration and release of source will be managed through the plpheads repository.  If you would like to contribute, I will have to add you as a collaborator.  Please visit my profile and send me a message if you would like to be added as a collaborator.  There is currently nothing in the repository, but groups will begin being added there starting with the second tutorial.

The best ideas hopefully won’t be the ones that are covered in this series but the ones it inspires.  Here’s hoping you’ll come along for the ride, and possibly will be one of the sources of those new and wonderful ideas.

If you don’t know, bidule is the other modular audio software.  You know the one with the crazy initiation involving candles, hoods and a scientific calculator.  I know, I know you thought all the rituals were just a conspiracy theory, but I’m here to tell you they are true.  And that’s before you purchase the early-bird license, I won’t even get into the crazy things they make you do after.  But I will say its well worth the body branding and I’m going to use this blog as a way to not just tell you but to show you.

For the past three years now I’ve been locked in the catacombs working on a project that takes bidule by the ram horns and really runs with it.  The result of which is a secret audio elixer which if taken on a specified day will open up a gateway to nirvana, I hope.  At the very least it will lead to the fountain of teen spirit, where you’ll remember what it was like to build mod, or patch your first analog synth, or whatever it was that first lured you into the underworld of audiophilia.  But that’s getting way ahead of ourselves.

A main goal of the blog will be to provide a step by step map through bidule which starts from an empty layout to full instruments.  Along the way I’ll impart some of the wisdom I’ve learned since my initiation into the finer ways of biduling, and at the end of it all…. okay I’ll tell you a secret which I’m probably not supposed to tell you [... grand dragon edit] – 42.

To whet your apetite have a look at the first two PEMF Sessions, a separate but related series about these instruments and the project they were built for.