Hey!

I am working on some audio buffer manipulation tools and I am experiencing an issue when I use list-rev to reverse the content of a table.

I know I can use a phasor with negative values for playback speed and other ways, to play it back in reverse, but that's not the goal, the goal is to literally reverse the table content, not just playing it back in reverse. It's a step in a longer process, so has to be "hardcoded" to the table.

This is what I tried for now:

It works fine for smaller tables, like 64 or 258 samples, but when you get up to something bigger like 1 second of audio, 44.100 samples(even at 10.000 samples), PD gets seriously sluggish. It takes like 5-10 seconds and freezes PD for those 5-10 seconds.

I am confident it's the list-rev abs, I think it's because it actually has to create a list of 48000(n) indexes and then reverse them, which seems to be a bit much to handle for PD.

I tried doing this too, where I can control the speed of how fast it does the list creation, but if I set it to a speed where it work, it take a pretty long time to reverse just 1 second of audio:

Any suggestions for doing this in a way that doesn't strain PD/Cpu as much and does it at a reasonable speed?

Here is the patch:
Reverse-Buffer Community.pd

Thanks

@jaffasplaffa Pd/doc in extended used to have this.......

all_about_arrays.pd
See "How to Manipulate Arrays" inside
David.

@whale-av

That looks interesting. I was just trying to do something similar using a phasor~ > tabread4~ to tabwrite~. But this is probably better.

Thanks for taking the time to look for it it, I don't have extended here.

@whale-av

Yep that seems to work flawlessly.

Thats a pretty nice array tutorial patch. Have to look more into that I think

Thanks

@jaffasplaffa You're welcome. It might be in the vanilla doc folder but some useful stuff was never copied over. It's worth grabbing a copy of extended and saving it's doc folder somewhere.
Most of it will be the same...... but sometimes there are little things missing from vanilla help..... just a small crucial paragraph that was not copied.
That tutorial was Miller I think.
David.

I think this way takes 1/2 as many operations and 1/2 as much space as the extended way (bc you do it in-place instead of with a temp array):
array-rev.pd

you just have a pointer at the beginning that you increment and a pointer at the end you decrement. You swap the elements they point to until they meet in the middle.

@seb-harmonik.ar

That's a pretty clever approach. Would never have thought of that.

Next thing I was planning to do was to make a function that mirrors the table data. It takes the first half of the table and reverse it and place it in the second half of the table, like if you mirrored the table content.

Already got that working for Davids version and trying to do that with the one you suggest here:

array-mirror.pd

Seems like it's half way through the mirroring it's missing a few indexes. Gonna try tweaking it a bit further.

I think both ways can work here. This is not an operation which is going to be done "live", it's just some sample preparation/manipulation to a buffer and then save the buffer and play it back in other patches.

Thanks, gonna try tweaking it and see if I can make the mirror version work fully too with second version.

Ahh, just tried on a larger table, seems like it works

EDIT:
A there is still some issues with some sizes of the table for the second version.

@jaffasplaffa all you have to do to adapt it to mirror is to change it so that the first half doesn't get written to (and it's even less complicated because you don't have to store the intermediate value of the "other side"):
array-mirror.pd

@seb-harmonik.ar

Ah, thanks!

I love simplicity

Still so much to learn, hehe