[mtx_ei~] Binaural Excitation Inhibition pattern (ITD,ILD)

svn path=/trunk/externals/iem/iemmatrix/; revision=15021

2 files changed, 306 insertions, 0 deletions

diff --git a/doc/mtx_ei~-help.pd b/doc/mtx_ei~-help.pd
new file mode 100755
index 0000000..0dccdb9
--- /dev/null
+++ b/doc/mtx_ei~-help.pd
@@ -0,0 +1,92 @@
+#N struct pcolor-plot float x float y array pcolor-element-array pcolor-element

+;

+#N struct pcolor-element float x float y float c float dx;

+#N canvas 819 236 698 410 10;

+#X obj 540 85 dsp;

+#X floatatom 539 115 5 0 0 0 - - -;

+#X floatatom 586 117 5 0 0 0 - - -;

+#X obj 95 185 z~;

+#X obj 96 225 *~ 1;

+#X obj 361 39 block~ 8192;

+#X obj 228 179 hsl 128 15 0 1.5 0 0 empty empty empty -2 -8 0 10 -262144

+-1 -1 0 1;

+#X obj 248 224 sin;

+#X obj 209 223 cos;

+#X obj 175 79 hsl 100 15 -10 10 0 0 empty empty empty -2 -8 0 10 -262144

+-1 -1 7100 1;

+#X obj 173 125 + 10;

+#X floatatom 174 149 5 0 0 0 - - -;

+#X obj 155 184 z~ 10;

+#X obj 174 98 i;

+#X obj 169 368 mtx_pcolor;

+#X obj 525 46 tgl 15 0 empty empty empty 17 7 0 10 -262144 -1 -1 1

+1;

+#X obj 94 343 mtx;

+#X obj 95 366 mtx_print;

+#X obj 56 317 bng 15 250 50 0 empty empty empty 17 7 0 10 -262144 -1

+-1;

+#X obj 93 93 *~ 2;

+#X obj 81 59 noise~;

+#N canvas 0 0 450 300 computegains 0;

+#X obj 141 55 bng 15 250 50 0 empty empty empty 17 7 0 10 -262144 -1

+-1;

+#X obj 45 206 mtx_print;

+#X obj 45 152 mtx_rmstodb;

+#X obj 45 177 mtx_- 100;

+#X obj 142 93 mtx_logspace 1 0.17 10;

+#X obj 195 157 mtx_reverse;

+#X obj 167 180 mtx_+;

+#X obj 144 125 t a a a;

+#X obj 144 288 mtx_./;

+#X obj 167 203 t a a;

+#X msg 202 225 1 \$3;

+#X obj 242 225 /;

+#X obj 167 249 mtx_* 1;

+#X connect 0 0 4 0;

+#X connect 2 0 3 0;

+#X connect 3 0 1 0;

+#X connect 4 0 7 0;

+#X connect 5 0 6 1;

+#X connect 6 0 9 0;

+#X connect 7 0 8 0;

+#X connect 7 1 6 0;

+#X connect 7 2 5 0;

+#X connect 8 0 2 0;

+#X connect 9 0 12 0;

+#X connect 9 1 10 0;

+#X connect 10 0 11 0;

+#X connect 11 0 12 1;

+#X connect 12 0 8 1;

+#X restore 489 325 pd computegains;

+#X obj 97 275 mtx_ei~ 23 0.909091 0.888184 0.863193 0.833662 0.79924

+0.759747 0.715253 0.666139 0.613137 0.557312 0.5 0.442688 0.386863

+0.333861 0.284747 0.240253 0.20076 0.166338 0.136807 0.111816 0.0909091

+;

+#X obj 156 224 *~ 0.5;

+#X obj 335 353 tgl 15 0 empty empty empty 17 7 0 10 -262144 -1 -1 1

+1;

+#X msg 332 378 vis \$1;

+#X connect 0 0 1 0;

+#X connect 0 1 2 0;

+#X connect 3 0 4 0;

+#X connect 4 0 22 0;

+#X connect 6 0 8 0;

+#X connect 6 0 7 0;

+#X connect 7 0 23 1;

+#X connect 8 0 4 1;

+#X connect 9 0 13 0;

+#X connect 10 0 3 1;

+#X connect 10 0 11 0;

+#X connect 12 0 23 0;

+#X connect 13 0 10 0;

+#X connect 15 0 0 0;

+#X connect 16 0 17 0;

+#X connect 18 0 16 0;

+#X connect 19 0 3 0;

+#X connect 19 0 12 0;

+#X connect 20 0 19 0;

+#X connect 22 0 14 0;

+#X connect 22 0 16 1;

+#X connect 23 0 22 1;

+#X connect 24 0 25 0;

+#X connect 25 0 14 1;

diff --git a/src/mtx_ei~.c b/src/mtx_ei~.c
new file mode 100755
index 0000000..e461bf2
--- /dev/null
+++ b/src/mtx_ei~.c
@@ -0,0 +1,214 @@
+#include "iemmatrix.h"

+

+static t_class *mtx_ei_tilde_class;

+

+typedef struct _mtx_ei_tilde {

+   t_object x_obj;

+   int bs;

+   int sd;

+   int sg;

+   int se;

+   t_float *g;

+   t_float *sig_in_left;

+   t_float *sig_in_right;

+   t_float *sl;

+   t_float *sr;

+   t_float *ei;

+   t_atom *list_out;

+   t_outlet *message_outlet;

+} mtx_ei_tilde;

+

+void *newMtxEITilde(t_symbol *s, int argc, t_atom *argv)

+{

+   int sd=1;

+   int sg=1;

+   mtx_ei_tilde *x = (mtx_ei_tilde*) pd_new(mtx_ei_tilde_class);

+   x->sig_in_left=0;

+   x->sig_in_right=0;

+   x->ei=0;

+   x->list_out=0;

+   x->g=0;

+   inlet_new(&x->x_obj, &x->x_obj.ob_pd, &s_signal, &s_signal);

+   inlet_new(&x->x_obj, &x->x_obj.ob_pd, &s_signal, &s_signal);

+   x->message_outlet=(t_outlet*)outlet_new(&x->x_obj,&s_list);

+

+   if (argc > 2) {

+      sd = atom_getint(argv++);

+      sg = argc-1;

+      sg = (sg<0)?0:sg;

+      sd = (sd<1)?1:sd;

+   }

+   x->sd=sd;

+   x->sg=sg;

+   x->se=(2*sd-1)*(2*sg-1);

+   post("size delay %d, size gain %d",x->sd,x->sg);

+

+   x->list_out = (t_atom*) getbytes ((x->se + 2) * sizeof(t_atom));

+   

+   if (x->sg) {

+      x->g = (t_float*) getbytes (x->sg*sizeof(t_float));

+      for (sg=0;sg<x->sg;sg++){ 

+         x->g[sg] = atom_getfloat (argv++);

+	 post("g[%d]=%f",sg,x->g[sg]);

+      }

+   }

+

+

+   x->ei = (t_float*) getbytes (x->se * sizeof(t_float));

+

+   return (void *) x;

+}

+void deleteMtxEITilde (mtx_ei_tilde *x)

+{

+   if (x->sl)

+      freebytes (x->sl, x->sd * sizeof (t_float));

+   if (x->sr)

+      freebytes (x->sr, x->sd * sizeof (t_float));

+   if (x->list_out)

+      freebytes (x->list_out, (x->se + 2) * sizeof(t_atom));

+   if (x->ei)

+      freebytes (x->ei, x->se * sizeof(t_float));

+

+}

+

+t_float computeEIBlock (t_float *sl, t_float gl, t_float *sr, t_float gr, int n)

+{

+    t_float ei=0;

+    t_float *exch;

+    int n16 = (n >> 4);

+    if ((gl!=1.0f)&&(gr!=1.0f)) {

+       while(n16--) {

+           ei += fabs(gl * *sl++ - gr * *sr++);

+           ei += fabs(gl * *sl++ - gr * *sr++);

+           ei += fabs(gl * *sl++ - gr * *sr++);

+           ei += fabs(gl * *sl++ - gr * *sr++);

+           ei += fabs(gl * *sl++ - gr * *sr++);

+           ei += fabs(gl * *sl++ - gr * *sr++);

+           ei += fabs(gl * *sl++ - gr * *sr++);

+           ei += fabs(gl * *sl++ - gr * *sr++);

+           ei += fabs(gl * *sl++ - gr * *sr++);

+           ei += fabs(gl * *sl++ - gr * *sr++);

+           ei += fabs(gl * *sl++ - gr * *sr++);

+           ei += fabs(gl * *sl++ - gr * *sr++);

+           ei += fabs(gl * *sl++ - gr * *sr++);

+           ei += fabs(gl * *sl++ - gr * *sr++);

+           ei += fabs(gl * *sl++ - gr * *sr++);

+           ei += fabs(gl * *sl++ - gr * *sr++);

+		n-=16;

+       }

+       while(n--) {

+           ei += fabs(gl * *sl++ - gr * *sr++);

+       }

+     }

+    else {

+       if (gr==1.0f) {

+	  exch = sr;

+	  sr = sl;

+	  sl = exch;

+	  gr = gl;

+       }

+       while(n16--) {

+           ei += fabs(*sl++ - gr * *sr++);

+           ei += fabs(*sl++ - gr * *sr++);

+           ei += fabs(*sl++ - gr * *sr++);

+           ei += fabs(*sl++ - gr * *sr++);

+           ei += fabs(*sl++ - gr * *sr++);

+           ei += fabs(*sl++ - gr * *sr++);

+           ei += fabs(*sl++ - gr * *sr++);

+           ei += fabs(*sl++ - gr * *sr++);

+           ei += fabs(*sl++ - gr * *sr++);

+           ei += fabs(*sl++ - gr * *sr++);

+           ei += fabs(*sl++ - gr * *sr++);

+           ei += fabs(*sl++ - gr * *sr++);

+           ei += fabs(*sl++ - gr * *sr++);

+           ei += fabs(*sl++ - gr * *sr++);

+           ei += fabs(*sl++ - gr * *sr++);

+           ei += fabs(*sl++ - gr * *sr++);

+		n-=16;

+       }

+       while(n--) {

+           ei += fabs(*sl++ - gr * *sr++);

+       }

+    }

+    return ei;

+}

+

+static t_int *mTxEITildePerform (t_int *arg) 

+{

+   mtx_ei_tilde *x = (mtx_ei_tilde *) (arg[1]);

+   int gi,zi,eii = 0;

+   t_float scale=1.0f/x->bs;

+   SETFLOAT(x->list_out,(t_float)2*x->sg-1);

+   SETFLOAT(x->list_out+1,(t_float)2*x->sd-1);

+

+   memcpy(x->sl, x->sl+x->bs, sizeof(t_float)*x->sd);

+   memcpy(x->sr, x->sr+x->bs, sizeof(t_float)*x->sd);

+   memcpy(x->sl+x->sd, x->sig_in_left, sizeof(t_float)*x->bs);

+   memcpy(x->sr+x->sd, x->sig_in_right, sizeof(t_float)*x->bs);

+

+   for (gi=0; gi<x->sg; gi++) {

+       if (gi>0) {

+           for (zi=0; zi<x->sd; zi++) {

+               if (zi>0) 

+                   x->ei[eii++]=computeEIBlock(&x->sl[zi],x->g[gi],

+                           &x->sr[x->sd-zi],x->g[x->sg-gi],

+                           x->bs);

+               x->ei[eii++]=computeEIBlock(&x->sl[zi],x->g[gi],

+                       &x->sr[x->sd-zi-1],x->g[x->sg-gi],

+                       x->bs);

+           }

+       }

+       for (zi=0; zi<x->sd; zi++) {

+           if (zi>0) 

+               x->ei[eii++]=computeEIBlock(&x->sl[zi],x->g[gi],

+                       &x->sr[x->sd-zi],x->g[x->sg-gi-1],

+                       x->bs);

+           x->ei[eii++]=computeEIBlock(&x->sl[zi],x->g[gi],

+                   &x->sr[x->sd-zi-1],x->g[x->sg-gi-1],

+                   x->bs);

+       }

+   }

+

+   for (eii=0; eii<x->se; eii++)

+       SETFLOAT(x->list_out+eii+2, x->ei[eii]*scale);

+

+   outlet_anything(x->message_outlet,gensym("matrix"),

+         x->se+2,x->list_out);

+

+   return(arg+2);

+

+}

+

+static void mTxEITildeDsp (mtx_ei_tilde *x, t_signal **sp)

+{

+   int chan;

+   x->sig_in_left=sp[0]->s_vec;

+   x->sig_in_right=sp[1]->s_vec;

+

+   x->bs=sp[0]->s_n;

+

+   if (x->sl)

+      freebytes (x->sl, x->sd * sizeof (t_float));

+   if (x->sr)

+      freebytes (x->sr, x->sd * sizeof (t_float));

+

+   if (x->sd) {

+      x->sl = (t_float*) getbytes ((x->sd+x->bs)*sizeof(t_float));

+      x->sr = (t_float*) getbytes ((x->sd+x->bs)*sizeof(t_float));

+   }

+

+   dsp_add(mTxEITildePerform,1,x);

+}

+

+void mtx_ei_tilde_setup (void)

+{

+   mtx_ei_tilde_class = class_new(gensym("mtx_ei~"), (t_newmethod)newMtxEITilde, (t_method) deleteMtxEITilde, sizeof(mtx_ei_tilde), CLASS_NOINLET, A_GIMME, 0);

+   class_addmethod (mtx_ei_tilde_class, (t_method) mTxEITildeDsp, gensym("dsp"),0);

+}

+

+void iemtx_ei__setup(void)

+{

+   mtx_ei_tilde_setup();

+}

+

+