Olaf, thanks for your reply.
I'll continue to flaunt my ignorance on the public list with my reply...
Olaf Matthes said this at Wed, 25 Sep 2002 15:32:13 +0200:
"Adam T. Lindsay" schrieb:
Optimization of the DSP-tree tries to avoid unnecessary copy-operations. Therefore it is possible, that in- and out-signal are located at the same address in the memory. In this case, the programmer has to be careful not to write into the out-signal before having read the in-signal to avoid overwriting data that is not yet saved.
http://iem.kug.ac.at/pd/externals-HOWTO/ node6.html#SECTION00065000000000000000
To me, this is a bit ambiguous (and my German officemate couldn't help with the lang-de version). Who does the optimization?
Pd does. It uses 'the same address in memory'. Thus you have to read in a sample before writing a sample. Writing just overwrites the input samples... In case you want 'silence' you have to set all samples to 0. Otherwise you would hear your input signal!
Using this method saves a lot of memory allocation.
Thanks. That's clear now. I guess I'm now confused by sending pointers to each "in" and "out" buffer, but I can sort of see the rationale.
But more importantly, how do I pass these pointers to enforce an in-place computation on the part of the signal processing network? Should I do something that looks "wrong," like:
void inPlace_dsp(t_inPlace *x, t_signal **sp) { dsp_add(inPlace_perform, 4, x, sp[0]->s_vec, sp[0]->s_vec, sp[0]->s_n); // in and out are the same }
t_int *inPlace_perform(t_int *w) { t_inPlace *x = (t_inPlace *)(w[1]); t_sample *in = (t_sample *)(w[2]); t_sample *out = (t_sample *)(w[2]); int n = (int)(w[3]); /* etc... */ return (w+6); }
Thanks for the help, adam
Hi Adam, i think one shouldn't rely on the input and output pointers to be the same. I would rather suggest that you test whether they are different, in this case copy the input to the output and then do your in-place operation on the output vectors. In my externals i tend to use algorithms that adapt to an in-place (in and out are equal) or out-of-place (in and out are different) situation.
greetings, Thomas
But more importantly, how do I pass these pointers to enforce an in-place computation on the part of the signal processing network? Should I do something that looks "wrong," like:
void inPlace_dsp(t_inPlace *x, t_signal **sp) { dsp_add(inPlace_perform, 4, x, sp[0]->s_vec, sp[0]->s_vec, sp[0]->s_n); // in and out are the same }
t_int *inPlace_perform(t_int *w) { t_inPlace *x = (t_inPlace *)(w[1]); t_sample *in = (t_sample *)(w[2]); t_sample *out = (t_sample *)(w[2]); int n = (int)(w[3]); /* etc... */ return (w+6); }
Thanks for the help, adam
Thanks, Thomas.
I was trying to avoid unnecessary copies, but I really should try the "simple" way first. Thanks for your suggestions.
Cheers, adam
Thomas Grill said this at Wed, 25 Sep 2002 16:45:47 +0200:
Hi Adam, i think one shouldn't rely on the input and output pointers to be the same. I would rather suggest that you test whether they are different, in this case copy the input to the output and then do your in-place operation on the output vectors. In my externals i tend to use algorithms that adapt to an in-place (in and out are equal) or out-of-place (in and out are different) situation.
greetings, Thomas
But more importantly, how do I pass these pointers to enforce an in-place computation on the part of the signal processing network? Should I do something that looks "wrong," like:
void inPlace_dsp(t_inPlace *x, t_signal **sp) { dsp_add(inPlace_perform, 4, x, sp[0]->s_vec, sp[0]->s_vec, sp[0]->s_n); // in and out are the same }
t_int *inPlace_perform(t_int *w) { t_inPlace *x = (t_inPlace *)(w[1]); t_sample *in = (t_sample *)(w[2]); t_sample *out = (t_sample *)(w[2]); int n = (int)(w[3]); /* etc... */ return (w+6); }
Thanks for the help, adam
PD-dev mailing list PD-dev@iem.kug.ac.at http://iem.kug.ac.at/cgi-bin/mailman/listinfo/pd-dev
-
Adam T. Lindsay -
Thomas Grill