Hayden Davenport

I'm taking a class on Max/MSP, and for the majority of the semester we have been doing tutorials.

But now it's final project time--we all have to pick a topic and go for it! ...And I'm really confused.

What I want to do is use an FFT to store sample data. Then I want to scramble the data, and play it invert the FFT so that it can be played back.

Ideally I would like to have some control over how "randomized" the samples are.

I would like to be able to "chunk" the data, and randomize from there.

The main thing I want is to be able to tell the patch how much to randomize or "blur" the patch.

It would be awesome if I had a number I could change to tell the patch how much to randomize. So if I selected 5, the patch would chunk the samples into groups of 5, and scramble from there. 1-5 would be scrambled, 6-10 would be, 11-15, etc.

Would anyone be able to help me figure out how to get started with this? I would greatly appreciate your help!

scrambling-samples-fft-playing-back

Anyone know how I might get started on this?

This is not a solution, but here are some suggestions about how to implement it. What you are looking to do is totally feasible to do in Max. I would also recommend looking into gen~ because it makes some of the operations a bit simpler, but this should also be totally doable with vanilla MSP.

You need to create a buffer which is n*fftsize samples long, where n is your maximum frame delay. This buffer~ should be inside pfft~ and should be named something like #0_data. The #0 makes sure that each voice of the pfft~ gets its own unique buffer~ for reading and writing. [there is a slightly different solution using 4x overlap as a four channel buffer, but I'm omitting it for the sake of simplicity; it does provide improvements in time resolution]

For the indices: make a long list of indices (1 2 3 4 5...) and then send that into zl.iter 5 into zl.scramble into zl.group. Bang the zl.group to output the semi-scrambled list. (This is outside pfft~ and sent in via send/receive)

Alternatively, make a buffer that contains all permutations of elements 1-n and randomly choose a starting position that is a multiple of n.

Store lists into buffer~ using listfunnel 0 and peek~.

Use ==~ 0 going into +=~ to create a frame counter that will only advance at the start of a new frame. %~ will wrap your index so that it doesn't exceed size_of_buffer_in_samples / fftsize.

This is not a solution, but here are some suggestions about how to implement it.  What you are looking to do is totally feasible to do in Max.  I would also recommend looking into gen~ because it makes some of the operations a bit simpler, but this should also be totally doable with vanilla MSP.  

You need to create a buffer which is n*fftsize samples long, where n is your maximum frame delay.  This buffer~ should be inside pfft~ and should be named something like #0_data.  The #0 makes sure that each voice of the pfft~ gets its own unique buffer~ for reading and writing.  [there is a slightly different solution using 4x overlap as a four channel buffer, but I'm omitting it for the sake of simplicity; it does provide improvements in time resolution]

For the indices: make a long list of indices (1 2 3 4 5...) and then send that into zl.iter 5 into zl.scramble into zl.group.  Bang the zl.group to output the semi-scrambled list.  (This is outside pfft~ and sent in via send/receive)

Use ==~ 0 going into +=~ to create a frame counter that will only advance at the start of a new frame.  %~ will wrap your index so that it doesn't exceed size_of_buffer_in_samples / fftsize.


Scrambling samples from FFT and playing back?