I recently gave a 5 minute “microtalk” about Minim at an Austin IGDA event and included in it a couple examples using the new UGen framework. In fact, I wrote the presentation in Processing, but I don’t think it is really interesting enough to post the entire application. Instead, I pulled out the song I programmed for it as a standalone sketch. Check it out.
This Sound Byte gives you sliders to control the parameters of a GranulateSteady UGen, which allows you chop up a sound as it plays. I’ve created a loop from the song Again and Again by The Bird and The Bee, which will hopefully get annoying enough that you’ll want to chop it into indiscernibility. The buttons along the side let you set the range of the sliders from quite small, to a full second.
Eventually, we plan to add a UGen to Minim that will allow you to control the generating speed of any other UGen, but that got me thinking about how you might do something similar with existing components. So, I struck upon the idea of using an Oscil as a looping sampler by using an audio file as the Waveform and setting the frequency of the Oscil to be very low. The fun thing about this is that if you set the Oscil to a negative frequency, the sound will play in reverse. Additionally, I thought it’d be fun to be able to automate the changing of the frequency by having an LFO control the frequency of each Oscil (left and right channels of the original audio file). So here’s a sketch that lets you play with this setup:
I’m picking my way through Real Sound Synthesis for Interactive Applications by Perry R. Cook (one of the authors of the STK) and decided to start making small apps to demonstrate the different kinds of synthesis he covers in the book. This first one let’s you set the variables of a mass-spring-damper system and then trigger it, which is exactly the same as setting the coefficients of a two-pole IIR filter and sending an impulse into it (as it turns out). Check it:
I am happy to announce the arrival of Minim 2.1.0 BETA.
This is a beta build of the next release, which contains the new UGen framework developed by myself and Anderson Mills through his project at Numediart. There are still a few loose ends to clean up, primarily documentation related, but we expect to have everything wrapped by the end of June. Until then, feel free to give this build a whirl and see how you like the new real-time synthesis capabilities made possible by the UGen framework.
At this time, all of the documentation is in the form of Javadocs, which are included with the download. I hope that you find the docs for the UGen framework clear enough to get started. If not, there are also quite a few new examples included in the download that demonstrate how to use many of the UGens and how to programmatically sequence sound.
To install this release, you will simply unzip the archive into a folder named libraries in your sketch folder. This folder may already exist if you’ve installed other libraries not included with the Processing download; create the folder if it doesn’t exist. By installing this release in your sketchbook’s libraries folder, you will make Processing use this release instead of the release included with Processing. All of your existing sketches should still work. If you find one that doesn’t, please create an Issue on Github.
I’m working on a music app that involves using Midi to trigger audio. Yesterday I wound up in a situation where after adding a new Track to my Sequence, I wasn’t receiving any of the MidiEvents that I added to the track. The problem, it turns out, is that the default Java Sequencer appears to cache all of the Tracks in a Sequence when you initially set the Sequence on the Sequencer using the setSequence method. If you modify the Sequence itself, as opposed to modifying the contents of the Tracks in the Sequence, the Sequencer won’t know about it until you call setSequence again. Just thought I’d throw this little tidbit out there, in case someone else runs into the same problem. Here’s some code to illustrate my point:
// make a sequence
Sequence s = new Sequence(Sequence.PPQ, 4);
// make a track in the sequence
Track t = s.createTrack();
// add midi events to the track
// make a sequencer
Sequencer seq = MidiSystem.getSequencer();
// at this point, we can modify the Track
// and the Sequencer will pick up those new notes
// but if we do this:
Track t2 = s.createTrack();
// and then add notes to this track
// the Sequencer will NOT play these notes
// because it doesn’t know about the track we just created
// we have to SET THE SEQUENCE AGAIN!
// now the sequencer will play the notes in the track we just created.
Reas kicked me in the ass (via e-mail), so I updated the Minim Manual to reflect the Minim 2.0 API. I need to give a shout-out to Urban Giraffe for their WordPress plug-in Sniplets. This enabled me to pull all of the examples in the Manual directly from the online examples. This means that any time I update the online examples, they will be immediately reflected in the Manual. Rock, rock on, says I.
I’m pretty sure that I didn’t leave anything out, but if you spot any omissions, mistakes, or poorly written explanations, please let me know! I will endeavor to fix the problem as quickly as possible.
Also worth mentioning in this post is that Processing 1.0 is out! I can’t say I contributed much to its release, but its imminent release is what got me to finally cleanup and release Minim 2.0. One exciting detail I don’t think I’ve mentioned is that Minim is now one of the libraries that comes with the Processing download. I am very honored to have my library so closely tied to such an awesome project and I hope that people find working with Minim as easy as it is to work with the core Processing API.
While writing the example that I just posted, I discovered a couple nasty bugs that would have made a lot of people unhappy. For the curious, they were that the
getChannel method was not returning the correct channel when using
BufferedAudio.RIGHT, and that stereo
AudioSamples were only playing the left channel. All my tests thus far have used mono files, so that one just slipped past me. I’ve packed up a new release and updated the download page.
Kyle says, “Like what if I want to load up a sound and remove certain portions that fit some criteria or rearrange it (i.e., non-real-time processing)?”
What you want to do is currently possible to a certain degree using
AudioSample. It now has a method called
getChannel(int), which comes from the BufferedAudio interface. This method returns in a
float array the actual samples being used by the object when you trigger it. You can then manipulate those values and hear the change when you trigger it.
Example (view online)
size(512, 200, P3D);
minim = new Minim(this);
jingle = minim.loadSample("jingle.mp3", 2048);
// get the left channel of the audio as a float array
// getChannel is defined in the interface BuffereAudio,
// which also defines two constants to use as an argument
// BufferedAudio.LEFT and BufferedAudio.RIGHT
float leftChannel = jingle.getChannel(BufferedAudio.LEFT);
// now we are just going to reverse the left channel
float reversed = reverse(leftChannel);
arraycopy(reversed, 0, leftChannel, 0, leftChannel.length);
for(int i = 0; i < jingle.bufferSize() - 1; i++)
line(i, 50 - jingle.left.get(i)*50, i+1, 50 - jingle.left.get(i+1)*50);
line(i, 150 - jingle.right.get(i)*50, i+1, 150 -
// always close Minim audio classes when you finish with them
Egged on by the Processing 1.0 team, I spent today putting together a new release of Minim, which had been languishing on my computer. The lion’s share of the work was simply updating the examples and then uploading them. I really need to automate that process, it’s a big pain. Still not done: updating the manual.
A very important change to be aware of if you are upgrading, is that the
Minim class is now instantiable. All of the
get methods have been changed to regular old member functions, rather than static on the class. The static
start(PApplet) method has been removed, you must now pass your sketch into the constructor, like so:
Minim minim = new Minim(this);
AudioPlayer player = minim.loadFile(“blah.wav”);
A very cool addition is
AudioSample. The ability to read the ID3 tags from mp3 files was always there in the package I use for playing those, but I didn’t hook it up initially. Now all the tags you probably care about get stuffed into an
AudioMetaData object when you load a file. Check out the online example.
An interesting implementation change is that I’ve broken out the Javasound specific code from the generic audio abstraction layer code. This means that there is now a package called ddf.minim.spi, which defines a bunch of interfaces that Minim uses to load files and acquire inputs and outputs. The key interface is
MinimServiceProvider, which looks a lot like a slimmed down version of Minim’s interface. It is now possible for you implement
MinimServiceProvider and then pass an instance of your implementation into the Minim constructor. Minim will use your implementation for all audio resource acquisition. This means that the default implementation, which uses Javasound, does exactly that and lives in jsminim.jar, which is included with the distro. One of the reasons that I did this was so that I could easily write an implementation of Minim that uses an FModEx Java binding. Work has begun on that, but it is not yet finished. Still, something to look forward to!