Max 5 API Reference
Max 5 API Reference
00001 #include "ext.h" 00002 #include "ext_obex.h" 00003 #include "ext_strings.h" 00004 #include "jit.common.h" 00005 #include "jit.bin.h" 00006 #include "jit.graphicexport.h" // jb added, in c74-private 00007 00008 typedef struct _jit_matrix_wrapper 00009 { 00010 t_object ob; 00011 void *obex; 00012 t_symbol *name; 00013 void *matrix; 00014 //conversion params 00015 uchar adapt; 00016 uchar thru; 00017 uchar interp; 00018 uchar usesrcdim; 00019 uchar usedstdim; 00020 t_matrix_conv_info mcinfo; 00021 short path; 00022 t_graphic_exportsettings exportsettings; 00023 } t_jit_matrix_wrapper; 00024 00025 00026 void jit_matrix_wrapper_init(void); 00027 void jit_matrix_wrapper_wrapit(t_class *c); 00028 t_max_err jit_matrix_wrapper_attrwrap_set(t_jit_matrix_wrapper *x, void *attr, long ac, t_atom *av); 00029 t_max_err jit_matrix_wrapper_attrwrap_get(t_jit_matrix_wrapper *x, void *attr, long *ac, t_atom **av); 00030 t_max_err jit_matrix_wrapper_methodwrap(t_jit_matrix_wrapper *x, t_symbol *s, long argc, t_atom *argv, t_atom *rv); 00031 t_max_err jit_matrix_wrapper_opwrap(t_jit_matrix_wrapper *x, t_symbol *s, long argc, t_atom *argv, t_atom *rv); 00032 void jit_matrix_wrapper_notify(t_jit_matrix_wrapper *x, t_symbol *s, t_symbol *msg, t_object *sender, void *data); 00033 void jit_matrix_wrapper_name(t_jit_matrix_wrapper *x, t_symbol *s, long argc, t_atom *argv); 00034 void *jit_matrix_wrapper_getmatrix(t_jit_matrix_wrapper *x); 00035 void *jit_matrix_wrapper_new(t_symbol *s, long argc, t_atom *argv); 00036 void jit_matrix_wrapper_free(t_jit_matrix_wrapper *x); 00037 00038 t_max_err jit_matrix_wrapper_export_movie(t_jit_matrix_wrapper *x, t_symbol *s, long argc, t_atom *argv, t_atom *rv); 00039 t_max_err jit_matrix_wrapper_exportimage(t_jit_matrix_wrapper *x, t_symbol *s, long argc, t_atom *argv, t_atom *rv); 00040 t_max_err jit_matrix_wrapper_import_movie(t_jit_matrix_wrapper *x, t_symbol *s, long argc, t_atom *argv, t_atom *rv); 00041 t_max_err jit_matrix_wrapper_read(t_jit_matrix_wrapper *x, t_symbol *s, long argc, t_atom *argv, t_atom *rv); 00042 t_max_err jit_matrix_wrapper_write(t_jit_matrix_wrapper *x, t_symbol *s, long argc, t_atom *argv, t_atom *rv); 00043 t_max_err jit_matrix_wrapper_frommatrix(t_jit_matrix_wrapper *x, t_symbol *s, long argc, t_atom *argv, t_atom *rv); 00044 00045 t_class *_jit_matrix_wrapper_class=NULL; 00046 00047 static t_symbol *ps_preset,*ps_assist,*ps_op,*ps_nobox,*ps_atomarray,*ps_jit_matrix_wrapper; 00048 static t_symbol *ps_usercanset,*ps_usercanget; 00049 00050 void jit_matrix_wrapper_init(void) 00051 { 00052 t_class *c; 00053 long attrflags; 00054 void *attr; 00055 00056 c = class_new("jit_matrix_wrapper", (method)jit_matrix_wrapper_new, (method)jit_matrix_wrapper_free, (short)sizeof(t_jit_matrix_wrapper), 00057 (method)0L, A_GIMME, 0); 00058 class_obexoffset_set(c, calcoffset(t_jit_matrix_wrapper, obex)); 00059 class_addmethod(c,(method)jit_matrix_wrapper_export_movie, "exportmovie", A_GIMMEBACK, 0L); 00060 class_addmethod(c,(method)jit_matrix_wrapper_exportimage, "exportimage", A_GIMMEBACK, 0L); 00061 class_addmethod(c,(method)jit_matrix_wrapper_import_movie, "importmovie", A_GIMMEBACK, 0L); 00062 class_addmethod(c,(method)jit_matrix_wrapper_read, "read", A_GIMMEBACK, 0L); 00063 class_addmethod(c,(method)jit_matrix_wrapper_write, "write", A_GIMMEBACK, 0L); 00064 class_addmethod(c,(method)jit_matrix_wrapper_frommatrix, "frommatrix", A_GIMMEBACK, 0); 00065 class_addmethod(c,(method)jit_matrix_wrapper_notify, "notify", A_CANT, 0); 00066 class_addmethod(c,(method)jit_matrix_wrapper_getmatrix, "getmatrix", A_CANT, 0); 00067 00068 // a little bit confused below using jitter attributes, but should 00069 // work now that jitter is obex based 00070 attrflags = JIT_ATTR_GET_DEFER_LOW | JIT_ATTR_SET_USURP_LOW ; 00071 attr = jit_object_new(_jit_sym_jit_attr_offset,"name",_jit_sym_symbol,attrflags, 00072 (method)0L,(method)jit_matrix_wrapper_name,calcoffset(t_jit_matrix_wrapper,name)); 00073 class_addattr(c,attr); 00074 attr = jit_object_new(_jit_sym_jit_attr_offset_array,"planemap",_jit_sym_long,JIT_MATRIX_MAX_PLANECOUNT,attrflags, 00075 (method)0L,(method)0L,0/*fix*/,calcoffset(t_jit_matrix_wrapper,mcinfo.planemap)); 00076 class_addattr(c,attr); 00077 attr = jit_object_new(_jit_sym_jit_attr_offset_array,"srcdimstart",_jit_sym_long,JIT_MATRIX_MAX_DIMCOUNT,attrflags, 00078 (method)0L,(method)0L,0/*fix*/,calcoffset(t_jit_matrix_wrapper,mcinfo.srcdimstart)); 00079 class_addattr(c,attr); 00080 attr = jit_object_new(_jit_sym_jit_attr_offset_array,"srcdimend",_jit_sym_long,JIT_MATRIX_MAX_DIMCOUNT,attrflags, 00081 (method)0L,(method)0L,0/*fix*/,calcoffset(t_jit_matrix_wrapper,mcinfo.srcdimend)); 00082 class_addattr(c,attr); 00083 attr = jit_object_new(_jit_sym_jit_attr_offset_array,"dstdimstart",_jit_sym_long,JIT_MATRIX_MAX_DIMCOUNT,attrflags, 00084 (method)0L,(method)0L,0/*fix*/,calcoffset(t_jit_matrix_wrapper,mcinfo.dstdimstart)); 00085 class_addattr(c,attr); 00086 attr = jit_object_new(_jit_sym_jit_attr_offset_array,"dstdimend",_jit_sym_long,JIT_MATRIX_MAX_DIMCOUNT,attrflags, 00087 (method)0L,(method)0L,0/*fix*/,calcoffset(t_jit_matrix_wrapper,mcinfo.dstdimend)); 00088 class_addattr(c,attr); 00089 attr = jit_object_new(_jit_sym_jit_attr_offset,"adapt",_jit_sym_char,attrflags, 00090 (method)0L,(method)0L,calcoffset(t_jit_matrix_wrapper,adapt)); 00091 class_addattr(c,attr); 00092 attr = jit_object_new(_jit_sym_jit_attr_offset,"interp",_jit_sym_char,attrflags, 00093 (method)0L,(method)0L,calcoffset(t_jit_matrix_wrapper,interp)); 00094 class_addattr(c,attr); 00095 attr = jit_object_new(_jit_sym_jit_attr_offset,"usesrcdim",_jit_sym_char,attrflags, 00096 (method)0L,(method)0L,calcoffset(t_jit_matrix_wrapper,usesrcdim)); 00097 class_addattr(c,attr); 00098 attr = jit_object_new(_jit_sym_jit_attr_offset,"usedstdim",_jit_sym_char,attrflags, 00099 (method)0L,(method)0L,calcoffset(t_jit_matrix_wrapper,usedstdim)); 00100 class_addattr(c,attr); 00101 00102 // symbols needed in the wrapit call 00103 ps_assist = gensym("assist"); 00104 ps_preset = gensym("preset"); 00105 ps_op = gensym("op"); 00106 ps_nobox = gensym("nobox"); 00107 ps_atomarray = gensym("atomarray"); 00108 ps_jit_matrix_wrapper = gensym("jit_matrix_wrapper"); 00109 ps_usercanset = gensym("usercanset"); 00110 ps_usercanget = gensym("usercanget"); 00111 00112 // wrap the jit_matrix class (attributes/methods/operators) 00113 jit_matrix_wrapper_wrapit(c); 00114 00115 class_register(gensym("jitter"),c); 00116 _jit_matrix_wrapper_class = c; 00117 00118 00119 } 00120 00121 void jit_matrix_wrapper_wrapit(t_class *c) 00122 { 00123 t_class *jc; 00124 long attrcount=0; 00125 t_symbol **attrarray=NULL; 00126 long canset,canget,flags; 00127 t_messlist *mp; 00128 t_messlist *mp2; 00129 long i; 00130 void *attr=NULL; 00131 00132 jc = class_findbyname(gensym("jitter"),gensym("jit_matrix")); 00133 if (!jc) { 00134 error("jit_matrix_wrapper: could not find jit_matrix class"); 00135 return; 00136 } 00137 00138 // for each public attribute add a wrapper attribute 00139 hashtab_getkeys((t_hashtab *)jc->c_attributes,&attrcount,&attrarray); 00140 for (i=0;i<attrcount;i++) { 00141 if (attr=class_attr_get(jc,attrarray[i])) { 00142 canset = (long) object_method(attr,ps_usercanset); 00143 canget = (long) object_method(attr,ps_usercanget); 00144 if (canset||canget) { 00145 flags = 0; 00146 if (!canset) flags |= ATTR_SET_OPAQUE_USER; 00147 if (!canget) flags |= ATTR_GET_OPAQUE_USER; 00148 attr = attribute_new(attrarray[i]->s_name,object_method(attr,_jit_sym_gettype),flags, 00149 (method)jit_matrix_wrapper_attrwrap_get,(method)jit_matrix_wrapper_attrwrap_set); 00150 class_addattr(c,attr); 00151 } 00152 } 00153 } 00154 freebytes(attrarray, sizeof(t_symbol *)*attrcount); 00155 00156 // for each typed method add wrapper method 00157 if (jc->c_messcount>0) { 00158 for (i=0,mp=jc->c_messlist+1;i<jc->c_messcount-1;i++,mp++) { 00159 if (mp->m_type[0]==A_CANT) { 00160 if (!(mp2=class_typedwrapper_get(jc,mp->m_sym))) 00161 mp2 = mp; 00162 } else { 00163 mp2 = mp; 00164 } 00165 if (mp2->m_sym && (mp2->m_type[0]!=A_CANT) && (mp2->m_sym!=ps_assist) && (mp2->m_sym!=ps_preset)) { 00166 class_addmethod(c,(method)jit_matrix_wrapper_methodwrap, mp2->m_sym->s_name, A_GIMMEBACK, 0L); 00167 } 00168 } 00169 } 00170 00171 // for each alphabetical operator, add wrapper method 00172 class_addmethod(c,(method)jit_matrix_wrapper_opwrap, "pass", A_GIMMEBACK, 0L); 00173 class_addmethod(c,(method)jit_matrix_wrapper_opwrap, "mult", A_GIMMEBACK, 0L); 00174 class_addmethod(c,(method)jit_matrix_wrapper_opwrap, "div", A_GIMMEBACK, 0L); 00175 class_addmethod(c,(method)jit_matrix_wrapper_opwrap, "add", A_GIMMEBACK, 0L); 00176 class_addmethod(c,(method)jit_matrix_wrapper_opwrap, "addmod", A_GIMMEBACK, 0L); 00177 class_addmethod(c,(method)jit_matrix_wrapper_opwrap, "sub", A_GIMMEBACK, 0L); 00178 class_addmethod(c,(method)jit_matrix_wrapper_opwrap, "submod", A_GIMMEBACK, 0L); 00179 class_addmethod(c,(method)jit_matrix_wrapper_opwrap, "mod", A_GIMMEBACK, 0L); 00180 class_addmethod(c,(method)jit_matrix_wrapper_opwrap, "min", A_GIMMEBACK, 0L); 00181 class_addmethod(c,(method)jit_matrix_wrapper_opwrap, "max", A_GIMMEBACK, 0L); 00182 class_addmethod(c,(method)jit_matrix_wrapper_opwrap, "avg", A_GIMMEBACK, 0L); 00183 class_addmethod(c,(method)jit_matrix_wrapper_opwrap, "absdiff", A_GIMMEBACK, 0L); 00184 class_addmethod(c,(method)jit_matrix_wrapper_opwrap, "flippass", A_GIMMEBACK, 0L); 00185 class_addmethod(c,(method)jit_matrix_wrapper_opwrap, "flipdiv", A_GIMMEBACK, 0L); 00186 class_addmethod(c,(method)jit_matrix_wrapper_opwrap, "flipsub", A_GIMMEBACK, 0L); 00187 class_addmethod(c,(method)jit_matrix_wrapper_opwrap, "flipmod", A_GIMMEBACK, 0L); 00188 // bitwise 00189 class_addmethod(c,(method)jit_matrix_wrapper_opwrap, "bitand", A_GIMMEBACK, 0L); 00190 class_addmethod(c,(method)jit_matrix_wrapper_opwrap, "bitor", A_GIMMEBACK, 0L); 00191 class_addmethod(c,(method)jit_matrix_wrapper_opwrap, "bitxor", A_GIMMEBACK, 0L); 00192 class_addmethod(c,(method)jit_matrix_wrapper_opwrap, "bitnot", A_GIMMEBACK, 0L); 00193 class_addmethod(c,(method)jit_matrix_wrapper_opwrap, "rshift", A_GIMMEBACK, 0L); 00194 class_addmethod(c,(method)jit_matrix_wrapper_opwrap, "lshift", A_GIMMEBACK, 0L); 00195 // logical 00196 class_addmethod(c,(method)jit_matrix_wrapper_opwrap, "and", A_GIMMEBACK, 0L); 00197 class_addmethod(c,(method)jit_matrix_wrapper_opwrap, "or", A_GIMMEBACK, 0L); 00198 class_addmethod(c,(method)jit_matrix_wrapper_opwrap, "not", A_GIMMEBACK, 0L); 00199 class_addmethod(c,(method)jit_matrix_wrapper_opwrap, "gt", A_GIMMEBACK, 0L); 00200 class_addmethod(c,(method)jit_matrix_wrapper_opwrap, "lt", A_GIMMEBACK, 0L); 00201 class_addmethod(c,(method)jit_matrix_wrapper_opwrap, "gte", A_GIMMEBACK, 0L); 00202 class_addmethod(c,(method)jit_matrix_wrapper_opwrap, "lte", A_GIMMEBACK, 0L); 00203 class_addmethod(c,(method)jit_matrix_wrapper_opwrap, "eq", A_GIMMEBACK, 0L); 00204 class_addmethod(c,(method)jit_matrix_wrapper_opwrap, "neq", A_GIMMEBACK, 0L); 00205 // logical pass 00206 class_addmethod(c,(method)jit_matrix_wrapper_opwrap, "gtp", A_GIMMEBACK, 0L); 00207 class_addmethod(c,(method)jit_matrix_wrapper_opwrap, "ltp", A_GIMMEBACK, 0L); 00208 class_addmethod(c,(method)jit_matrix_wrapper_opwrap, "gtep", A_GIMMEBACK, 0L); 00209 class_addmethod(c,(method)jit_matrix_wrapper_opwrap, "ltep", A_GIMMEBACK, 0L); 00210 class_addmethod(c,(method)jit_matrix_wrapper_opwrap, "eqp", A_GIMMEBACK, 0L); 00211 class_addmethod(c,(method)jit_matrix_wrapper_opwrap, "neqp", A_GIMMEBACK, 0L); 00212 // trig 00213 class_addmethod(c,(method)jit_matrix_wrapper_opwrap, "sin", A_GIMMEBACK, 0L); 00214 class_addmethod(c,(method)jit_matrix_wrapper_opwrap, "cos", A_GIMMEBACK, 0L); 00215 class_addmethod(c,(method)jit_matrix_wrapper_opwrap, "tan", A_GIMMEBACK, 0L); 00216 class_addmethod(c,(method)jit_matrix_wrapper_opwrap, "asin", A_GIMMEBACK, 0L); 00217 class_addmethod(c,(method)jit_matrix_wrapper_opwrap, "acos", A_GIMMEBACK, 0L); 00218 class_addmethod(c,(method)jit_matrix_wrapper_opwrap, "atan", A_GIMMEBACK, 0L); 00219 class_addmethod(c,(method)jit_matrix_wrapper_opwrap, "atan2", A_GIMMEBACK, 0L); 00220 // hyperbolic trig 00221 class_addmethod(c,(method)jit_matrix_wrapper_opwrap, "sinh", A_GIMMEBACK, 0L); 00222 class_addmethod(c,(method)jit_matrix_wrapper_opwrap, "cosh", A_GIMMEBACK, 0L); 00223 class_addmethod(c,(method)jit_matrix_wrapper_opwrap, "tanh", A_GIMMEBACK, 0L); 00224 class_addmethod(c,(method)jit_matrix_wrapper_opwrap, "asinh", A_GIMMEBACK, 0L); 00225 class_addmethod(c,(method)jit_matrix_wrapper_opwrap, "acosh", A_GIMMEBACK, 0L); 00226 class_addmethod(c,(method)jit_matrix_wrapper_opwrap, "atanh", A_GIMMEBACK, 0L); 00227 // exponential/logarithmic 00228 class_addmethod(c,(method)jit_matrix_wrapper_opwrap, "exp", A_GIMMEBACK, 0L); 00229 class_addmethod(c,(method)jit_matrix_wrapper_opwrap, "exp2", A_GIMMEBACK, 0L); 00230 class_addmethod(c,(method)jit_matrix_wrapper_opwrap, "ln", A_GIMMEBACK, 0L); 00231 class_addmethod(c,(method)jit_matrix_wrapper_opwrap, "log", A_GIMMEBACK, 0L); 00232 class_addmethod(c,(method)jit_matrix_wrapper_opwrap, "log2", A_GIMMEBACK, 0L); 00233 class_addmethod(c,(method)jit_matrix_wrapper_opwrap, "log10", A_GIMMEBACK, 0L); 00234 class_addmethod(c,(method)jit_matrix_wrapper_opwrap, "hypot", A_GIMMEBACK, 0L); 00235 class_addmethod(c,(method)jit_matrix_wrapper_opwrap, "pow", A_GIMMEBACK, 0L); 00236 class_addmethod(c,(method)jit_matrix_wrapper_opwrap, "sqrt", A_GIMMEBACK, 0L); 00237 // rounding 00238 class_addmethod(c,(method)jit_matrix_wrapper_opwrap, "ceil", A_GIMMEBACK, 0L); 00239 class_addmethod(c,(method)jit_matrix_wrapper_opwrap, "floor", A_GIMMEBACK, 0L); 00240 class_addmethod(c,(method)jit_matrix_wrapper_opwrap, "round", A_GIMMEBACK, 0L); 00241 class_addmethod(c,(method)jit_matrix_wrapper_opwrap, "trunc", A_GIMMEBACK, 0L); 00242 // ignore 00243 class_addmethod(c,(method)jit_matrix_wrapper_opwrap, "ignore", A_GIMMEBACK, 0L); 00244 } 00245 00246 t_max_err jit_matrix_wrapper_attrwrap_set(t_jit_matrix_wrapper *x, void *attr, long ac, t_atom *av) 00247 { 00248 if (x->matrix&&attr) { 00249 //MAKE THIS FUNCTION AND EXPORT FOR 1.5 GUARANTEE 00250 //jit_object_attr_setvalueof(x->matrix,object_method(attr,_jit_sym_getname),ac,av); 00251 return object_attr_setvalueof(x->matrix,object_method(attr,_jit_sym_getname),ac,av); 00252 } 00253 return MAX_ERR_GENERIC; 00254 } 00255 00256 t_max_err jit_matrix_wrapper_attrwrap_get(t_jit_matrix_wrapper *x, void *attr, long *ac, t_atom **av) 00257 { 00258 if (x->matrix&&attr) { 00259 //MAKE THIS FUNCTION AND EXPORT FOR 1.5 GUARANTEE 00260 //return jit_object_attr_getvalueof(x->matrix,object_method(attr,_jit_sym_getname),ac,av); 00261 return object_attr_getvalueof(x->matrix,object_method(attr,_jit_sym_getname),ac,av); 00262 } 00263 return MAX_ERR_GENERIC; 00264 } 00265 00266 t_max_err jit_matrix_wrapper_methodwrap(t_jit_matrix_wrapper *x, t_symbol *s, long argc, t_atom *argv, t_atom *rv) 00267 { 00268 t_atom av2[256]; 00269 long i; 00270 00271 if (x->matrix) { 00272 for (i=0;i<argc;i++) { 00273 if ((argv[i].a_type==A_OBJ)&& 00274 (object_classname((t_object *)argv[i].a_w.w_obj)==ps_jit_matrix_wrapper)) 00275 { 00276 atom_setobj(av2+i,((t_jit_matrix_wrapper *)argv[i].a_w.w_obj)->matrix); 00277 } else { 00278 av2[i] = argv[i]; 00279 } 00280 } 00281 return object_method_typed(x->matrix,s,argc,av2,rv); 00282 } 00283 return MAX_ERR_GENERIC; 00284 } 00285 00286 t_max_err jit_matrix_wrapper_opwrap(t_jit_matrix_wrapper *x, t_symbol *s, long argc, t_atom *argv, t_atom *rv) 00287 { 00288 long i,ac2; 00289 t_atom av2[256]; 00290 00291 if (x->matrix) { 00292 ac2 = argc+1; 00293 if (ac2>254) ac2 = 255; 00294 atom_setsym(av2,s); 00295 for (i=1;i<(ac2-1);i++) { 00296 if ((argv[i-1].a_type==A_OBJ)&& 00297 (object_classname((t_object *)argv[i-1].a_w.w_obj)==ps_jit_matrix_wrapper)) 00298 { 00299 atom_setobj(av2+i,((t_jit_matrix_wrapper *)argv[i-1].a_w.w_obj)->matrix); 00300 } else { 00301 av2[i]=argv[i-1]; 00302 } 00303 } 00304 return object_method_typed(x->matrix,ps_op,ac2,av2,rv); 00305 } 00306 return MAX_ERR_NONE; 00307 } 00308 00309 void jit_matrix_wrapper_notify(t_jit_matrix_wrapper *x, t_symbol *s, t_symbol *msg, t_object *sender, void *data) 00310 { 00311 //jit_object_post((t_object *)x,"notify: %s %s",s->s_name,msg->s_name); 00312 if (s==x->name&&msg==_jit_sym_free) { 00313 jit_object_error((t_object *)x,"jit_matrix_wrapper: freeing referenced matrix %s",s->s_name); 00314 jit_object_detach(x->name, x); 00315 x->name = _jit_sym_nothing; 00316 x->matrix = NULL; 00317 } 00318 } 00319 00320 void jit_matrix_wrapper_name(t_jit_matrix_wrapper *x, t_symbol *s, long argc, t_atom *argv) 00321 { 00322 t_symbol *name=_jit_sym_nothing; 00323 void *o; 00324 00325 if (argc&&argv) { 00326 name = jit_atom_getsym(argv); 00327 } 00328 if (name==_jit_sym_nothing) name = jit_symbol_unique(); 00329 jit_object_detach(x->name, x); 00330 x->name = name; 00331 o = x->matrix; 00332 o = jit_object_method(o,_jit_sym_register,x->name); 00333 x->matrix = o; 00334 jit_object_attach(x->name, x); 00335 } 00336 00337 t_max_err jit_matrix_wrapper_export_movie(t_jit_matrix_wrapper *x, t_symbol *s, long argc, t_atom *argv, t_atom *rv) 00338 { 00339 void *qtrecord; 00340 t_jit_matrix_info info; 00341 void *o=x->matrix; 00342 t_symbol *name; 00343 t_atom at[2]; 00344 t_atom rv2; 00345 t_object *rvarr; 00346 long rvac = 0; 00347 t_atom *rvav = NULL; 00348 00349 jit_atom_setsym(&at[0], gensym("<none>")); 00350 jit_atom_setlong(&at[1], 0); 00351 00352 if (o) { 00353 jit_object_method(o,_jit_sym_getinfo,&info); 00354 qtrecord = jit_object_new(gensym("jit_qt_record"),info.dim[0],info.dim[1]); 00355 if (qtrecord) { 00356 jit_object_method(qtrecord,gensym("write"),gensym("write"),argc,argv); 00357 jit_object_method(qtrecord,_jit_sym_matrix_calc,o,NULL); 00358 object_method_typed(qtrecord, gensym("stop"), 0, NULL, &rv2); 00359 if (rvarr = jit_atom_getobj(&rv2)) { 00360 object_getvalueof(rvarr, &rvac, &rvav); 00361 if (rvac && rvav) { 00362 jit_atom_setsym(&at[0], jit_atom_getsym(rvav)); 00363 if (rvac > 1) 00364 jit_atom_setlong(&at[1], jit_atom_getlong(rvav + 1)); 00365 freebytes(rvav, sizeof(t_atom) * rvac); 00366 } 00367 freeobject(rvarr); 00368 } 00369 jit_object_free(qtrecord); 00370 } 00371 } 00372 atom_setobj(rv,object_new(ps_nobox,ps_atomarray,2,at)); 00373 return MAX_ERR_NONE; 00374 } 00375 00376 t_max_err jit_matrix_wrapper_exportimage(t_jit_matrix_wrapper *x, t_symbol *s, long argc, t_atom *argv, t_atom *rv) 00377 { 00378 void *qtmovie; 00379 t_jit_matrix_info info; 00380 t_atom at[2]; 00381 void *o=x->matrix; 00382 00383 jit_atom_setsym(&at[0], gensym("<none>")); 00384 jit_atom_setlong(&at[1], 0); 00385 00386 if (o) { 00387 jit_object_method(o,_jit_sym_getinfo,&info); 00388 qtmovie = jit_object_new(gensym("jit_qt_movie"),info.dim[0],info.dim[1]); 00389 if (qtmovie) { 00390 if (!((long)jit_object_method(qtmovie,gensym("matrix_to_image"),o,argc,argv,&x->exportsettings))) { 00391 jit_atom_setsym(&at[0], argv->a_w.w_sym); 00392 jit_atom_setlong(&at[1], 1); 00393 } 00394 jit_object_free(qtmovie); 00395 } 00396 } 00397 atom_setobj(rv,object_new(ps_nobox,ps_atomarray,2,at)); 00398 return MAX_ERR_NONE; 00399 } 00400 00401 t_max_err jit_matrix_wrapper_import_movie(t_jit_matrix_wrapper *x, t_symbol *s, long argc, t_atom *argv, t_atom *rv) 00402 { 00403 void *qtmovie; 00404 long time=0; 00405 long err; 00406 t_symbol *name=_jit_sym_nothing; 00407 long intarg = 0; 00408 void *o=x->matrix; 00409 t_jit_matrix_info info; 00410 t_atom a; 00411 t_atom at[2]; 00412 t_atom rv2; 00413 t_object *rvarr; 00414 long rvac = 0; 00415 t_atom *rvav = NULL; 00416 00417 //deal with file opening/arg parsing. 00418 jit_atom_arg_getsym(&name, 0, argc, argv); 00419 jit_atom_setsym(&a, name); 00420 jit_atom_setsym(&at[0], gensym("<none>")); 00421 jit_atom_setlong(&at[1], 0); 00422 00423 if (name==_jit_sym_nothing) { 00424 ; 00425 } else { 00426 intarg = 1; 00427 } 00428 00429 jit_atom_arg_getlong(&time, intarg, argc, argv); 00430 00431 if (o) { 00432 jit_object_method(o,_jit_sym_getinfo,&info); 00433 qtmovie = jit_object_new(gensym("jit_qt_movie"),info.dim[0],info.dim[1]); 00434 if (qtmovie) { 00435 jit_attr_setfloat(qtmovie, gensym("rate"), 0.); // set rate to 0. as a precaution 00436 object_method_typed(qtmovie, gensym("read"), 1, &a, &rv2); 00437 if (rvarr = jit_atom_getobj(&rv2)) { 00438 object_getvalueof(rvarr, &rvac, &rvav); 00439 if (rvac && rvav) { 00440 jit_atom_setsym(&at[0], jit_atom_getsym(rvav)); 00441 if (rvac > 1 && jit_atom_getlong(rvav + 1)) { 00442 jit_attr_setlong(qtmovie,gensym("time"),time); 00443 if (x->adapt) { 00444 t_jit_matrix_info minfo; 00445 long dim[2]; 00446 00447 jit_attr_getlong_array(qtmovie,gensym("movie_dim"),2,dim); 00448 jit_object_method(qtmovie,_jit_sym_dim,dim[0],dim[1]); 00449 jit_object_method(o,_jit_sym_getinfo,&minfo); 00450 minfo.type = _jit_sym_char; 00451 minfo.planecount = 4; 00452 minfo.dimcount = 2; 00453 minfo.dim[0] = dim[0]; 00454 minfo.dim[1] = dim[1]; 00455 jit_object_method(o,_jit_sym_setinfo,&minfo); 00456 } 00457 err = (t_jit_err)jit_object_method(qtmovie,_jit_sym_matrix_calc,NULL,o); 00458 if (!err) 00459 jit_atom_setlong(&at[1], 1); 00460 } 00461 freebytes(rvav, sizeof(t_atom) * rvac); 00462 } 00463 freeobject(rvarr); 00464 } 00465 jit_object_free(qtmovie); 00466 } 00467 } 00468 atom_setobj(rv,object_new(ps_nobox,ps_atomarray,2,at)); 00469 return MAX_ERR_NONE; 00470 } 00471 00472 t_max_err jit_matrix_wrapper_read(t_jit_matrix_wrapper *x, t_symbol *s, long argc, t_atom *argv, t_atom *rv) 00473 { 00474 t_jit_matrix_info info; 00475 long err,filesize; 00476 unsigned long version; 00477 t_filehandle fh; 00478 short path; 00479 t_symbol *name=_jit_sym_nothing; 00480 char filename[MAX_PATH_CHARS]; 00481 long type=JIT_BIN_MAC_TYPE; 00482 void *o=x->matrix; 00483 t_atom a[2]; 00484 00485 //deal with file opening/arg parsing. 00486 jit_atom_arg_getsym(&name, 0, argc, argv); 00487 00488 jit_atom_setlong(a+1,-1); //error 00489 00490 if (name==_jit_sym_nothing) { 00491 if (open_dialog(filename, &path, &type, &type, 1)) { 00492 jit_atom_setlong(a+1,0); //cancelled 00493 goto out; 00494 } 00495 name=gensym(filename); 00496 } else { 00497 strcpy(filename,name->s_name); 00498 path = x->path; 00499 if (locatefile_extended(filename, &path, &type, &type, 1)) { 00500 jit_object_error((t_object *)x,"jit.matrix: can't find file %s",name->s_name); 00501 goto out; 00502 } 00503 } 00504 00505 if (!(err=path_opensysfile(filename, path, &fh, READ_PERM))) { 00506 //all is well 00507 } else { 00508 jit_object_error((t_object *)x,"jit.matrix: can't open file %s",name->s_name); 00509 goto out; 00510 } 00511 00512 if (o) { 00513 if (jit_bin_read_header(fh,&version,&filesize)) { 00514 jit_object_error((t_object *)x,"jit.matrix: improper file format %s",name->s_name); 00515 sysfile_close(fh); 00516 goto out; 00517 } 00518 //later skip non matrix chunks, but for now, assume it is the next one 00519 if (jit_bin_read_matrix(fh,o)) { 00520 jit_object_error((t_object *)x,"jit.matrix: improper file format %s",name->s_name); 00521 sysfile_close(fh); 00522 goto out; 00523 } 00524 sysfile_close(fh); 00525 jit_atom_setlong(a+1,1); //success 00526 } else { 00527 jit_object_error((t_object *)x,"jit.matrix: error reading file"); 00528 } 00529 out: 00530 if (name==_jit_sym_nothing) name = gensym("<none>"); 00531 jit_atom_setsym(a,name); 00532 atom_setobj(rv,object_new(ps_nobox,ps_atomarray,2,a)); 00533 return MAX_ERR_NONE; 00534 } 00535 00536 t_max_err jit_matrix_wrapper_write(t_jit_matrix_wrapper *x, t_symbol *s, long argc, t_atom *argv, t_atom *rv) 00537 { 00538 t_jit_matrix_info info; 00539 long err,version,filesize,position; 00540 t_filehandle fh; 00541 short path=0; 00542 t_symbol *name=_jit_sym_nothing; 00543 char filename[256]; 00544 long type=JIT_BIN_MAC_TYPE; 00545 void *o=x->matrix; 00546 t_atom a[2]; 00547 00548 //deal with file opening/arg parsing. 00549 jit_atom_arg_getsym(&name, 0, argc, argv); 00550 00551 jit_atom_setlong(a+1,-1); //error 00552 00553 if (name==_jit_sym_nothing) { 00554 sprintf(filename,"matrix.jxf"); 00555 if (saveasdialog_extended(filename, &path, &type, &type, 1)) { 00556 jit_atom_setlong(a+1,0); //cancelled 00557 goto out; 00558 } 00559 name=gensym(filename); 00560 } else { 00561 strcpy(filename,name->s_name); 00562 path = x->path; 00563 } 00564 00565 if (!(err=path_createsysfile(filename, path, type, &fh))) { 00566 //all is well 00567 } else { 00568 jit_object_error((t_object *)x,"jit.matrix: could not create file %s",name->s_name); 00569 goto out; 00570 } 00571 00572 if (o) { 00573 if (jit_bin_write_header(fh,0)) { 00574 jit_object_error((t_object *)x,"jit.matrix: could not write header %s",name->s_name); 00575 sysfile_close(fh); 00576 goto out; 00577 } 00578 //later skip non matrix chunks, but for now, assume it is the next one 00579 if (jit_bin_write_matrix(fh,o)) { 00580 jit_object_error((t_object *)x,"jit.matrix: could not write matrix %s",name->s_name); 00581 sysfile_close(fh); 00582 goto out; 00583 } 00584 sysfile_getpos(fh, &position); 00585 sysfile_seteof(fh, position); 00586 if (jit_bin_write_header(fh,position)) { 00587 jit_object_error((t_object *)x,"jit.matrix: could not write header %s",name->s_name); 00588 sysfile_close(fh); 00589 goto out; 00590 } 00591 sysfile_close(fh); 00592 jit_atom_setlong(a+1,1); //success 00593 } else { 00594 jit_object_error((t_object *)x,"jit.matrix: error writing file"); 00595 } 00596 out: 00597 if (name==_jit_sym_nothing) name = gensym("<none>"); 00598 jit_atom_setsym(a,name); 00599 atom_setobj(rv,object_new(ps_nobox,ps_atomarray,2,a)); 00600 return MAX_ERR_NONE; 00601 } 00602 00603 t_max_err jit_matrix_wrapper_frommatrix(t_jit_matrix_wrapper *x, t_symbol *s, long argc, t_atom *argv, t_atom *rv) 00604 { 00605 long err; 00606 t_symbol *name; 00607 void *o,*p; 00608 t_matrix_conv_info mcinfo; 00609 t_jit_matrix_info minfo; 00610 00611 //check if it is a symbol or an object pointer 00612 //if an object pointer, make sure you grab underlying object 00613 // for now just support name 00614 00615 if (argc&&argv) { 00616 if ((argv[0].a_type==A_OBJ)&& 00617 (object_classname((t_object *)argv[0].a_w.w_obj)==ps_jit_matrix_wrapper)) 00618 { 00619 o = ((t_jit_matrix_wrapper *)argv[0].a_w.w_obj)->matrix; 00620 } else if ((name=jit_atom_getsym(argv))!=_jit_sym_nothing) { 00621 o = jit_object_findregistered(name); 00622 if (!jit_object_method(o,_jit_sym_class_jit_matrix)) 00623 o = NULL; 00624 } 00625 if (o) { 00626 p = x->matrix; 00627 if (o&&p) { 00628 if (x->adapt) { 00629 jit_object_method(o,_jit_sym_getinfo,&minfo); 00630 jit_object_method(p,_jit_sym_setinfo,&minfo); 00631 } 00632 mcinfo = x->mcinfo; 00633 if (x->interp) mcinfo.flags |= JIT_MATRIX_CONVERT_INTERP; 00634 if (x->usesrcdim) mcinfo.flags |= JIT_MATRIX_CONVERT_SRCDIM; 00635 if (x->usedstdim) mcinfo.flags |= JIT_MATRIX_CONVERT_DSTDIM; 00636 jit_object_method(p,_jit_sym_frommatrix,o,&mcinfo); 00637 } 00638 } 00639 } 00640 // later could return success codes in rv? 00641 return MAX_ERR_NONE; 00642 } 00643 00644 void *jit_matrix_wrapper_getmatrix(t_jit_matrix_wrapper *x) 00645 { 00646 return (void *)x->matrix; 00647 } 00648 00649 void *jit_matrix_wrapper_new(t_symbol *s, long argc, t_atom *argv) 00650 { 00651 t_jit_matrix_wrapper *x; 00652 void *p=NULL,*data; 00653 long i,j,savelock; 00654 t_jit_matrix_info info; 00655 long attrstart; 00656 void *o; 00657 00658 if (x = (t_jit_matrix_wrapper *)object_alloc(_jit_matrix_wrapper_class)) { 00659 jit_matrix_info_default(&info); 00660 x->name = _jit_sym_nothing; 00661 00662 x->adapt = 1; 00663 x->thru = 1; 00664 x->interp = 0; 00665 x->usesrcdim = 0; 00666 x->usedstdim = 0; 00667 x->exportsettings.settings = NULL; 00668 x->exportsettings.type = 0L; 00669 setmem(&x->mcinfo,sizeof(t_matrix_conv_info),0); 00670 for (i=0;i<JIT_MATRIX_MAX_PLANECOUNT;i++) x->mcinfo.planemap[i] = i; 00671 00672 attrstart=argc;//not looking for attrargs for now 00673 //get normal args 00674 if (attrstart&&argv) { 00675 jit_atom_arg_getsym(&x->name, 0, attrstart, argv); 00676 i = (x->name==_jit_sym_nothing)?0:1; 00677 if (attrstart>i) 00678 x->adapt = 0; 00679 jit_atom_arg_getlong(&info.planecount, i, attrstart, argv); 00680 jit_atom_arg_getsym(&info.type, i+1, attrstart, argv); 00681 i+=2; j=0; 00682 while (i<attrstart) { //dimensions 00683 jit_atom_arg_getlong(&(info.dim[j]), i, attrstart, argv); 00684 i++; j++; 00685 } 00686 if (j) info.dimcount=j; 00687 } 00688 00689 if (x->name==_jit_sym_nothing) x->name = jit_symbol_unique(); 00690 //create + register jit_matrix object 00691 o = jit_object_new(_jit_sym_jit_matrix,&info); 00692 o = jit_object_method(o,_jit_sym_register,x->name); 00693 00694 if (!o) { 00695 //either a different class already registered with this name 00696 //or we've run out of memory. drat! 00697 jit_object_post((t_object *)x,"error could not create jit.matrix %s",x->name->s_name); 00698 x->name=NULL; //no, no, no...we're not bound to this guy 00699 freeobject((void *)x); 00700 x = NULL; 00701 goto out; 00702 } 00703 00704 if (x->adapt==0) 00705 jit_object_method(o,_jit_sym_setinfo,&info); //impose matrix args 00706 x->matrix = o; 00707 jit_object_attach(x->name, x); //attach max object to registered jit object 00708 x->path = path_getdefault(); 00709 } 00710 00711 out: 00712 return x; 00713 } 00714 00715 void jit_matrix_wrapper_free(t_jit_matrix_wrapper *x) 00716 { 00717 if (x->exportsettings.settings) 00718 jit_qt_utils_atomcontainer_dispose(x->exportsettings.settings); 00719 jit_object_detach(x->name, x); 00720 if (x->matrix) 00721 jit_object_free(x->matrix); 00722 } 00723
Copyright © 2008, Cycling '74