flies

so i was working with stutter~ and thinking of how i could 'make it better', or at least make it suit my needs better.

the musical effect i want to make is a delay line granulator.

the external that would make it easy is a queue of samples where you could 'tap' it at any point in the queue (making it a random access queue). let's call it cutie~

cutie~ would have 1 inlet for the signal to be sampled, and at least one 'tap' input (with an equal number of tap outputs).

let's say the queue is 48000 samples long, and into the 'tap input' i send the signal 24000. the output would then be the 24000'th sample in the queue. at 48k sampling rate, this is just a half-second delay. so far this is nothing you can't do easily with existing objects.

what makes cutie~ handy is that if instead of sending the constant signal 24000, i send a ramp, say, from 24000 to 0 that lasts half a second, i'd effectively be going through 48k samples in half a second (the 24k already in the queue plus what gets put in the queue during the ramp), meaning i'd be pitched up by an octave.

the main advantage of this object over, say, stutter, is that with stutter, i can move my read head over the write head and get a discontinuity. for my money, patching with this object would be a hell of a lot simpler than stutter for asynchronous grain scheduling.

it doesn't sound all that complicated, does it? I haven't built any externals, but i do have a programming background and a fair amount of C++ experience.

does this sound doable? obviously i would want to start with simpler objects to begin with, but, as they say, learning is much easier when you have a goal in mind.

the external that would make it easy is a queue of samples where you could 'tap' it at any point in the queue (making it a random access queue).  let's call it cutie~

let's say the queue is 48000 samples long, and into the 'tap input' i send the signal 24000.  the output would then be the 24000'th sample in the queue.  at 48k sampling rate, this is just a half-second delay.  so far this is nothing you can't do easily with existing objects.

the main advantage of this object over, say, stutter, is that with stutter, i can move my read head over the write head and get a discontinuity.  for my money, patching with this object would be a hell of a lot simpler than stutter for asynchronous grain scheduling.

it doesn't sound all that complicated, does it?  I haven't built any externals, but i do have a programming background and a fair amount of C++ experience.

does this sound doable?  obviously i would want to start with simpler objects to begin with, but, as they say, learning is much easier when you have a goal in mind.


idea-for-external

I think you can achieve this with plain max objects, for what it's worth (e.g. buffer~, record~, wave~ etc), though you have to massage the signal units a little. Or, for that matter, I'm not sure what the difference is between what you're describing, and tapin~/tapout~. Maybe I didn't understand what you were trying to achieve. Do you really want to hear the discontinuity when moving the read over the write heads?

But it's good to have goals, and making it yourself is the best way to learn & understand.

say, yno, it seems like tapout~ is basically the object i describe. (the only difference so far as I can tell is that the index is milliseconds instead of samples, but, if anything, that's a convenience.) hot shit. i didn't realize it worked that way. now i can build the granulator i always wanted. Maybe my mom will buy me a pony too 

say, yno, it seems like tapout~ is basically the object i describe.  (the only difference so far as I can tell is that the index is milliseconds instead of samples, but, if anything, that's a convenience.)  hot shit.  i didn't realize it worked that way.  now i can build the granulator i always wanted.  Maybe my mom will buy me a pony too 


idea for external