• magnetophon

    A happy little jam I made.

    All the sounds are my voice trough pd.

    The patch uses hermholz~ by katjav to find the pitch, and it has the analysis part of a vocoder.
    Then, instead of a soundsource trough a bunch of bp filters, it uses banks of oscillators that have a formant by themselves, like PAF, vosim and FOF.

    Another trick it uses extensively is ring modulation of the input signal with an oscillator that has the same pitch (up or down one or more octaves).
    This sounds great whith the CZ-oscillators by Maelstorm as the modulator.

    It also tracks the main formant of the input, and uses that as the cutoff of a muug~, and also as the res freq of the CZ oscs mentioned above.
    Great fun, controlling a filter by going ou-wah....

    Finally there's a kick, snare and HH that get triggered when you make corresponding sounds.

    Hope you enjoy it! :)


    posted in output~ read more
  • magnetophon

    Who would have thought! ;)

    All kidding aside, I've made a patch that can tell which chord is most likely to come up, to be used in my jam-machine.

    It looks at incoming notes and tries to recognize a repeating pattern in it.
    When it does, it outputs the chord that was next in the last repetition.

    It's functioning, but causes dropouts, even though the CPU-usage is below 2%.
    The part that is at fault is a nested until loop.

    I thought that 'until' spits out the next bang as soon as the "depth first" branch is completed, but no sooner.
    Is this true?
    If so, a until (even a nested one) couldn't cause a dropout as long as it doesn't tax the CPU too much, right?

    I'm at a loss here. If someone could please have a look, the troublesome part is in MIDIchordImpro.pd->ChordProgresionChecker->Compare

    Thank a lot!!!


    PS: the patch is in alpha state, so don't expect too much of it. Also, some sub-patches are messy, though I've cleaned up the one that is giving me grief.


    posted in technical issues read more
  • magnetophon


    The D-TWO rhythm delay is a delay where instead of tapping the delay time, you tap a rhythm, and your audio gets delayed in that pattern.

    For along time I've been wanting to make a version that gets it's rhythm from midi.
    You play a rhythm on your midi device, the velocity gets translated to the level of that delay tap, and the note is used as a parameter in a user selectable effect.
    You can choose from:

    bypass: a "normal" stereo rhythm-delay, like the D2.
    pan: low notes make a delay tap on the left, high on the right.
    filter: a lowpass: low notes dark, high notes bright
    grunge: the higher the note, the more distorted the tap. (carefull, CPU-heavy!)
    transpose: pitch-shifter: you can play a melody with a delay :)

    Have fun with it!

    I have some questions about it too:

    -Is there a more elegant way to have 12 sub-patches that do the same thing?
    I know I can make an abstraction, but these sub-patches are useless in other contexts, and I like having everything in one file...

    -Is there a better way to do the audio-routing in the insertFX subpatch?
    I want to route audio from one input to one of five outputs, depending on the value of a second input.
    So basically zexy/demux but for audio.

    -Sometimes a few of the delay-lines's parameters don't get updated. Anybody know why?

    -I used the marvelous soundtouch~ pitch-shifter. (thanks Olli & dank je wel Katja!).
    I didn't expect to be able to play melodies at all with it, because the pitch input goes from 0.25 to 2, meaning two octaves down to one octave up, and I had no idea how to map that to notes musically.
    I tried % 36 for three octaves followed by normal scaling and strange enough I get output that is in tune <on most notes>!
    Can anybody explain what is going on?
    Who has ideas for solutions? Some other scalar? Another pitch-shifter?

    -Of course any ideas on how to improve it or some of those famous PD-forum patch-remixes would be awesome!

    All the best,


    posted in abstract~ read more
  • magnetophon


    I was searching for tempo tracking patches when I found this:


    Unfortunately I can not find the patches that are described in it.
    Does anyone have a copy?

    Are there any other advanced tempo trackers out there?
    This one analyzes incoming midi notes, and decides for each note whether it is most likely a halve note, quarter note, etc. based on the previous estimate of tempo, and uses that to make a next estimate.

    I was working on just such an algorithm when I decided it was too hard for me, and went online to find implementations. Then I found this :)


    posted in technical issues read more
  • magnetophon


    I'm working on a generative music engine. See attached patch for rudimentary beginnings.
    The Idea is that you enter a chord sequence through a gui, tap a tempo, and the machine starts improvising for you.
    A more advanced version would let you enter the notes and tempo in one go via midi. Just play the song in block-chords on quarter notes and hit a predefined key as soon as the chord sequence loops.

    I have made a version of this patch that works quite well for one tempo and chord sequence.
    see: http://puredata.hurleur.com/viewtopic.php?pid=34264

    I have also made a start on the generic version. You can choose a scale, and it translates numbers into notes for that scale. See attachment.

    I'd love to collaborate on this. Who's up for that?

    Some questions about the patch I made:
    I have a sub-patch called SelectNoteFromScale, that inputs a number and a list that represents a scale.
    So input 0 in any scale outputs 0. Input 1 plus Major, output 2, etcetera.
    It was quite easy to get working for positive numbers, but the negative ones required some hacks I don't really understand myself, even though I made it :(
    I've commented it as far as I could.

    Who can explain why/how this works?
    Even better: I\m sure there is an elegant way of doing this. How?

    Then some more general questions:
    I made this based on lists for the scales. What would be the advantages/disadvantages of doing it with arrays?

    I made this with the length of the list varying according to the scale. that way you can use a counter as the input for SelectNoteFromScale, and hear a nice scale being played.
    Another way would be to have the list always 12 long. That would have advantages for transposing melodies to other scales. Look here:


    Your thoughts on this are much appreciated.

    All the best,


    posted in technical issues read more
  • magnetophon

    Like many I'm trying to use PD as a BandInABox on steroids.
    I'm building a patch that has a GUI for inputting a chord sequence, and that outputs a song.

    I've made a nice sounding one here:
    but it is not generalized at all, ie it only really works for one tempo and chord sequence.

    I've found a great library to form the basis of the generalized patch, but it's unsupported as of 2008, and as such doesn't really work.


    What I basically need is an abstraction or external that inputs a note number or name and a chord type and that outputs the notes in that chord.

    I've just started to build one (attached) but I suspect there is one out there already.

    Where is it? :)

    Thanks in advance for any pointers,
    All the best,


    PS: I feel there must be an easyer way to do what SelectScale does with the combo select, numberboxes,spigot. But how?


    posted in technical issues read more
  • magnetophon

    This is my first post, and my first patch.
    It generates a nice electronic funk/jazz/acid song out of a chord sequence.
    There's a drum, a bass-line, a "rhythm-guitar", a pad, two nasty and one sweet melody.
    To hear it, turn on the volume of each part and the master, and hit the green square.

    It is based on a patch I made on my NordModular 10 years ago, and that I reworked recently.

    You need pd-exended and Maelstorm's state saving abstractions:

    I used obiwannabe's fairly efficient analog drums as one layer of the kick and snare, and took sumidero's keymetro as a timekeeper. These are incorporated as sub-patches so you don't need to download them separately. Here's the addresses for attribution's sake:
    I also used a modified version Miller's phaser effect from the doc's

    This is quite a CPU-heavy patch, but you could use less oversampling if your PC isn't fast enough.

    I didn't really sanitize it, so all my beginner mistakes are in there, and it looks horrible.
    It does sound quite cool if I may say so myself :)

    A simplified rundown of how it works:

    ***** choosing notes*****************************************************************************************

    All melody instruments randomly choose notes from a scale that gets transposed up and down according to a predefined 16 bar scheme.

    The bass and L+R melody's use a markov-chain to decide which note to play, where the likelyness of each note is defined with the GUI. The octave get's switched around as well, and if the final note is too low to sound good, it is transposed up an octave.

    The bass decides when to glide based on which note within the chord it is playing and to which it is going, so disregarding the octave and the chord-scheme transposes
    The LR melody's decide when to glide based on the difference between the current and the next note, including actave and transposes. (that's why they have these nice long down-slides)

    The "rhythm-guitar" always plays 3 notes left and 3 right, of which one on each side is randomly chosen out of 4 possible combinations, in such a way that they always form a balanced LR picture.

    The pad plays a full triad on each side, but with a random octave chosen each bar. It start gliding to these notes half a bar before the chord change, and arrives at the chord change.

    The lead chooses it's notes and octave fully random, but with a preference for the root .
    It has two "modes": it either plays long legato notes with slow glides, in which case it stays within the current octave, or plays quicker phrases with a faster glide.
    It also features a slowly in fading vibrato on long notes.

    *****Making rhythms*****************************************************************************************

    The drums feature a kick on every 1 and 3 and a snare on 2 and 4. Then a low-passed noise generator decides where and how loud the other kicks and snares are: positive for snares, negative for kicks, quantized to 16th notes.
    The HH is a 1 bar loop, but by modulating it with the total output level, you get interesting, and somehow appropriate HH patterns.

    The bass gets it's rhythm from a 16 step sequencer, whit 3 fades for each step:
    The first governs the likeliness of whether to change the volume at all from the last step.
    The second has the minimum volume, and the third set's the maximum of a random number that gets added to it.
    Then the level of the kick gets subtracted from this, so that notes that where loud get punched in a bit by the kick, and if there where no notes at that point, they get created.
    The attack and decay also get modulated.

    The LR melody's base their rhythms on the difference between the current and the next note, and on the difference between the left and the right note.
    Their level gets modulated by the snare level in a similar way as the bass.

    The "rhythm-guitar" always plays the same sequence rhythm-wise.

    The pad slowly comes in when the other instruments are silent for a moment, but also slightly random.

    The lead has a random rhythm with random longer brakes. It also has a tendency to turn of on the less harmonic note of the bunch, so it stays nice and sweet sounding.

    ****** getting tones *****************************************************************************************
    And finaly some notes on the synths used:

    The tones of the bass and LR melody's follow the same "random rhythmic lfo generator" in such a way that when the bass is bright the melody's are mellow, and vice versa.

    The bass, LR, guitar and lead are all FM synths with internal and external tanh distortion and some internal and external lop and hip filtering.
    The lead is differently modulated left and right, for width.

    The pad is band passed phasors put trough a phaser effect.

    The kick has two layers, obiwannabe kick for punch and a swept down sine for weight.
    The sine's decay is fast when there's bass playing, and slow when not, to maximise heaviness without being in the way of the bass.

    The snare has 5 different layers:
    -obiwannabe's snare
    -a filtered pulse for extra crack
    -some sines for weight
    -some sines with noise FM, different for left and right for width
    -filtered noise, again different for left and right for width

    Might seems overkill, but the snare sounds a lot worse when you turn of a layer :)


    There's a lot more going on in this patch but since this already turned in to a full essay I'll stop here.
    I'm more than willing to try and answer any questions you may have though.

    Have fun with it, and I'd love to hear any modifications you come up with.

    All the best,



    posted in patch~ read more
  • magnetophon

    mod, I'm documenting the workings and heritage of this patch at the moment, and discover that I used a kick from your DIY2.

    So double thanks to you!

    posted in output~ read more
  • magnetophon

    That link seems to be down again. Does anyone still have these externals?
    I'd love to try them for mapping controllers to parameters!


    posted in technical issues read more
  • magnetophon

    @mod said:

    How did you put this together? Did you just sing overdubs in real time, or cut it up in a DAW or something?

    Both. I came up with the meat of the thing using sooperlooper, and then arranged, overdubbed, edited and mixed in Ardour.

    @mod said:

    I love the breathy mong voice sounds, demented like afx windowlicker.

    Thanks! Not sure which sounds you are referring to, but it's a great compliment to be compared to Aphex Twin!

    posted in output~ read more
  • magnetophon


    I've been meaning to upload it, but the usual story applies: I need to clean it up and never got around to that.

    So here it is in all it's dirtiness ;)

    You can use it with a guitar, but it will only make predictable sounds if you play monophonic.
    Also what makes the sounds come alive are the vocoder like qualities, and you can't really do that on a guitar.

    But don't let that stop you, and please let me know (or even hear) how it sounds!

    Oh, and it uses tons of externals and abstractions that are not in extended... Sorry!


    posted in output~ read more
  • magnetophon


    What do you mean by live jam?
    Was it created algorithmiicly?

    posted in output~ read more
  • magnetophon

    Very nice!

    How did you make the sounds?
    Are there feedback loops involved?

    I also quite enjoyed the one following it.

    posted in output~ read more
  • magnetophon

    alexandros: Thank you for the quick reply! That helped a lot, but didn't solve it completely.

    I would like to understand why this mostly works and until mostly gives xruns. Then I can hopefully change the algorithm so is just works.
    I've read the thread on the mailing-list about nbuntil, but that didn't help much, since I'm not entirely clear on how the normal until works.
    It seems my assumption that -until spits out bangs as fast as the underlying branch can bear, but no faster- is false.
    Could someone point me to an explanation? 'until' is kinda hard to google on...

    For those interested, here's the thread about nbuntil : http://markmail.org/message/binb3mv7ys657g5n#query:+page:1+mid:wk5t6kapa7dg3g2o+state:results

    Maybe if I read it again in the morning it wil make more sense...

    Maelstorm: For a moment I was glowing with pride, then I realized you where talking about nbuntil... :)

    posted in technical issues read more
  • magnetophon


    I'm using those too, but tbh I am a bit disappointed by their performance.
    Of course extracting tempo from audio is a lot harder then from midi, but that part actually works quite nice.

    Unfortunately none of them seem to keep track of previous tempo's as the Rippin's version does
    It is quite advanced and I hope it will do better.
    I also hope to use it's internal state to provide further parameters for generative music.
    At least it will be a good learning experience to have it working.


    Yes, I've met her too ;)
    The same woes as for IBT and aubio apply.

    That's why I've begun copying the patch in the paper.
    Unfortunately not all subpatches are printed.

    If anybody wants a preliminary version to help make it work, let me know.


    posted in technical issues read more
  • magnetophon

    Thanks for trying to check out my patch, I'm looking forward to hear your feedback!

    I already mentioned that you need the state saving abstractions, but I can understand one could overlook it in this amount of text.

    @mod said:

    I also get the following errors:

    "InterRandom 22 0 43 2 (bang->line) connection failed
    BassRythm 222 0 68 2 (bang->line) connection failed"

    so you might wanna have a look and track those down.

    I have no idea how to track down those.
    It obviously works over here ;)

    I actually might be getting those errors as well, but I'm also getting tons of:
    "inlet: expected 'float' but got 'bang'"
    so they are drowning out everything else.

    No idea how to get rid of those either :(

    Any pointers on either issue are greatly appreciated!

    posted in patch~ read more
Internal error.

Oops! Looks like something went wrong!