Operation on buffers in place/temporary memory?

Does the fluid.bufnmf~ work on buffers in place? I envisage an implementation where you perform a decomposition with heavy handed parameters, isolate a specific layer you like (perhaps according to some descriptor criteria) and then further decompose that to get ‘inside’ the sound. Currently I have a patch that does this with numerous duplicate objects chained into each other but I was curious if this could be done in place on the original buffers.

Furthermore, is this pathway made obsolete the the dictFlag + actFlag settings and using a seed dictionary?

I am trying to think a little divergently here!

1 Like

We don’t do process in place, but transfer to internal buffers (higher resolution). But the second part of your question is different, i.e. if we could keep the buffers untouched internally, therefore having a ‘state’. @groma and @weefuzzy will have opinions on this.

With no specific comments on this question, it would be cool to see your de-de-decomposition patch.

hi @rodrigo.constanzo

Patch and some sound files are located at the db link below.


The second layer of decomposition tends to produce ‘filtered’ versions of the same thing, perhaps what you were alluding to in your other post about getting somewhat spectrally separated layers without a sense of much differentiation. I suppose I was hoping to get something totally unexpected out of the second level of processing akin to @tutschku 's analogy of the flower. That said, try the sound files I put in the folder. They are some dense radio noise samples from which I got some interesting results. If you make anything interesting please post it here, or perhaps we can start a new thread in the appropriate place.

The best way to think of the whole process is:

Read buffers to internal storage
Process on internal storage
Write to buffers

So the read and write buffers can be the same, but the processing is done somewhere else first, so the also only sees the input buffers as they are at the start of the process, and then the output is written as a separate stage.

Hi, sorry I cannot look at the code for the moment, but if I understand correctly I would say a) the idea of recursive decomposition seems interesting, but you should compare it to using a larger rank for the first one, and b) the dictFlag and actFlag would be useful if you want to apply a similar decomposition to new samples, it looks like a different case to me.