static void *n_CNLMS_tilde_new(t_symbol *s, t_int argc, t_atom *argv) { t_n_CNLMS_tilde *x = (t_n_CNLMS_tilde *)pd_new(n_CNLMS_tilde_class); char buffer[400]; int i; t_int n_order=39, n_io=1; t_symbol *w_name; t_float beta=0.1f; t_float gamma=0.00001f; t_float kappa = 1.0f; if((argc >= 6) && IS_A_FLOAT(argv,0) && //IS_A_FLOAT/SYMBOL from iemlib.h IS_A_FLOAT(argv,1) && IS_A_FLOAT(argv,2) && IS_A_FLOAT(argv,3) && IS_A_FLOAT(argv,4) && IS_A_SYMBOL(argv,5)) { n_io = (t_int)atom_getintarg(0, argc, argv); n_order = (t_int)atom_getintarg(1, argc, argv); beta = (t_float)atom_getfloatarg(2, argc, argv); gamma = (t_float)atom_getfloatarg(3, argc, argv); kappa = (t_float)atom_getfloatarg(4, argc, argv); w_name = (t_symbol *)atom_getsymbolarg(5, argc, argv); if(beta < 0.0f) beta = 0.0f; if(beta > 2.0f) beta = 2.0f; if(gamma < 0.0f) gamma = 0.0f; if(gamma > 1.0f) gamma = 1.0f; if(kappa < 0.0001f) kappa = 0.0001f; if(kappa > 10000.0f) kappa = 10000.0f; if(n_order < 2) n_order = 2; if(n_order > 11111) n_order = 11111; if(n_io < 1) n_io = 1; if(n_io > 60) n_io = 60; for(i=0; i<n_io; i++) inlet_new(&x->x_obj, &x->x_obj.ob_pd, &s_signal, &s_signal); for(i=0; i<=n_io; i++) outlet_new(&x->x_obj, &s_signal); x->x_out_compressing_bang = outlet_new(&x->x_obj, &s_bang); x->x_msi = 0; x->x_n_io = n_io; x->x_n_order = n_order; x->x_update = 0; x->x_beta = beta; x->x_gamma = gamma; x->x_kappa = kappa; x->x_my_kern = (t_n_CNLMS_tilde_kern *)getbytes(x->x_n_io*sizeof(t_n_CNLMS_tilde_kern)); for(i=0; i<n_io; i++) { sprintf(buffer, "%d_%s", i+1, w_name->s_name); x->x_my_kern[i].x_w_array_sym_name = gensym(buffer); x->x_my_kern[i].x_w_array_mem_beg = (t_float *)0; x->x_my_kern[i].x_in_hist = (t_float *)getbytes(2*x->x_n_order*sizeof(t_float)); } x->x_clock = clock_new(x, (t_method)n_CNLMS_tilde_tick); return(x); } else { post("n_CNLMSC~-ERROR: need 5 float- + 1 symbol-arguments:"); post(" number_of_filters + order_of_filters + learnrate_beta + security_value_gamma + threshold_kappa + array_name_taps"); return(0); } }
///////////////////////////////////////////////////////// // // GEMglViewport // ///////////////////////////////////////////////////////// // Constructor // GEMglStencilMask :: GEMglStencilMask (t_floatarg arg0) : mask(static_cast<GLuint>(arg0)) { m_inlet[0] = inlet_new(this->x_obj, &this->x_obj->ob_pd, &s_float, gensym("mask")); }
///////////////////////////////////////////////////////// // // GEMglViewport // ///////////////////////////////////////////////////////// // Constructor // GEMglEvalCoord1d :: GEMglEvalCoord1d (t_floatarg arg0=0) : u(static_cast<GLdouble>(arg0)) { m_inlet[0] = inlet_new(this->x_obj, &this->x_obj->ob_pd, &s_float, gensym("u")); }
static void *matrix_multilde_new(t_symbol *s, int argc, t_atom *argv) { t_matrix_multilde *x = (t_matrix_multilde *)pd_new(matrix_multilde_class); int i, n; /* arguments parsing: * this might depend on whether we are creating an object * [mtx_*~], [matrix~] or [matrix_mul_line~] * * [mtx_*~ [#out [#in [time]]]]: in1=matrix; in2-in(#in+1)=signals; in(#in+2)=time * [matrix~ [#in [#out [time]]]]: in1-in(#in)=signals; in(#in+1)=matrix; in(#in+2)=time * [matrix_mul_line~ [#in [#out [time]]]]: in1=matrix; in1=time; in1-in(#in):=signals * * furthermore: * [mtx_*~] and [matrix_mul_line~] : O^=A*I^ * [matrix~] : O^'=I^'*B * * with "matrix=(A or B)" and "A=B'" */ t_atom*ap_in =argv+1; t_atom*ap_out =argv+0; t_atom*ap_time=argv+2; x->x_compat=0; if(s==gensym("matrix~")){ pd_error(x,"[matrix~] is deprecated! use [mtx_*~] instead!!"); x->x_compat=2; } else if (s==gensym("matrix_mul_line~")){ pd_error(x,"[matrix_mul_line~] is deprecated! use [mtx_*~] instead!!"); x->x_compat=1; } if(x->x_compat){ ap_in=argv+0; ap_out=argv+1; } switch(argc) { case 0: x->x_n_in = x->x_n_out = 1; x->x_time_ms = (x->x_compat==2)?0.f:50.0f; break; case 1: x->x_n_in = x->x_n_out = (int)atom_getint(argv); x->x_time_ms = (x->x_compat==2)?0.f:50.0f; break; case 2: x->x_n_in = (int)atom_getint(ap_in); x->x_n_out = (int)atom_getint(ap_out); x->x_time_ms = (x->x_compat==2)?0.f:50.0f; break; default: x->x_n_in = (int)atom_getint(ap_in); x->x_n_out = (int)atom_getint(ap_out); x->x_time_ms = atom_getfloat(ap_time); break; } /* sanity check */ if(x->x_time_ms < 0.0f) x->x_time_ms = (x->x_compat==1)?50.f:0.0f; if(x->x_n_in < 1) x->x_n_in = 1; if(x->x_n_out < 1) x->x_n_out = 1; /* creating signal ins & outs */ i = x->x_n_in; if(x->x_compat)i--; while(i--) inlet_new(&x->x_obj, &x->x_obj.ob_pd, &s_signal, &s_signal); i = x->x_n_out; while(i--) outlet_new(&x->x_obj, &s_signal); /* creating the matrix-inlet for [matrix~] */ if(x->x_compat==2) inlet_new(&x->x_obj, &x->x_obj.ob_pd, gensym("matrix"), gensym("")); /* creating time-inlet (not for [matrix_mul_linie~]) */ if(x->x_compat!=1) inlet_new(&x->x_obj, &x->x_obj.ob_pd, &s_float, gensym("time")); /* setting up internal values */ x->x_msi = 0; x->x_outsumbuf = (t_float *)0; x->x_outsumbufsize = 0; x->x_matcur = (t_float *)getbytes(x->x_n_in * x->x_n_out * sizeof(t_float)); x->x_matend = (t_float *)getbytes(x->x_n_in * x->x_n_out * sizeof(t_float)); x->x_inc = (t_float *)getbytes(x->x_n_in * x->x_n_out * sizeof(t_float)); x->x_biginc = (t_float *)getbytes(x->x_n_in * x->x_n_out * sizeof(t_float)); x->x_io = (t_float **)getbytes((x->x_n_in + x->x_n_out) * sizeof(t_float *)); x->x_remaining_ticks = 0; x->x_retarget = 0; x->x_ms2tick = 0.001f * 44100.0f / 64.0f; /* will be set in the dsp-routine */ x->x_1overn = 1.0f / 64.0f; /* will be set in the dsp-routine */ /* setting up internal matrices */ n = x->x_n_in * x->x_n_out; for(i=0; i<n; i++) { x->x_matcur[i] = 0.0f; x->x_matend[i] = 0.0f; x->x_inc[i] = 0.0f; x->x_biginc[i] = 0.0f; } return (x); }
static void *udpsend_tilde_new(t_floatarg inlets, t_floatarg blocksize) { int i; t_udpsend_tilde *x = (t_udpsend_tilde *)pd_new(udpsend_tilde_class); if (x) { for (i = sizeof(t_object); i < (int)sizeof(t_udpsend_tilde); i++) ((char *)x)[i] = 0; if ((int)inlets < 1 || (int)inlets > DEFAULT_AUDIO_CHANNELS) { error("udpsend~: Number of channels must be between 1 and %d", DEFAULT_AUDIO_CHANNELS); return NULL; } x->x_ninlets = (int)inlets; for (i = 1; i < x->x_ninlets; i++) inlet_new(&x->x_obj, &x->x_obj.ob_pd, &s_signal, &s_signal); x->x_outlet = outlet_new(&x->x_obj, &s_float); x->x_outlet2 = outlet_new(&x->x_obj, &s_list); x->x_clock = clock_new(x, (t_method)udpsend_tilde_notify); x->x_myvec = (t_int **)t_getbytes(sizeof(t_int *) * (x->x_ninlets + 3)); if (!x->x_myvec) { error("udpsend~: out of memory"); return NULL; } pthread_mutex_init(&x->x_mutex, 0); x->x_hostname = ps_localhost; x->x_portno = DEFAULT_PORT; x->x_connectstate = 0; x->x_childthread_result = NO_CHILDTHREAD; x->x_fd = -1; x->x_tag.format = x->x_format = SF_FLOAT; x->x_tag.channels = x->x_channels = x->x_ninlets; x->x_vecsize = 64; /* this is updated in the perform routine udpsend_tilde_perform */ x->x_cbuf = NULL; if (blocksize == 0) x->x_blocksize = DEFAULT_AUDIO_BUFFER_SIZE; else if (DEFAULT_AUDIO_BUFFER_SIZE%(int)blocksize) { error("udpsend~: blocksize must fit snugly in %d", DEFAULT_AUDIO_BUFFER_SIZE); return NULL; } else x->x_blocksize = (int)blocksize; //DEFAULT_AUDIO_BUFFER_SIZE; /* <-- the only place blocksize is set */ x->x_blockspersend = x->x_blocksize / x->x_vecsize; /* 1024/64 = 16 blocks */ x->x_blockssincesend = 0; x->x_cbufsize = x->x_blocksize * sizeof(t_float) * x->x_ninlets; x->x_cbuf = (char *)t_getbytes(x->x_cbufsize); #if defined(UNIX) || defined(unix) /* we don't want to get signaled in case send() fails */ signal(SIGPIPE, SIG_IGN); #endif } return (x); }
//static void *ambix_write_new(t_floatarg fnchannels, t_floatarg fbufsize) { static void *ambix_write_new(t_symbol*s, int argc, t_atom*argv) { int achannels=0, xchannels=0, bufframes=-1, bufsize=0; int have_x=0, limiting=0; t_ambix_write *x; int nchannels, i; t_sample*buf; switch(argc) { case 0: achannels=4; break; case 1: achannels=atom_getint(argv+0); break; case 2: achannels=atom_getint(argv+0); xchannels=atom_getint(argv+1); have_x=1; break; case 3: achannels=atom_getint(argv+0); xchannels=atom_getint(argv+1); have_x=1; bufframes =atom_getint(argv+2); break; default: error("usage: [ambix_write~ <ambichannels> <extrachannels> <buffersize>]"); return NULL; } if(achannels+xchannels>MAXSFCHANS) { /* ouch, user requested too much! */ if(achannels>MAXSFCHANS) { achannels=MAXSFCHANS; xchannels=0; } else { xchannels=MAXSFCHANS-achannels; } limiting=1; } nchannels=achannels+xchannels; if (bufframes <= 0) bufframes = DEFBUFPERCHAN; else if (bufframes < MINBUFSIZE) bufframes = MINBUFSIZE; else if (bufframes > MAXBUFSIZE) bufframes = MAXBUFSIZE; bufsize=bufframes*nchannels; buf = (t_sample*)getbytes(bufsize*sizeof(t_sample)); if (!buf) return (0); x = (t_ambix_write *)pd_new(ambix_write_class); if(limiting) { pd_error(x, "limiting to %d ambisonics channels and %d extra channels", achannels, xchannels); if(have_x) { /* FIXXME: remove 'have_x' variable */ } } for (i = 1; i < nchannels; i++) inlet_new(&x->x_obj, &x->x_obj.ob_pd, &s_signal, &s_signal); x->x_f = 0; x->x_ambichannels = achannels; x->x_extrachannels = xchannels; x->x_matrix=NULL; x->x_canvas = canvas_getcurrent(); pthread_mutex_init(&x->x_mutex, 0); pthread_cond_init(&x->x_requestcondition, 0); pthread_cond_init(&x->x_answercondition, 0); pthread_mutex_lock(&x->x_mutex); x->x_vecsize = DEFAULTVECSIZE; x->x_insamplerate = x->x_samplerate = 0; x->x_state = STATE_IDLE; x->x_buf = buf; x->x_bufsize = bufsize; x->x_bufframes = bufframes; x->x_fifosize = x->x_fifohead = x->x_fifotail = x->x_requestcode = 0; pthread_mutex_unlock(&x->x_mutex); pthread_create(&x->x_childthread, 0, ambix_write_child_main, x); return (x); }
///////////////////////////////////////////////////////// // // GEMglVertex2iv // ///////////////////////////////////////////////////////// // Constructor // GEMglVertex2iv :: GEMglVertex2iv (t_floatarg arg0=0, t_floatarg arg1=0) { vMess(arg0, arg1); m_inlet = inlet_new(this->x_obj, &this->x_obj->ob_pd, &s_float, gensym("v")); }
static void *iem_vu_new(t_symbol *s, int argc, t_atom *argv) { t_iem_vu *x = (t_iem_vu *)pd_new(iem_vu_class); int bflcol[]={-66577, -1, -1}; t_symbol *srl[3]; int w=IEM_GUI_DEFAULTSIZE; int ldx=-1, ldy=-8, f=0, fs=8, scale=1; int iinit=0, ifstyle=0; int ftbreak=IEM_BNG_DEFAULTBREAKFLASHTIME, fthold=IEM_BNG_DEFAULTHOLDFLASHTIME; t_iem_init_symargs *init=(t_iem_init_symargs *)(&iinit); t_iem_fstyle_flags *fstyle=(t_iem_fstyle_flags *)(&ifstyle); char str[144]; srl[0] = gensym("empty"); srl[1] = gensym("empty"); srl[2] = gensym("empty"); if((argc >= 11)&&IS_A_FLOAT(argv,0)&&IS_A_FLOAT(argv,1) &&(IS_A_SYMBOL(argv,2)||IS_A_FLOAT(argv,2)) &&(IS_A_SYMBOL(argv,3)||IS_A_FLOAT(argv,3)) &&IS_A_FLOAT(argv,4)&&IS_A_FLOAT(argv,5) &&IS_A_FLOAT(argv,6)&&IS_A_FLOAT(argv,7) &&IS_A_FLOAT(argv,8)&&IS_A_FLOAT(argv,9)&&IS_A_FLOAT(argv,10)) { w = (int)atom_getintarg(0, argc, argv); if(IS_A_SYMBOL(argv,2)) srl[1] = atom_getsymbolarg(2, argc, argv); else if(IS_A_FLOAT(argv,2)) { sprintf(str, "%d", (int)atom_getintarg(2, argc, argv)); srl[1] = gensym(str); } if(IS_A_SYMBOL(argv,3)) srl[2] = atom_getsymbolarg(3, argc, argv); else if(IS_A_FLOAT(argv,3)) { sprintf(str, "%d", (int)atom_getintarg(3, argc, argv)); srl[2] = gensym(str); } ldx = (int)atom_getintarg(4, argc, argv); ldy = (int)atom_getintarg(5, argc, argv); ifstyle = (int)atom_getintarg(6, argc, argv); fs = (int)atom_getintarg(7, argc, argv); bflcol[0] = (int)atom_getintarg(8, argc, argv); bflcol[2] = (int)atom_getintarg(9, argc, argv); scale = (int)atom_getintarg(10, argc, argv); } if((argc == 12)&&IS_A_FLOAT(argv,11)) iinit = (int)atom_getintarg(11, argc, argv); x->x_gui.x_draw = (t_iemfunptr)iem_vu_draw; iinit &= IEM_INIT_ARGS_ALL; ifstyle &= IEM_FSTYLE_FLAGS_ALL; fstyle->x_snd_able = 0; fstyle->x_rcv_able = 1; x->x_gui.x_glist = (t_glist *)canvas_getcurrent(); x->x_gui.x_isa = *init; if(!strcmp(srl[1]->s_name, "empty")) fstyle->x_rcv_able = 0; x->x_gui.x_unique_num = 0; if(fstyle->x_font_style == 1) strcpy(x->x_gui.x_font, "helvetica"); else if(fstyle->x_font_style == 2) strcpy(x->x_gui.x_font, "times"); else { fstyle->x_font_style = 0; strcpy(x->x_gui.x_font, "courier"); } x->x_gui.x_fsf = *fstyle; iemgui_first_dollararg2sym(&x->x_gui, srl); if(x->x_gui.x_fsf.x_rcv_able) pd_bind(&x->x_gui.x_obj.ob_pd, srl[1]); x->x_gui.x_snd = srl[0]; x->x_gui.x_rcv = srl[1]; x->x_gui.x_lab = srl[2]; x->x_gui.x_ldx = ldx; x->x_gui.x_ldy = ldy; if(fs < 4) fs = 4; x->x_gui.x_fontsize = fs; // x->x_gui.x_w = iem_vu_clip_width(w)-1; x->x_gui.x_w = iem_vu_clip_width(w+1); x->x_old_width = x->x_gui.x_w; x->x_gui.x_h = 120; iemgui_all_colfromload(&x->x_gui, bflcol); if(scale != 0) scale = 1; x->x_scale = scale; x->x_peak = 0; x->x_rms = 0; x->x_fp = -101.0; x->x_fr = -101.0; iemgui_verify_snd_ne_rcv(&x->x_gui); inlet_new(&x->x_gui.x_obj, &x->x_gui.x_obj.ob_pd, &s_float, gensym("ft1")); x->x_out_rms = outlet_new(&x->x_gui.x_obj, &s_float); x->x_out_peak = outlet_new(&x->x_gui.x_obj, &s_float); x->x_scale_w = 14; x->x_scale_h = 129; strcpy(x->x_scale_gif, my_iemgui_black_vscale_gif); x->x_gui.x_fsf.x_selected = 0; return (x); }
///////////////////////////////////////////////////////// // // GEMglViewport // ///////////////////////////////////////////////////////// // Constructor // GEMglClearDepth :: GEMglClearDepth (t_floatarg arg0) : depth(static_cast<GLclampd>(arg0)) { m_inlet[0] = inlet_new(this->x_obj, &this->x_obj->ob_pd, &s_float, gensym("depth")); }
///////////////////////////////////////////////////////// // // GEMglTexCoord1sv // ///////////////////////////////////////////////////////// // Constructor // GEMglTexCoord1sv :: GEMglTexCoord1sv (t_floatarg arg0=0) { vMess(arg0); m_inlet = inlet_new(this->x_obj, &this->x_obj->ob_pd, &s_float, gensym("v")); }
static void *iem_vu_new(t_symbol *s, int argc, t_atom *argv) { t_iem_vu *x = (t_iem_vu *)pd_new(iem_vu_class); int bflcol[]={-66577, -1, -1}; int w=IEM_GUI_DEFAULTSIZE; int ldx=-1, ldy=-8, f=0, fs=8, scale=1; int ftbreak=IEM_BNG_DEFAULTBREAKFLASHTIME, fthold=IEM_BNG_DEFAULTHOLDFLASHTIME; char str[144]; iem_inttosymargs(&x->x_gui.x_isa, 0); iem_inttofstyle(&x->x_gui.x_fsf, 0); if((argc >= 11)&&IS_A_FLOAT(argv,0)&&IS_A_FLOAT(argv,1) &&(IS_A_SYMBOL(argv,2)||IS_A_FLOAT(argv,2)) &&(IS_A_SYMBOL(argv,3)||IS_A_FLOAT(argv,3)) &&IS_A_FLOAT(argv,4)&&IS_A_FLOAT(argv,5) &&IS_A_FLOAT(argv,6)&&IS_A_FLOAT(argv,7) &&IS_A_FLOAT(argv,8)&&IS_A_FLOAT(argv,9)&&IS_A_FLOAT(argv,10)) { w = (int)atom_getintarg(0, argc, argv); iemgui_new_getnames(&x->x_gui, 1, argv); ldx = (int)atom_getintarg(4, argc, argv); ldy = (int)atom_getintarg(5, argc, argv); iem_inttofstyle(&x->x_gui.x_fsf, atom_getintarg(6, argc, argv)); fs = (int)atom_getintarg(7, argc, argv); bflcol[0] = (int)atom_getintarg(8, argc, argv); bflcol[2] = (int)atom_getintarg(9, argc, argv); scale = (int)atom_getintarg(10, argc, argv); } else iemgui_new_getnames(&x->x_gui, 1, 0); if((argc == 12)&&IS_A_FLOAT(argv,11)) iem_inttosymargs(&x->x_gui.x_isa, atom_getintarg(11, argc, argv)); x->x_gui.x_draw = (t_iemfunptr)iem_vu_draw; x->x_gui.x_fsf.x_snd_able = 0; x->x_gui.x_fsf.x_rcv_able = 1; x->x_gui.x_glist = (t_glist *)canvas_getcurrent(); if (!strcmp(x->x_gui.x_rcv->s_name, "empty")) x->x_gui.x_fsf.x_rcv_able = 0; if (x->x_gui.x_fsf.x_font_style == 1) strcpy(x->x_gui.x_font, "helvetica"); else if(x->x_gui.x_fsf.x_font_style == 2) strcpy(x->x_gui.x_font, "times"); else { x->x_gui.x_fsf.x_font_style = 0; strcpy(x->x_gui.x_font, "courier"); } if(x->x_gui.x_fsf.x_rcv_able) pd_bind(&x->x_gui.x_obj.ob_pd, x->x_gui.x_rcv); x->x_gui.x_ldx = ldx; x->x_gui.x_ldy = ldy; if(fs < 4) fs = 4; x->x_gui.x_fontsize = fs; // x->x_gui.x_w = iem_vu_clip_width(w)-1; x->x_gui.x_w = iem_vu_clip_width(w+1); x->x_old_width = x->x_gui.x_w; x->x_gui.x_h = 120; iemgui_all_colfromload(&x->x_gui, bflcol); if(scale != 0) scale = 1; x->x_scale = scale; x->x_peak = 0; x->x_rms = 0; x->x_fp = -101.0; x->x_fr = -101.0; iemgui_verify_snd_ne_rcv(&x->x_gui); inlet_new(&x->x_gui.x_obj, &x->x_gui.x_obj.ob_pd, &s_float, gensym("ft1")); x->x_out_rms = outlet_new(&x->x_gui.x_obj, &s_float); x->x_out_peak = outlet_new(&x->x_gui.x_obj, &s_float); x->x_scale_w = 14; x->x_scale_h = 129; strcpy(x->x_scale_gif, my_iemgui_black_vscale_gif); x->x_gui.x_fsf.x_selected = 0; return (x); }
///////////////////////////////////////////////////////// // // GEMglMultMatrixf // ///////////////////////////////////////////////////////// // Constructor // GEMglMultMatrixf :: GEMglMultMatrixf (t_floatarg arg0) { m_inlet = inlet_new(this->x_obj, &this->x_obj->ob_pd, &s_float, gensym("list")); }
static void *NLMSerr_in_tilde_new(t_symbol *s, t_int argc, t_atom *argv) { t_NLMSerr_in_tilde *x = (t_NLMSerr_in_tilde *)pd_new(NLMSerr_in_tilde_class); t_int i, n_order=39; t_symbol *w_name; t_float beta=0.01f; t_float gammax=0.00001f; if((argc >= 4) && IS_A_FLOAT(argv,0) && //IS_A_FLOAT/SYMBOL from iemlib.h IS_A_FLOAT(argv,1) && IS_A_FLOAT(argv,2) && IS_A_SYMBOL(argv,3)) { n_order = (t_int)atom_getintarg(0, argc, argv); beta = (t_float)atom_getfloatarg(1, argc, argv); gammax = (t_float)atom_getfloatarg(2, argc, argv); w_name = (t_symbol *)atom_getsymbolarg(3, argc, argv); if(beta < 0.0f) beta = 0.0f; if(beta > 2.0f) beta = 2.0f; if(gammax < 0.0f) gammax = 0.0f; if(gammax > 1.0f) gammax = 1.0f; if(n_order < 2) n_order = 2; if(n_order > 1111111) n_order = 1111111; 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); outlet_new(&x->x_obj, &s_signal); x->x_flt_sig_in1 = 0; x->x_n_order = n_order; x->x_update = 0; x->x_beta = beta; x->x_gamma = gammax; // 2 times in and one time err_in memory allocation (history) x->x_ref_filt_in_hist = (t_float *)getbytes(x->x_n_order*sizeof(t_float)); x->x_ref_adapt_in_hist = (t_float *)getbytes(x->x_n_order*sizeof(t_float)); // table-symbols will be linked to their memory in future (dsp_routine) x->x_w_array_sym_name = gensym(w_name->s_name); x->x_w_array_mem_beg = (t_float *)0; x->x_rw_index = 0; return(x); } else { post("NLMSerr_in~-ERROR: need 3 float- + 1 symbol-arguments:"); post(" order_of_filter + learnrate_beta + security_value + array_name_taps"); return(0); } }
static void *matrix_new(t_symbol *s, int argc, t_atom *argv) { t_matrix *x = (t_matrix *)pd_new(matrix_class); t_float rampval = MATRIX_DEFRAMP; x->x_numinlets = (int)MATRIX_MININLETS; x->x_numoutlets = (int)MATRIX_MINOUTLETS; x->x_defgain = MATRIX_DEFGAIN; int i; int argnum = 0; while(argc > 0){ if(argv -> a_type == A_FLOAT){ t_float argval = atom_getfloatarg(0, argc, argv); switch(argnum){ case 0: if(argval < MATRIX_MININLETS){ x->x_numinlets = (int)MATRIX_MININLETS; } else if (argval > MATRIX_MAXINLETS){ x->x_numinlets = (int)MATRIX_MAXINLETS; post("matrix~: resizing to %d signal inlets", (int)MATRIX_MAXINLETS); } else{ x->x_numinlets = (int)argval; }; break; case 1: if(argval < MATRIX_MINOUTLETS){ x->x_numoutlets = (int)MATRIX_MINOUTLETS; } else if (argval > MATRIX_MAXOUTLETS){ x->x_numoutlets = (int)MATRIX_MAXOUTLETS; post("matrix~: resizing to %d signal outlets", (int)MATRIX_MAXOUTLETS); } else{ x->x_numoutlets = (int)argval; }; break; case 2: x->x_defgain = argval; break; default: break; }; argc--; argv++; argnum++; } else if(argv -> a_type == A_SYMBOL){ t_symbol *argname = atom_getsymbolarg(0, argc, argv); if(strcmp(argname->s_name, "@ramp")==0){ if(argc >= 2){ t_float argval = atom_getfloatarg(1, argc, argv); if(argval < MATRIX_MINRAMP){ rampval = MATRIX_MINRAMP; } else{ rampval = argval; }; argc -= 2; argv += 2; } else{ goto errstate; }; } else{ goto errstate; }; } else{ goto errstate; }; }; int gaingiven = argnum >= 3; //if >= 3 args given, then gain is given, binary mode is off x->x_ncells = x->x_numinlets * x->x_numoutlets; x->x_ivecs = getbytes(x->x_numinlets * sizeof(*x->x_ivecs)); x->x_ovecs = getbytes(x->x_numoutlets * sizeof(*x->x_ovecs)); x->x_nblock = x->x_maxblock = sys_getblksize(); x->x_osums = getbytes(x->x_numoutlets * sizeof(*x->x_osums)); for (i = 0; i < x->x_numoutlets; i++){ x->x_osums[i] = getbytes(x->x_maxblock * sizeof(*x->x_osums[i])); }; x->x_cells = getbytes(x->x_ncells * sizeof(*x->x_cells)); /* zerovec for filtering float inputs*/ x->x_zerovec = getbytes(x->x_maxblock * sizeof(*x->x_zerovec)); matrix_clear(x); if (gaingiven){ x->x_gains = getbytes(x->x_ncells * sizeof(*x->x_gains)); for (i = 0; i < x->x_ncells; i++){ x->x_gains[i] = x->x_defgain; }; x->x_ramps = getbytes(x->x_ncells * sizeof(*x->x_ramps)); matrix_ramp(x, rampval); x->x_coefs = getbytes(x->x_ncells * sizeof(*x->x_coefs)); for (i = 0; i < x->x_ncells; i++){ x->x_coefs[i] = 0.; }; x->x_ksr = sys_getsr() * .001; x->x_incrs = getbytes(x->x_ncells * sizeof(*x->x_incrs)); x->x_bigincrs = getbytes(x->x_ncells * sizeof(*x->x_bigincrs)); x->x_remains = getbytes(x->x_ncells * sizeof(*x->x_remains)); for (i = 0; i < x->x_ncells; i++){ x->x_remains[i] = 0; }; } else{ x->x_gains = 0; x->x_ramps = 0; x->x_coefs = 0; x->x_incrs = 0; x->x_bigincrs = 0; x->x_remains = 0; }; for (i = 1; i < x->x_numinlets; i++){ pd_float( (t_pd *)inlet_new(&x->x_obj, &x->x_obj.ob_pd, &s_signal, &s_signal), -0.); x->x_signalscalars[i] = obj_findsignalscalar((t_object *)x, i); }; for (i = 0; i < x->x_numoutlets; i++){ outlet_new(&x->x_obj, gensym("signal")); }; x->x_dumpout = outlet_new((t_object *)x, &s_list); x->x_glist = canvas_getcurrent(); return (x); errstate: pd_error(x, "matrix~: improper args"); return NULL; }
/* CHANGE this will have to be taken care of */ default: post("expr: bang: unrecognized result %ld\n", x->exp_res[i].ex_type); } } } static t_expr * #ifdef PD expr_new(t_symbol *s, int ac, t_atom *av) #else /* MSP */ Nexpr_new(t_symbol *s, int ac, t_atom *av) #endif { struct expr *x; int i, ninlet; struct ex_ex *eptr; t_atom fakearg; int dsp_index; /* keeping track of the dsp inlets */ /* * SDY - we may need to call dsp_setup() in this function */ if (!ac) { ac = 1; av = &fakearg; SETFLOAT(&fakearg, 0); } #ifdef PD /* * figure out if we are expr, expr~, or fexpr~ */ if (!strcmp("expr", s->s_name)) { x = (t_expr *)pd_new(expr_class); SET_EXPR(x); } else if (!strcmp("expr~", s->s_name)) { x = (t_expr *)pd_new(expr_tilde_class); SET_EXPR_TILDE(x); } else if (!strcmp("fexpr~", s->s_name)) { x = (t_expr *)pd_new(fexpr_tilde_class); SET_FEXPR_TILDE(x); } else { post("expr_new: bad object name '%s'"); /* assume expr */ x = (t_expr *)pd_new(expr_class); SET_EXPR(x); } #else /* MSP */ /* for now assume an expr~ */ x = (t_expr *)pd_new(expr_tilde_class); SET_EXPR_TILDE(x); #endif /* * initialize the newly allocated object */ x->exp_proxy = 0; x->exp_nivec = 0; x->exp_nexpr = 0; x->exp_error = 0; for (i = 0; i < MAX_VARS; i++) { x->exp_stack[i] = (struct ex_ex *)0; x->exp_outlet[i] = (t_outlet *)0; x->exp_res[i].ex_type = 0; x->exp_res[i].ex_int = 0; x->exp_p_res[i] = (t_float *)0; x->exp_var[i].ex_type = 0; x->exp_var[i].ex_int = 0; x->exp_p_var[i] = (t_float *)0; x->exp_tmpres[i] = (t_float *)0; x->exp_vsize = 0; } x->exp_f = 0; /* save the control value to be transformed to signal */ if (expr_donew(x, ac, av)) { pd_error(x, "expr: syntax error"); /* SDY the following coredumps why? pd_free(&x->exp_ob.ob_pd); */ return (0); } ninlet = 1; for (i = 0, eptr = x->exp_var; i < MAX_VARS ; i++, eptr++) if (eptr->ex_type) { ninlet = i + 1; } /* * create the new inlets */ for (i = 1, eptr = x->exp_var + 1, dsp_index=1; i<ninlet ; i++, eptr++) { t_exprproxy *p; switch (eptr->ex_type) { case 0: /* nothing is using this inlet */ if (i < ninlet) #ifdef PD floatinlet_new(&x->exp_ob, &eptr->ex_flt); #else /* MSP */ inlet_new(&x->exp_ob, "float"); #endif break; case ET_II: case ET_FI: p = exprproxy_new(x, i); #ifdef PD inlet_new(&x->exp_ob, &p->p_pd, &s_float, &s_float); #else /* MSP */ inlet_new(&x->exp_ob, "float"); #endif break; case ET_SI: #ifdef PD symbolinlet_new(&x->exp_ob, (t_symbol **)&eptr->ex_ptr); #else /* MSP */ inlet_new(&x->exp_ob, "symbol"); #endif break; case ET_XI: case ET_VI: if (!IS_EXPR(x)) { dsp_index++; #ifdef PD inlet_new(&x->exp_ob, &x->exp_ob.ob_pd, &s_signal, &s_signal); #else /* MSP */ inlet_new(&x->exp_ob, "signal"); #endif break; } else post("expr: internal error expr_new"); default: pd_error(x, "expr: bad type (%lx) inlet = %d\n", eptr->ex_type, i + 1); break; } } if (IS_EXPR(x)) { for (i = 0; i < x->exp_nexpr; i++) x->exp_outlet[i] = outlet_new(&x->exp_ob, 0); } else { for (i = 0; i < x->exp_nexpr; i++) x->exp_outlet[i] = outlet_new(&x->exp_ob, gensym("signal")); x->exp_nivec = dsp_index; } /* * for now assume a 64 sample size block but this may change once * expr_dsp is called */ x->exp_vsize = 64; for (i = 0; i < x->exp_nexpr; i++) { x->exp_p_res[i] = fts_calloc(x->exp_vsize, sizeof (t_float)); x->exp_tmpres[i] = fts_calloc(x->exp_vsize, sizeof (t_float)); } for (i = 0; i < MAX_VARS; i++) x->exp_p_var[i] = fts_calloc(x->exp_vsize, sizeof (t_float)); return (x); }
///////////////////////////////////////////////////////// // // GEMglViewport // ///////////////////////////////////////////////////////// // Constructor // GEMglGenLists :: GEMglGenLists (t_floatarg arg0=0) : range(static_cast<GLsizei>(arg0)) { m_inlet = inlet_new(this->x_obj, &this->x_obj->ob_pd, &s_float, gensym("range")); m_outlet= outlet_new(this->x_obj, 0); }
///////////////////////////////////////////////////////// // // GEMglViewport // ///////////////////////////////////////////////////////// // Constructor // GEMglIndexf :: GEMglIndexf (t_floatarg arg0=0) : c(static_cast<GLfloat>(arg0)) { m_inlet[0] = inlet_new(this->x_obj, &this->x_obj->ob_pd, &s_float, gensym("c")); }
///////////////////////////////////////////////////////// // // GEMglViewport // ///////////////////////////////////////////////////////// // Constructor // GEMglPushName :: GEMglPushName (t_floatarg arg0=0) : name(static_cast<GLuint>(arg0)) { m_inlet[0] = inlet_new(this->x_obj, &this->x_obj->ob_pd, &s_float, gensym("name")); }
///////////////////////////////////////////////////////// // // GEMglGetMapfv // ///////////////////////////////////////////////////////// // Constructor // GEMglGetMapfv :: GEMglGetMapfv (t_floatarg arg0=0, t_floatarg arg1=0) { targetMess(arg0); queryMess(arg1); m_inlet[0] = inlet_new(this->x_obj, &this->x_obj->ob_pd, &s_float, gensym("target")); m_inlet[1] = inlet_new(this->x_obj, &this->x_obj->ob_pd, &s_float, gensym("query")); }
static void *matrix_bundle_line8_tilde_new(t_symbol *s, int argc, t_atom *argv) { t_matrix_bundle_line8_tilde *x = (t_matrix_bundle_line8_tilde *)pd_new(matrix_bundle_line8_tilde_class); int i, n; switch (argc) { case 0: x->x_n_in = x->x_n_out = 1; x->x_time_ms = 50.0f; break; case 1: x->x_n_in = x->x_n_out = (int)atom_getint(argv); x->x_time_ms = 50.0f; break; case 2: x->x_n_in = (int)atom_getint(argv); x->x_n_out = (int)atom_getint(argv+1); x->x_time_ms = 50.0f; break; default: x->x_n_in = (int)atom_getint(argv); x->x_n_out = (int)atom_getint(argv+1); x->x_time_ms = atom_getfloat(argv+2); break; } if(x->x_n_in < 1) x->x_n_in = 1; if(x->x_n_out < 1) x->x_n_out = 1; if(x->x_time_ms < 0.0f) x->x_time_ms = 50.0f; i = x->x_n_in - 1; while(i--) inlet_new(&x->x_obj, &x->x_obj.ob_pd, &s_signal, &s_signal); i = x->x_n_out; while(i--) outlet_new(&x->x_obj, &s_signal); x->x_in2out_new = (int *)getbytes(x->x_n_in * sizeof(int)); x->x_in2out_old = (int *)getbytes(x->x_n_in * sizeof(int)); x->x_remaining_ticks = (int *)getbytes(x->x_n_in * sizeof(int)); x->x_retarget = (int *)getbytes(x->x_n_in * sizeof(int)); x->x_io = (t_float **)getbytes((x->x_n_in + x->x_n_out) * sizeof(t_float *)); x->x_outsumbuf = (t_float *)0; x->x_outsumbufsize = 0; x->x_raise_cur = 1.0f; x->x_raise_end = 1.0f; x->x_fall_cur = 0.0f; x->x_fall_end = 0.0f; x->x_inc8 = 0.0f; x->x_biginc = 0.0f; x->x_msi = 0; x->x_ms2tick = 0.001f * 44100.0f / 64.0f; x->x_8overn = 8.0f / 64.0f; x->x_remaining_ticks_start = (int)(x->x_time_ms * x->x_ms2tick); if(!x->x_remaining_ticks_start) x->x_remaining_ticks_start = 1; n = x->x_n_in; for(i=0; i<n; i++) { x->x_in2out_new[i] = 0; x->x_in2out_old[i] = 0; x->x_remaining_ticks[i] = 0; x->x_retarget[i] = 0; } return(x); }
///////////////////////////////////////////////////////// // // GEMglNormal3bv // ///////////////////////////////////////////////////////// // Constructor // GEMglNormal3bv :: GEMglNormal3bv (t_floatarg arg0=0, t_floatarg arg1=0, t_floatarg arg2=0) { vMess(arg0, arg1, arg2); m_inlet = inlet_new(this->x_obj, &this->x_obj->ob_pd, &s_float, gensym("v")); }
static void *matrix_mul_line_tilde_new(t_symbol *s, int argc, t_atom *argv) { t_matrix_mul_line_tilde *x = (t_matrix_mul_line_tilde *)pd_new(matrix_mul_line_tilde_class); int i, n; switch(argc) { case 0: x->x_n_in = x->x_n_out = 1; x->x_time_ms = 50.0f; break; case 1: x->x_n_in = x->x_n_out = (int)atom_getint(argv); x->x_time_ms = 50.0f; break; case 2: x->x_n_in = (int)atom_getint(argv); x->x_n_out = (int)atom_getint(argv+1); x->x_time_ms = 50.0f; break; default: x->x_n_in = (int)atom_getint(argv); x->x_n_out = (int)atom_getint(argv+1); x->x_time_ms = atom_getfloat(argv+2); break; } if(x->x_time_ms < 0.0f) x->x_time_ms = 50.0f; if(x->x_n_in < 1) x->x_n_in = 1; if(x->x_n_out < 1) x->x_n_out = 1; i = x->x_n_in - 1; while(i--) inlet_new(&x->x_obj, &x->x_obj.ob_pd, &s_signal, &s_signal); i = x->x_n_out; while(i--) outlet_new(&x->x_obj, &s_signal); x->x_msi = 0; x->x_outsumbuf = (t_float *)0; x->x_outsumbufsize = 0; x->x_matcur = (t_float *)getbytes(x->x_n_in * x->x_n_out * sizeof(t_float)); x->x_matend = (t_float *)getbytes(x->x_n_in * x->x_n_out * sizeof(t_float)); x->x_inc = (t_float *)getbytes(x->x_n_in * x->x_n_out * sizeof(t_float)); x->x_biginc = (t_float *)getbytes(x->x_n_in * x->x_n_out * sizeof(t_float)); x->x_io = (t_float **)getbytes((x->x_n_in + x->x_n_out) * sizeof(t_float *)); x->x_ms2tick = 0.001f * 44100.0f / 64.0f; x->x_1overn = 1.0f / 64.0f; x->x_remaining_ticks = 0; x->x_retarget = 0; n = x->x_n_in * x->x_n_out; for(i=0; i<n; i++) { x->x_matcur[i] = 0.0f; x->x_matend[i] = 0.0f; x->x_inc[i] = 0.0f; x->x_biginc[i] = 0.0f; } return (x); }
///////////////////////////////////////////////////////// // // GEMglColor4ubv // ///////////////////////////////////////////////////////// // Constructor // GEMglColor4ubv :: GEMglColor4ubv (t_floatarg arg0, t_floatarg arg1, t_floatarg arg2, t_floatarg arg3) { vMess(arg0, arg1, arg2, arg3); m_inlet = inlet_new(this->x_obj, &this->x_obj->ob_pd, &s_float, gensym("v")); }
///////////////////////////////////////////////////////// // // GEMglViewport // ///////////////////////////////////////////////////////// // Constructor // GEMglDepthMask :: GEMglDepthMask (t_floatarg arg0) : flag(static_cast<GLboolean>(arg0)) { m_inlet[0] = inlet_new(this->x_obj, &this->x_obj->ob_pd, &s_float, gensym("flag")); }
///////////////////////////////////////////////////////// // // GEMglViewport // ///////////////////////////////////////////////////////// // Constructor // GEMglArrayElement :: GEMglArrayElement (t_floatarg arg0=0) : i(static_cast<GLint>(arg0)) { m_inlet[0] = inlet_new(this->x_obj, &this->x_obj->ob_pd, &s_float, gensym("i")); }
///////////////////////////////////////////////////////// // // GEMglIndexdv // ///////////////////////////////////////////////////////// // Constructor // GEMglIndexdv :: GEMglIndexdv (t_floatarg arg0) { cMess(arg0); m_inlet = inlet_new(this->x_obj, &this->x_obj->ob_pd, &s_float, gensym("v")); }
///////////////////////////////////////////////////////// // // GEMglViewport // ///////////////////////////////////////////////////////// // Constructor // GEMglCallList :: GEMglCallList (t_floatarg arg0) : list( static_cast<GLuint>(arg0)) { m_inlet = inlet_new(this->x_obj, &this->x_obj->ob_pd, &s_float, gensym("gllist")); }
static void *mtr_new(t_floatarg f) { t_mtr *x = 0; int ntracks = (int)f; t_mtrack **tracks; if (ntracks < 1) ntracks = 1; if (tracks = getbytes(ntracks * sizeof(*tracks))) { int i; t_mtrack **tpp; for (i = 0, tpp = tracks; i < ntracks; i++, tpp++) { if (!(*tpp = (t_mtrack *)pd_new(mtrack_class)) || !((*tpp)->tr_binbuf = binbuf_new()) || !((*tpp)->tr_clock = clock_new(*tpp, (t_method)mtrack_tick))) { if (*tpp) pd_free((t_pd *)*tpp); if ((*tpp)->tr_binbuf) binbuf_free((*tpp)->tr_binbuf); while (i--) { tpp--; binbuf_free((*tpp)->tr_binbuf); clock_free((*tpp)->tr_clock); pd_free((t_pd *)*tpp); } return (0); } } if (x = (t_mtr *)pd_new(mtr_class)) { int id; t_outlet *mainout = outlet_new((t_object *)x, &s_list); x->x_glist = canvas_getcurrent(); x->x_filehandle = hammerfile_new((t_pd *)x, 0, mtr_readhook, mtr_writehook, 0); if (ntracks > MTR_C74MAXTRACKS) fittermax_rangewarning(mtr_class, MTR_C74MAXTRACKS, "tracks"); x->x_ntracks = ntracks; x->x_tracks = tracks; for (id = 1; id <= ntracks; id++, tracks++) /* CHECKED 1-based */ { t_mtrack *tp = *tracks; inlet_new((t_object *)x, (t_pd *)tp, 0, 0); tp->tr_trackout = outlet_new((t_object *)x, &s_); tp->tr_mainout = mainout; tp->tr_owner = x; tp->tr_id = id; tp->tr_listed = 0; tp->tr_filehandle = /* LATER rethink */ hammerfile_new((t_pd *)tp, 0, mtrack_readhook, mtrack_writehook, 0); tp->tr_mode = MTR_STEPMODE; tp->tr_muted = 0; tp->tr_restarted = 0; tp->tr_atdelta = 0; tp->tr_ixnext = 0; tp->tr_tempo = 1.; tp->tr_clockdelay = 0.; tp->tr_prevtime = 0.; } } } return (x); }
static void *xtract_new(t_symbol *me, t_int argc, t_atom *argv) { t_xtract_tilde *x = (t_xtract_tilde *)pd_new(xtract_class); xtract_mel_filter *mf; t_int n, N, M, f, F, n_args, type; double *argv_max; t_symbol *arg1; xtract_function_descriptor_t *fd; char *p_name, *p_desc, *author; int year; p_name = p_desc = author = NULL; n_args = type = 0; f = F = XTRACT_FEATURES; N = BLOCKSIZE; x->argv = NULL; x->argv_type = 0; x->done_init = 0; x->is_scalar = 0; x->is_subframe = 0; x->feature = -1; /* Allocate data area */ x->data = (double *)getbytes(N * sizeof(double)); x->result = (double *)getbytes(N * sizeof(double)); /* Parse arguments */ if(argc){ arg1 = atom_getsymbol(argv); if(arg1 == gensym("subframe")) x->is_subframe = 1; else x->feature_name = atom_getsymbol(argv); } else { post("xtract~: No arguments given"); return (void *)x; } if(argc > 1){ if(x->is_subframe) x->feature_name = atom_getsymbol(argv+1); else N = atom_getint(argv+1); } if(argc > 2) N = atom_getint(argv+2); x->init_blocksize = N; M = N >> 1; /* get function descriptors */ fd = (xtract_function_descriptor_t *)xtract_make_descriptors(); /* iterate over descriptors */ while(f--){ /* map creation arg to feature */ if(x->feature_name == gensym(fd[f].algo.name)){ x->feature = f; break; } } if(x->feature == -1) post("xtract~: feature not found: %s", x->feature_name->s_name); /* allocate memory for feature arguments */ n_args = fd[f].argc; type = fd[f].argv.type; x->argv_type = type; if(n_args){ for(n = 0; n < n_args; n++){ argv_max = &fd[f].argv.max[n]; /*post("Argument %d, max: %.2f", n, *argv_max); */ } if(type == XTRACT_MEL_FILTER){ x->memory.argv = (size_t)(n_args * sizeof(xtract_mel_filter)); x->argv = (xtract_mel_filter *)getbytes(x->memory.argv); } else if(type == XTRACT_INT){ x->memory.argv = (size_t)(n_args * sizeof(t_int)); x->argv = (t_int *)getbytes(x->memory.argv); } else if (type == XTRACT_FLOAT){ x->memory.argv = (size_t)(n_args * sizeof(t_float)); x->argv = (t_float *)getbytes(x->memory.argv); } else x->memory.argv = 0; } p_name = fd[f].algo.p_name; p_desc = fd[f].algo.p_desc; author = fd[f].algo.author; year = fd[f].algo.year; if(argc){ if(strcmp(p_name, "")) post("xtract~: %s", p_name ); if(strcmp(p_desc, "")) post("xtract~: %s", p_desc ); if(strcmp(author, "") && year) post("xtract~: %s(%d)", author, year); } /* Adjust frame size if we are using subframe features */ if(x->is_subframe) N = M; post("xtract~: assumed window size: %d", N); /* do init if needed */ if(x->feature == XTRACT_MFCC){ mf = x->argv; mf->n_filters = 20; post("xtract~: mfcc: filters = %d", ((xtract_mel_filter *)x->argv)->n_filters); mf->filters = (double **)getbytes(mf->n_filters * sizeof(double *)); for(n = 0; n < mf->n_filters; n++) mf->filters[n] = (double *)getbytes(N * sizeof(double)); xtract_init_mfcc(N, NYQUIST, XTRACT_EQUAL_GAIN, 80.0f, 18000.0f, mf->n_filters, mf->filters); x->done_init = 1; } else if(x->feature == XTRACT_BARK_COEFFICIENTS){ xtract_init_bark(N, NYQUIST, x->argv); x->done_init = 1; } else if(x->feature == XTRACT_WINDOWED){ x->window = xtract_init_window(N, XTRACT_HANN); x->argv = x->window; x->done_init = 1; } else if(x->feature == XTRACT_WAVELET_F0){ xtract_init_wavelet_f0_state(); } /* Initialise fft_plan if required */ if(x->feature == XTRACT_AUTOCORRELATION_FFT || x->feature == XTRACT_SPECTRUM || x->feature == XTRACT_DCT){ xtract_init_fft(N, x->feature); x->done_init = 1; } if(fd[f].is_scalar) x->is_scalar = 1; /* if(x->feature == XTRACT_AUTOCORRELATION || x->feature == XTRACT_AUTOCORRELATION_FFT || x->feature == XTRACT_MFCC || x->feature == XTRACT_AMDF || x->feature == XTRACT_ASDF|| x->feature == XTRACT_DCT || x->feature == XTRACT_BARK_COEFFICIENTS || x->feature == XTRACT_SPECTRUM || x->feature == XTRACT_PEAK_SPECTRUM || x->feature == XTRACT_HARMONIC_SPECTRUM || x->feature == XTRACT_LPC || x->feature == XTRACT_LPCC || x->feature == XTRACT_WINDOWED) x->feature_type = XTRACT_VECTOR; */ /* else if (x->feature == XTRACT_FLUX || x->feature == XTRACT_ATTACK_TIME || x->feature == XTRACT_DECAY_TIME || x->feature == XTRACT_DIFFERENCE_VECTOR) x->feature_type = XTRACT_DELTA; */ /* else x->feature_type = XTRACT_SCALAR; */ /* argv through right inlet */ inlet_new(&x->x_obj, &x->x_obj.ob_pd, gensym("list"), gensym("list")); /* if feature is vector, create signal out */ if(!x->is_scalar) outlet_new(&x->x_obj, &s_signal); /* otherwise: float */ else outlet_new(&x->x_obj, &s_float); if(x->is_scalar && x->is_subframe) post( "xtract~: warning: subframes not yet supported for scalar features"); /* free the function descriptors */ xtract_free_descriptors(fd); return (void *)x; }
///////////////////////////////////////////////////////// // // GEMglEvalCoord2dv // ///////////////////////////////////////////////////////// // Constructor // GEMglEvalCoord2dv :: GEMglEvalCoord2dv (t_floatarg arg0=0, t_floatarg arg1=0) { vMess(arg0, arg1); m_inlet = inlet_new(this->x_obj, &this->x_obj->ob_pd, &s_float, gensym("v")); }