Polyphonic Synthesizer w/ poly ADSR

Currently designing the next generation generative music machine for mobile (especially iOS), I needed a way to trigger not only the pitch & velocity of a note to a polyphonic system, but also the amplitude envelope.

I’ll use libPD for this one too.
So yes, I’m using Pure Data too and not only max6 .. but it is the same family, even if there are many pure data nerd trolling a lot about max6.
Let’s prefer to spend time on using and making beautiful things instead of dividing people.
So, yes, I LOVE both pure data & max6 (and even reaktor!)

Why a need of polyphonic synth with an adsr for each event triggered ?
If the usual polyphonic stuff implement a way to trigger multiple note to may voices, each note having its pitch & its velocity, how can we do if we want different amplitude envelope for each note triggered ?
It is absolutely not native in the poly object in pure data (and in max6)

In my generative music machine, I need to send an event including pitch, velocity, attack, decay, release & sustain.
That way, I can control the whole sound triggered, firing some events more percussive, some other more smooth with a longer attack.

How I did that ?
So, after to have questionned here & there if there wasn’t something more native, more efficient, I designed mine which is quite efficient and indeed, it does the job well.
Even if I didn’t use their ways, I want to thank fp from the Cycling 74 forum and mod from puredata.hurleur.com forum.

One schematic is better than 100 words.
Here it is :

You can download it here
I packaged all in order to make an easier way by copy pasting the objects, but, of course, you’ll have to save the patch inside the orange square as voice.pd, then, to reopen the main one.
You’ll also need the adsr abstraction. Mine is inspired by the one here

Tech Café à Marseille ?

Hello à tous et surtout aux marseillais!

Je voudrais vous proposer des moments informels d’ open discussions autour des technologies que l’on utilise.
Pour ma part, on peut parler de:
- openframeworks & C/C++
- audio DSP
- arduino et arduino-like et électronique
- Pure Data & Max6
- Stratégie de développement agile pour sound applications sur  iOS
- Ableton Live / Max for Live / Reaktor et Sound design

mais aussi
- ambient music
- entrepreneurship moderne
- vie d’artiste digital
- zen coding
et + + +

L’EVENT est ici: https://www.facebook.com/events/353319924704264/

Si vous êtes intéressés, sachant que je bosse souvent à l’extérieur (café en ville, coins sympas), je peux vous proposer un time slot de 2h par semaine sur lequel vous venez, on fait connaissance, on teste, on bricole nos laptop etc.

L’EVENT est ici: https://www.facebook.com/events/353319924704264/

Teasing The Granulizator for Live

You know me.. I’m one of those never really happy with tools I found before.
As a huge diy guy, I decided (again) to build my own granulator machine.
This one has that grain I wanted, I needed for my own music.

RELEASED HERE
I named it The Granulizator because it sounded & sounds fine, no?
My friend (and almost partner) Tristan Heau suggested Sound Blender. I loved that too.Though, I wanted to keep a reference to the grain, this small element you’ll love to manipulate with this device for Ableton Live / Max for Live.

Here are 2 sound records I already publish in a previous post

Here is the video I made.

I have to say something too.
I will compose an ep exclusively with it.
I really like textures I can make and it deserves to be explored further.

It would be released soon, probably as usual on saturday evening.
Stay tuned on the newsletter & twitter.

A very early prototype…

Prototyping a drone machine driven by a processing script providing particles movements.
The sound engine is made with Max6.
The communication between the controller part & the sound engine is made using Open Sound Control protocol.

My purpose, here, is to make a prototype for further targets, one target being iOS.

Ability to cleanly destroy LiveAPI’s callbacks ?

I initiated a post on the Cycling 74 forum.
It was about the fact that if you instantiate LiveAPI objects, setting up callbacks, through javascript, I had doubts about how those callbacks could be cleanly, I mean: with a REAL memory liberation, destroyed and garbage collected.

Indeed, javascript’s Max implementations provide all stuff from classic javascript.
It means the garbage collector is also totally working.

So, if I want to make a LiveAPI call (instantiation) from javascript, I can do that:

trackObject= new LiveAPI(this.patcher, “live_set tracks 5″);

This row call the object in the LOM and “put it” in trackObject variable, basically for further access.

I can also do that:

trackObject= new LiveAPI(this.patcher,track_callback,”live_set tracks 5″);
trackObject.name = trackObject.get(“name”) ;
trackObject.property = “name”;
function track_callback()
{
post(“The track 5 is named:” + this.name;
}

This piece of code instantiate an object and observe if something changes and react by doing something.
Here, if the name of the track 5 changes, the callback is executed and pops out the new name.

If trackObject is out of scope (I mean, NOONE calls/runs the part of the code where it has been declared), the javascript’s (precious) garbage collector destroy and free the part of the memory where there was this variable.
It works.
BUT the problem is on the LiveAPI (and Live) side.
How could I be sure the callback is totally collected ?

Especially, I have been surprised by using the same piece of code by creating a HUGE table of LiveAPI objects, using callbacks and other stuff.
The Memory was a bit … busy and even the CPU (callbacks were working)

So I decided to … basically as I used to do in javascript: to try:
- myArray.length = 0; (this totally weird tip works fine usually)
-  myArray = null; (no comment)

Nothing worked fine BECAUSE there were those callbacks still working or even sleepy zombified or ?!

So the question became: How to really free memory from this callbacks ?

Tom answered and give an important information in the thread I began there.

cb_private seems to be a property for all LiveAPI objects (I guess it is trivial for those which don’t have a callback)

So, inside the callback, Tom suggests to add

delete liveAPIObject.cb_private

Where liveAPIObject is the related object for which you need to free the memory addressed for the callback.

Let’s test that in case we need it.

I suppose C74′s dudes will answer soon, but it is a nice news/clue/tip to test.
 

Max 6.0.4 update

Announced right now, Cycling 74 just popped out the latest update: 6.0.4

The official changelog is here.
We can all download it here.

And the HUGE news is: the new Max 6.0.4 SDK and the 1000+ pages documentation PDF are released !

Here are the new features announced:

• attrui: tab key support
• filterdesign: double-click to see dictionary
• Gen: GenExpr include files
• jit.anim.node new features:
  - new messages: concat, worldtolocal, localtoworld
  - new attribute: invtransform
• jit.gl.cornerpin object
• jit.phys.* new features:
  - @enable attribute
  - physics constraints now have rotate/rotatexyz attributes
• jit.phys.world new features:
  - attributes for simulation updates
  - remove_plane attribute for 2D functionality
• sqlite: faster database update startup
• standalone: improved dependency inclusion for some components

Here are the (huge fix list):

• audio: fixed start/stop UI delay glitch
• audio: closing patcher window now fades properly (Mixer Crossfade)
• audio: clicking then silence / crashing when changing audio settings
• audio: fixed crash when turning mixer parallel on/off when signal vector size is smaller than 64
• audio: hot-swap devices without needing to restart Max
• audio: patcher muting respected when audio started
• audio: fixed deadlock when closing a patcher with the Audio running
• preferences: fixed crash on corrupted Windows preference files
• cascade~: fixed zipper noise on coefficient change
• cellblock: resizing the object refreshes properly in in-line edit mode
• codebox: require disposes of filewatcher when closed
• codebox: retains inlet/outlet count even with an error with GenExpr
• cycle~: proper handling of attrs/args
• dac~: start/startwindow in right inlet
• dialog: text field does not have focus (Mac OS 10.6)
• dict: automatically add missing extension for the ‘import’ message
• dict.iter: fix crashes with references to dangling subdictionaries.
• enable SSE2 instructions for windows non-audio projects
• Encapsulating with disabled patch cord causes crash
• File > New Text, typing, File > Save causes text to disappear
• filtergraph~ no longer crash when receiving a message with the wrong filter index
• filtergraph~: @edit_maxfreq @edit_minfreq swap
• fpic: opt+drag no longer loses image
• Gen: patcher type visual display on inlets and outlets
• Gen: ‘f’ can be used in GenExpr as a variable
• Gen: .genexpr files now associated with Max6
• grab: Works with ‘set’ receives / multiple output
• groove~: fix for output gain variations depending up transposition with resampling on
• groove~: fix for stuttering, distortion, and other glitches with resampling on and looping a small portion of a large buffer
• groove~: fixed crash when loop max is smaller than loop min
• groove~: resampling aliasing on loop points
• groove~: resampling and loopinterp should work together
• jit.anim.drive: ui_map dictionary functionality fixes
• jit.cellblock: .txt extension added to written files
• jit.cellblock: misc fixes
• jit.gen: fixed noise()
• jit.gl.lua: .lua files: now associated with Max6
• jit.gl.node: fixed crash when closing patch after deleting jit.gl.node
• jit.gl.node: gl.node erase_color attribute bug fix
• jit.gl.pix: fixed GLSL compilation errors
• jit.gl.videoplane: fixed fullscreen crash
• jit.phys.body: fixed @shape compound crashes when collision reporting
• jit.phys.ghost: fixed help file crash
• jit.qt.movie: fixed flatten + inplace crash
• jit.qt.movie: attrui @dim updates with @adapt 1
• jitter Gen: math binops with vec2 arguments produce valid output
• KeyMIDI: octaves buttons works properly again
• live.step: editlooponly respects loop start > 1
• matrixctrl: updates when recalling a preset in Max for Live
• minimixer: fixed sizing issues
• nodes: mouse coordinate are correct when the object isn’t squared
• nodes: no longer produce NaN when the size of a node is set to 0.
• nodes: setnode message properly updates the active state
• ob3d matrixoutput 2 memory leak
• object details panel: fixed GUI glitch
• polybuffer~ help file: fixed crash on Windows
• phasor~: improved @lock 1 performance
• plot~: editing domain labels in the editor does not trigger a re-paint
• poly~: decreased the CPU usage for non-dsp (and non-active DSP) patchers
• polybuffer~: fixed getshortname crash
• Projects: auto localize setting results in missing file entry
• reference: fixed Tutorial 1 missing text
• reference browser: removed mouseover popup in search results
• regexp: fixed substring crash
• saving: saving an abstraction (or poly~ patcher) as another file no longer causes other instances to reload
• saving: fixed open rect bpatcher save issue
• scale: fixed ref and scale vignette namespace collision
• scale/scale~: exponent base is no longer inverted in non-classic mode
• send~/receive~: mismatched pair no longer crashes Max when DSP is on
• sidebar: improved reference appearance at small sizes
• standalone: better default audio driver selection
• standalone: fixed java dependency issues
• standalone: fixed issues on Windows with javascript inclusion
• table: object box attrs now work properly
• vst~: window coordinate arguments work again with ‘open’ message
• watchpoints: improved positioning when watchpoint is below patcher when patcher is floating

Maybe the next sequencer…

Those who have followed that lead know already I’m working on (amongst many things) an euclidean sequencer.
As many know, I already worked and currently proposing alternative sequencers for you all bored by straight sequences.

Especially, people seems to like a lot :
- The MatriX
- The Uncanny Sequencer

Here is a little view, totally unfinished view of the jsui object in max6 containing the whole javascript engine inspired by basic algorithms and a research text (The Euclidean Algorithm Generates Traditional Musical Rhythms ; Godfried Toussaint, School of Computer Science, McGill University, Montreal,  Quebec,  Canada)

Basically, euclidean algorithm solves a classical problem: how to distribute the most evenly possible x object into y slots ?
It involves to divide integers etc etc. (feel free to ask more in comments)

This sequencer engine is a new experiment for me.
It is based on a basic concept:
- the UI is made of classical UI elements + a JSUI providing a visualization but driving the engine too (all in one!)
- the sequences are fired from the JSUI engine into a seq~ object (event-driven sequencer object in Max)
- the seq~ is triggered by a phasor object locked on the Ableton Live transport

Seems efficient enough to be proposed to Design the Media, I mean, to be proposed to you.

My video generator begins to live

Designing & testing my video generator with Max & Max for Live as written in some previous posts (especially this one where you can see the global architecture), here is a very light & short video.

Thanks to Synthtopia for the review.

The video generated (in the little black window on the left) has been made with a javascript + MGraphics code designed by Darwin Grosse and provided the 02 / 11 / 12 here)
I altered it a bit in order to follow the requirements of the video generator (framework, I could add)

I’d like to make the core available for you.
We’ll see this point later but not very late

As I wrote previously, the only important point shown here in that video is the concept, not the video generated or else.
Also, I can say I’ll use it as soon as it will be fully functional.
My couple of algorithms will generated strange minimalistic videos and, all along my music performance, these videos will be altered, changed by :
- me tweaked parameters not directly related to visuals (I push a button to mute, I accelerate the tempo, I tweak a panning on this track)
- audio part of music itself (volume, frequency too)

My video generator architecture

As described in a previous post about the fact I love to design minimalistic elements, I’m currently designing my video generator.
I need it since .. around 3 years and I already discussed about that here and there.

The more I play, the more I need it
For me, making music equals designing music.
The process includes algorithms & coding, sometimes.
Generative sequence (made for instance with my 2 own sequencers, including The MatriX sequencer) & generative video can coexist very well. Especially, I feel well with them.

It wouldn’t replace a VJ.
By writing that, I didn’t write it will be worse than a VJ, and no more it will be better than a VJ.
It just will be a special entity by itself, built to react and to inspire me while I’ll perform live.
It will also be a nice way to produce visuals for you if you are in front of me, not watching my screen, drinking something, wanting to see more visuals stuff.

OSC can be use internal or external on a network.
OSC is Open Sound Control.

I’ll deliver more later of course because I want to provide the Video Generator part.
Following some (very light, voluntarily) requirements, you’ll be able to build your own modules by programming (coding) and to use them with the video generator.

Stay tuned…