Max 5 API Reference

max.jit.mop.c

#include "jit.common.h"
#include "max.jit.mop.h"

#define JIT_MATRIX_PROBE_INTERVAL 100 //10fps probe

static t_object *g_jit_matrix_probe_obj=NULL;
static void *g_jit_matrix_probe_qelem=NULL;
static void *g_jit_matrix_probe_clock=NULL;
static long g_jit_matrix_probe_outnum=0;
void *max_jit_mop_jit_matrix_startprobe(t_object *o);
void *max_jit_mop_jit_matrix_probevalue(t_object *o, long innum, long outnum, long *status, long *argc, t_atom **argv);
void max_jit_mop_jit_matrix_endprobe(t_object *o);
void max_jit_mop_jit_matrix_probe_tick(t_object *x);
void max_jit_mop_jit_matrix_probe_qfn(t_object *x);

/**
 * @defgroup maxmopmod MOP Max Wrapper Module
    @ingroup jitter
 */

/**
 * Adds default methods and attributes to the MOP Max wrapper class.
 *
 * @ingroup maxmopmod
 *
 * @param   mclass  max jit classex pointer returned from max_jit_classex_setup
 * @param   jclass  t_jit_class pointer, typcially returned from jit_class_findbyname
 * @param   flags   flags to override default MOP Max wrapper behavior
 *
 * @return  t_jit_err error code
 *
 */
t_jit_err max_jit_classex_mop_wrap(void *mclass, void *jclass, long flags)
{
    void *mop,*p,*attr;
    long i,incount,outcount,attrflags;
    char tmpstr[256];
    t_symbol *name;
    
    //grab mop stuff from jit class and add accordingly
    mop = jit_class_adornment_get(jclass,_jit_sym_jit_mop);
    incount  = jit_attr_getlong(mop,_jit_sym_inputcount);
    outcount = jit_attr_getlong(mop,_jit_sym_outputcount);
    
    if (!(flags&MAX_JIT_MOP_FLAGS_OWN_JIT_MATRIX))
        addmess((method)max_jit_mop_jit_matrix,         "jit_matrix",       A_GIMME,0); 
    if (!(flags&MAX_JIT_MOP_FLAGS_OWN_BANG))
        addbang((method)max_jit_mop_bang);  
    if (!(flags&MAX_JIT_MOP_FLAGS_OWN_OUTPUTMATRIX))
        max_addmethod_usurp_low((method)max_jit_mop_outputmatrix, "outputmatrix");  

    attrflags = JIT_ATTR_GET_DEFER_LOW | JIT_ATTR_SET_USURP_LOW;

    if (!(flags&MAX_JIT_MOP_FLAGS_OWN_OUTPUTMODE)) {
        attr = jit_object_new(_jit_sym_jit_attr_offset,"outputmode",_jit_sym_char,attrflags,
            (method)max_jit_mop_getoutputmode_attr,(method)max_jit_mop_outputmode,0/*custom*/);
        object_addattr_parse(attr,"category",_jit_sym_symbol,0,"MOP");
        object_addattr_parse(attr,"style",_jit_sym_symbol,0,"enumindex");
        object_addattr_parse(attr,"enumvals",_jit_sym_atom,0,"\"No Output\" Normal \"Pass Input\" \"Pass Output\"");
        max_jit_classex_addattr(mclass,attr);
    }
    
    if (!(flags&MAX_JIT_MOP_FLAGS_OWN_ADAPT)) {
        attr = jit_object_new(_jit_sym_jit_attr_offset,"adapt",_jit_sym_char,attrflags,
            (method)max_jit_mop_getadapt,(method)max_jit_mop_adapt,0/*custom*/);
        object_addattr_parse(attr,"category",_jit_sym_symbol,0,"MOP");
        object_addattr_parse(attr,"style",_jit_sym_symbol,0,"onoff");
        max_jit_classex_addattr(mclass,attr);
    }
    
    // for each input/output
    // should be different if the object is not all input linked
    for (i=2;i<=incount;i++) {
        if (p=jit_object_method(mop,_jit_sym_getinput,i)) {
            name = jit_attr_getsym(p,_jit_sym_ioname);
            
            sprintf(tmpstr,"%s_name",name->s_name);
            if (!(flags&MAX_JIT_MOP_FLAGS_OWN_NAME)) {
                attr = jit_object_new(_jit_sym_jit_attr_offset,tmpstr,_jit_sym_symbol,attrflags,
                    (method)max_jit_mop_getname,(method)max_jit_mop_name,0/*custom*/);
                object_addattr_parse(attr,"category",_jit_sym_symbol,0,"MOP");
                max_jit_classex_addattr(mclass,attr);
            }           
            
            sprintf(tmpstr,"%s_type",name->s_name);
            if (!(flags&MAX_JIT_MOP_FLAGS_OWN_TYPE)) {
                attr = jit_object_new(_jit_sym_jit_attr_offset,tmpstr,_jit_sym_symbol,attrflags,
                    (method)max_jit_mop_gettype,(method)max_jit_mop_type,0/*custom*/);
                object_addattr_parse(attr,"category",_jit_sym_symbol,0,"MOP");
                object_addattr_parse(attr,"style",_jit_sym_symbol,0,"enum");
                object_addattr_parse(attr,"enumvals",_jit_sym_atom,0,"char long float32 float64");
                max_jit_classex_addattr(mclass,attr);
            }           
            
            sprintf(tmpstr,"%s_dim",name->s_name);
            if (!(flags&MAX_JIT_MOP_FLAGS_OWN_DIM)){
                attr = jit_object_new(_jit_sym_jit_attr_offset_array,tmpstr,_jit_sym_long,JIT_MATRIX_MAX_DIMCOUNT,attrflags,
                    (method)max_jit_mop_getdim,(method)max_jit_mop_dim,0/*custom*/);
                object_addattr_parse(attr,"category",_jit_sym_symbol,0,"MOP");
                max_jit_classex_addattr(mclass,attr);
            }
            
            sprintf(tmpstr,"%s_planecount",name->s_name);
            if (!(flags&MAX_JIT_MOP_FLAGS_OWN_PLANECOUNT)) {
                attr = jit_object_new(_jit_sym_jit_attr_offset,tmpstr,_jit_sym_long,attrflags,
                    (method)max_jit_mop_getplanecount,(method)max_jit_mop_planecount,0/*custom*/);
                object_addattr_parse(attr,"category",_jit_sym_symbol,0,"MOP");
                object_addattr_parse(attr,"style",_jit_sym_symbol,0,"enum");
                object_addattr_parse(attr,"enumvals",_jit_sym_atom,0,"1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32");
                max_jit_classex_addattr(mclass,attr);
            }           
        }
    }
    
    if (outcount!=0) {
        // supports negative number for variable outputs
        addmess((method)max_jit_mop_jit_matrix_startprobe,          "jit_matrix_startprobe",        A_CANT,0);  
        addmess((method)max_jit_mop_jit_matrix_probevalue,          "jit_matrix_probevalue",        A_CANT,0);  
        addmess((method)max_jit_mop_jit_matrix_endprobe,            "jit_matrix_endprobe",          A_CANT,0);  
    }
    
    if (outcount>0) {
        if (p=jit_object_method(mop,_jit_sym_getoutput,1)) {
            name = jit_attr_getsym(p,_jit_sym_ioname);
            
            sprintf(tmpstr,"%s_name",name->s_name);
            if (!(flags&MAX_JIT_MOP_FLAGS_OWN_NAME)) {
                attr = jit_object_new(_jit_sym_jit_attr_offset,tmpstr,_jit_sym_symbol,attrflags,
                    (method)max_jit_mop_getname,(method)max_jit_mop_name,0/*custom*/);
                object_addattr_parse(attr,"category",_jit_sym_symbol,0,"MOP");
                max_jit_classex_addattr(mclass,attr);
            }           
            
            sprintf(tmpstr,"type");
            if (!(flags&MAX_JIT_MOP_FLAGS_OWN_TYPE)) {
                attr = jit_object_new(_jit_sym_jit_attr_offset,tmpstr,_jit_sym_symbol,attrflags,
                    (method)max_jit_mop_gettype,(method)max_jit_mop_type,0/*custom*/);
                object_addattr_parse(attr,"category",_jit_sym_symbol,0,"MOP");
                object_addattr_parse(attr,"style",_jit_sym_symbol,0,"enum");
                object_addattr_parse(attr,"enumvals",_jit_sym_atom,0,"char long float32 float64");
                max_jit_classex_addattr(mclass,attr);
            }           
            
            sprintf(tmpstr,"dim");
            if (!(flags&MAX_JIT_MOP_FLAGS_OWN_DIM)){
                attr = jit_object_new(_jit_sym_jit_attr_offset_array,tmpstr,_jit_sym_long,JIT_MATRIX_MAX_DIMCOUNT,attrflags,
                    (method)max_jit_mop_getdim,(method)max_jit_mop_dim,0/*custom*/);
                object_addattr_parse(attr,"category",_jit_sym_symbol,0,"MOP");
                max_jit_classex_addattr(mclass,attr);
            }
            
            sprintf(tmpstr,"planecount");
            if (!(flags&MAX_JIT_MOP_FLAGS_OWN_PLANECOUNT)) {
                attr = jit_object_new(_jit_sym_jit_attr_offset,tmpstr,_jit_sym_long,attrflags,
                    (method)max_jit_mop_getplanecount,(method)max_jit_mop_planecount,0/*custom*/);
                object_addattr_parse(attr,"category",_jit_sym_symbol,0,"MOP");
                object_addattr_parse(attr,"style",_jit_sym_symbol,0,"enum");
                object_addattr_parse(attr,"enumvals",_jit_sym_atom,0,"1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32");
                max_jit_classex_addattr(mclass,attr);
            }           
        }
    }
    
    for (i=2;i<=outcount;i++) {
        if (p=jit_object_method(mop,_jit_sym_getoutput,i)) {
            name = jit_attr_getsym(p,_jit_sym_ioname);
            
            sprintf(tmpstr,"%s_name",name->s_name);
            if (!(flags&MAX_JIT_MOP_FLAGS_OWN_NAME)) {
                attr = jit_object_new(_jit_sym_jit_attr_offset,tmpstr,_jit_sym_symbol,attrflags,
                    (method)max_jit_mop_getname,(method)max_jit_mop_name,0/*custom*/);
                object_addattr_parse(attr,"category",_jit_sym_symbol,0,"MOP");
                max_jit_classex_addattr(mclass,attr);
            }           
            
            sprintf(tmpstr,"%s_type",name->s_name);
            if (!(flags&MAX_JIT_MOP_FLAGS_OWN_TYPE)) {
                attr = jit_object_new(_jit_sym_jit_attr_offset,tmpstr,_jit_sym_symbol,attrflags,
                    (method)max_jit_mop_gettype,(method)max_jit_mop_type,0/*custom*/);
                object_addattr_parse(attr,"category",_jit_sym_symbol,0,"MOP");
                object_addattr_parse(attr,"style",_jit_sym_symbol,0,"enum");
                object_addattr_parse(attr,"enumvals",_jit_sym_atom,0,"char long float32 float64");
                max_jit_classex_addattr(mclass,attr);
            }           
            
            sprintf(tmpstr,"%s_dim",name->s_name);
            if (!(flags&MAX_JIT_MOP_FLAGS_OWN_DIM)){
                attr = jit_object_new(_jit_sym_jit_attr_offset_array,tmpstr,_jit_sym_long,JIT_MATRIX_MAX_DIMCOUNT,attrflags,
                    (method)max_jit_mop_getdim,(method)max_jit_mop_dim,0/*custom*/);
                object_addattr_parse(attr,"category",_jit_sym_symbol,0,"MOP");
                max_jit_classex_addattr(mclass,attr);
            }
            
            sprintf(tmpstr,"%s_planecount",name->s_name);
            if (!(flags&MAX_JIT_MOP_FLAGS_OWN_PLANECOUNT)) {
                attr = jit_object_new(_jit_sym_jit_attr_offset,tmpstr,_jit_sym_long,attrflags,
                    (method)max_jit_mop_getplanecount,(method)max_jit_mop_planecount,0/*custom*/);
                object_addattr_parse(attr,"category",_jit_sym_symbol,0,"MOP");
                object_addattr_parse(attr,"style",_jit_sym_symbol,0,"enum");
                object_addattr_parse(attr,"enumvals",_jit_sym_atom,0,"1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32");
                max_jit_classex_addattr(mclass,attr);
            }           
        }
    }
    
    //otherwise if variable inputs/outputs, homies gotta do this themselves
    
    if (!(flags&MAX_JIT_MOP_FLAGS_OWN_CLEAR))
        max_addmethod_defer_low((method)max_jit_mop_clear,  "clear");   
    if (!(flags&MAX_JIT_MOP_FLAGS_OWN_NOTIFY))
        addmess((method)max_jit_mop_notify,                 "notify",           A_CANT,0);  

    return JIT_ERR_NONE;
}

t_jit_err max_jit_mop_variable_anything(void *x, t_symbol *s, long argc, t_atom *argv)
{
    long i,iotype,idx,set,ac=0;
    t_symbol *msg=NULL,*name,*name2;
    t_atom  *av=NULL,a;
    char tmpstr[256];
    void *mop,*m,*n,*o,*p;
    t_jit_matrix_info info;
    
    if (!x||!(mop=max_jit_obex_adornment_get(x,_jit_sym_jit_mop)))
        return JIT_ERR_INVALID_PTR;
    
    max_jit_mop_variable_parse_sym(s,&msg,&set);
    if (!msg)
        return JIT_ERR_GENERIC;
    
    if (set) {
        max_jit_mop_parse_name(s,&iotype,&idx);
    } else {
        max_jit_mop_parse_name(gensym(s->s_name+3),&iotype,&idx); //strip get
    }
    
    if (idx!=0) {
        switch (iotype) {
        case JIT_MOP_INPUT:
            if (idx>=2) p=jit_object_method(mop,_jit_sym_getinput,idx);
            break; 
        case JIT_MOP_OUTPUT:
            if (idx>=1) p=jit_object_method(mop,_jit_sym_getoutput,idx);
            break; 
        }
        
        if (p) {
            if (set) {
                if (msg==_jit_sym_name) {
                    if (argc&&argv) {
                        name = jit_atom_getsym(argv);
                    }
                
                    if (name==_jit_sym_nothing) {
                        name = jit_symbol_unique();
                    }

                    //if already something registered with this name, check class_jit_matrix, and handle accordingly
                    if (n=jit_object_findregistered(name)) {
                        if (!jit_object_method(n,_jit_sym_class_jit_matrix)) {
                            jit_object_error((t_object *)x,"%s exists and is not a matrix",name);
                            return JIT_ERR_GENERIC;
                        }
                    }               
                
                    m=jit_object_method(p,_jit_sym_getmatrix);
                    name2 = jit_attr_getsym(p,_jit_sym_matrixname);
                    if (name==name2) {
                        //same name...check matrix pointer just in case
                        if (m!=n) jit_object_error((t_object *)x,"loss of matrix sync %s",name);
                    } else {
                        //if matrix is null, and the named instance doesn't already exist, allocate a new one
                        if (!m&&!n) {
                            jit_matrix_info_default(&info);
                            max_jit_mop_restrict_info(x,p,&info);
                            m = jit_object_new(_jit_sym_jit_matrix, &info);
                        }
                        //could warn user here if incompatible type/dim/planecount
                        jit_object_detach(name, x);
                        jit_attr_setsym(p,_jit_sym_matrixname,name);
                        jit_object_method(p,_jit_sym_matrix,jit_object_method(m,_jit_sym_register,name));
                        jit_object_attach(name, x); 
                    }
                } else {
                    if ((m=jit_object_method(p,_jit_sym_getmatrix))) {              
                        jit_object_method(m,_jit_sym_getinfo,&info);
                        if (msg==_jit_sym_type) {   
                            info.type = jit_atom_getsym(argv);
                            jit_object_method(p,_jit_sym_restrict_type,&info);
                        } else if (msg==_jit_sym_planecount) {  
                            info.planecount = jit_atom_getlong(argv);
                            jit_object_method(p,_jit_sym_restrict_planecount,&info);                    
                        } else if (msg==_jit_sym_dim) { 
                            CLIP(argc,0,JIT_MATRIX_MAX_DIMCOUNT);
                            info.dimcount = argc;
                            for (i=0;i<argc;i++)
                                info.dim[i] = jit_atom_getlong(argv+i);
                            for (;i<JIT_MATRIX_MAX_DIMCOUNT;i++)
                                info.dim[i] = 1;    
                            jit_object_method(p,_jit_sym_restrict_dim,&info);
                        }
                        jit_object_method(m,_jit_sym_setinfo,&info);
                    }
                }
            } else {
                if (msg==_jit_sym_name) {
                    jit_atom_setsym(&a,jit_attr_getsym(p,_jit_sym_matrixname));
                    if (o=max_jit_obex_dumpout_get(x))
                        outlet_anything(o,msg,1,&a);
                } else {
                    if ((m=jit_object_method(p,_jit_sym_getmatrix))) {              
                        sprintf(tmpstr,"get%s",msg->s_name);
                        if (!jit_object_method(m,gensym(tmpstr),&ac,&av)) { 
                            if (o=max_jit_obex_dumpout_get(x))
                                outlet_anything(o,msg,ac,av);
                            if (ac) 
                                jit_freebytes(av,sizeof(t_atom)*ac);
                        }
                    }
                }               
            }
        }
        return JIT_ERR_NONE;
    }

    return JIT_ERR_GENERIC; 
}

/**
 * Sets a custom matrix procedure for the MOP Max wrapper class.
 *
 * @ingroup maxmopmod
 *
 * @param   mclass  max jit classex pointer returned from max_jit_classex_setup
 * @param   jclass  t_jit_class pointer, typcially returned from jit_class_findbyname
 * @param   mproc   matrix procedure
 *
 * @return  t_jit_err error code
 *
 */
t_jit_err max_jit_classex_mop_mproc(void *mclass, void *jclass, void *mproc)
{
    void *mop;

    if (!mclass||!jclass)
        return JIT_ERR_INVALID_PTR;
    mop = jit_class_adornment_get(jclass,_jit_sym_jit_mop);
    return (t_jit_err) jit_object_method(mop,_jit_sym_special,mproc);
}

   
/**
 * Sets up necessary resources for MOP Max wrapper object.
 *
 * @ingroup maxmopmod
 *
 * @param   x   Max object pointer
 *
 * @return  t_jit_err error code
 *
 */
t_jit_err max_jit_mop_setup(void *x)
{
    void *mc,*mo,*jclass;
    
    if (x&&(mc=jit_class_adornment_get(jit_object_class(max_jit_obex_jitob_get(x)),_jit_sym_jit_mop))) 
    {
        if (mo=jit_object_method(mc,_jit_sym_newcopy))
            max_jit_obex_addadornment(x,mo);
    }
    return JIT_ERR_NONE;
}

/**
 * Sets the number of inputs for a variable input MOP Max wrapper object.
 *
 * @ingroup maxmopmod
 *
 * @param   x   Max object pointer
 * @param   c   inlet count
 *
 * @return  t_jit_err error code
 *
 */
t_jit_err max_jit_mop_variable_addinputs(void *x, long c)
{
    void *mop;
    
    if (x&&(mop=max_jit_obex_adornment_get(x,_jit_sym_jit_mop))) 
    {
        return (t_jit_err) jit_object_method(mop,gensym("addinputs"),c);
    } 
    return JIT_ERR_INVALID_PTR;
}

/**
 * Sets the number of outputs for a variable input MOP Max wrapper object.
 *
 * @ingroup maxmopmod
 *
 * @param   x   Max object pointer
 * @param   c   inlet count
 *
 * @return  t_jit_err error code
 *
 */
t_jit_err max_jit_mop_variable_addoutputs(void *x, long c)
{
    void *mop;
    
    if (x&&(mop=max_jit_obex_adornment_get(x,_jit_sym_jit_mop))) 
    {
        return (t_jit_err) jit_object_method(mop,gensym("addoutputs"),c);
    } 
    return JIT_ERR_INVALID_PTR;
}


/**
 * Creates input resources for a MOP Max wrapper object.
 *
 * @ingroup maxmopmod
 *
 * @param   x   Max object pointer
 *
 * @return  t_jit_err error code
 *
 */
t_jit_err max_jit_mop_inputs(void *x)
{
    void *mop,*p,*m;
    long i,incount;
    t_jit_matrix_info info;
    t_symbol *name;
    
    if (x&&(mop=max_jit_obex_adornment_get(x,_jit_sym_jit_mop))) 
    {
        incount  = jit_attr_getlong(mop,_jit_sym_inputcount);
        for (i=2;i<=incount;i++) {
            max_jit_obex_proxy_new(x,(incount+1)-i); //right to left
            if (p=jit_object_method(mop,_jit_sym_getinput,i)) {
                jit_matrix_info_default(&info);
                max_jit_mop_restrict_info(x,p,&info);
                name = jit_symbol_unique();
                m = jit_object_new(_jit_sym_jit_matrix,&info);
                m = jit_object_register(m,name);
                jit_attr_setsym(p,_jit_sym_matrixname,name);
                jit_object_method(p,_jit_sym_matrix,m);
                jit_object_attach(name, x);
            }
        }   
        return JIT_ERR_NONE;
    } 
    return JIT_ERR_INVALID_PTR;
}

/**
 * Creates output resources for a MOP Max wrapper object.
 *
 * @ingroup maxmopmod
 *
 * @param   x   Max object pointer
 *
 * @return  t_jit_err error code
 *
 */
t_jit_err max_jit_mop_outputs(void *x)
{
    void *mop,*p,*m;
    long i,outcount;
    t_jit_matrix_info info;
    t_symbol *name;

    if (x&&(mop=max_jit_obex_adornment_get(x,_jit_sym_jit_mop))) 
    {
        outcount = jit_attr_getlong(mop,_jit_sym_outputcount);
        for (i=1;i<=outcount;i++) {
            max_jit_mop_matrixout_new(x,(outcount)-i);//right to left
            if (p=jit_object_method(mop,_jit_sym_getoutput,i)) {
                jit_matrix_info_default(&info);
                max_jit_mop_restrict_info(x,p,&info);
                name = jit_symbol_unique();
                m = jit_object_new(_jit_sym_jit_matrix,&info);
                m = jit_object_register(m,name);
                jit_attr_setsym(p,_jit_sym_matrixname,name);
                jit_object_method(p,_jit_sym_matrix,m);
                jit_object_attach(name, x);
            }
        }

        return JIT_ERR_NONE;
    } 
    return JIT_ERR_INVALID_PTR;
}

/**
 * Creates matrix outlet for a MOP Max wrapper object.
 *
 * @ingroup maxmopmod
 *
 * @param   x   Max object pointer
 * @param   c   output index (zero based)
 *
 * @return  t_jit_err error code
 *
 */
t_jit_err max_jit_mop_matrixout_new(void *x, long c)
{
    void *mop,*p,*o;
        
    if (!(mop=max_jit_obex_adornment_get(x,_jit_sym_jit_mop)))
        return JIT_ERR_GENERIC;
    
    if (p=jit_object_method(mop,_jit_sym_getoutput,c+1)) // 0 vs 1 based worlds.
    {
        o = outlet_new(x,"jit_matrix"); 
        jit_object_method(p,_jit_sym_special,o);
    }
    
    return JIT_ERR_NONE;
}

/**
 * Process matrix arguments for a MOP Max wrapper object.
 *
 * @ingroup maxmopmod
 *
 * @param   x       Max object pointer
 * @param   argc    argument count
 * @param   argv    argument vector
 *
 * @return  t_jit_err error code
 *
 */
t_jit_err max_jit_mop_matrix_args(void *x, long argc, t_atom *argv)
{
    void *mop,*p,*m;
    long incount,outcount,attrstart,i,j;
    t_jit_matrix_info info,info2;
    
    //deal with matrix args
    //send to matrices if link flag is on
    //if args present set adapt to false
    
    if (!(mop=max_jit_obex_adornment_get(x,_jit_sym_jit_mop)))
        return JIT_ERR_GENERIC;

    incount  = jit_attr_getlong(mop,_jit_sym_inputcount);
    outcount = jit_attr_getlong(mop,_jit_sym_outputcount);
    
    jit_matrix_info_default(&info);
    
    attrstart = max_jit_attr_args_offset(argc,argv);
    if (attrstart&&argv) {
        jit_atom_arg_getlong(&info.planecount, 0, attrstart, argv);
        jit_atom_arg_getsym(&info.type, 1, attrstart, argv);
        i=2; j=0;
        while (i<attrstart) { //dimensions
            jit_atom_arg_getlong(&(info.dim[j]), i, attrstart, argv);
            i++; j++;
        }
        if (j) info.dimcount=j;
        
        jit_attr_setlong(mop,_jit_sym_adapt,0); //adapt off
    }
    
    jit_attr_setlong(mop,_jit_sym_outputmode,1); 
        
    for (i=2;i<=incount;i++) {
        if ((p=jit_object_method(mop,_jit_sym_getinput,i)) &&
            (m=jit_object_method(p,_jit_sym_getmatrix)))
        {
            jit_object_method(m,_jit_sym_getinfo,&info2);
            if (jit_attr_getlong(p,_jit_sym_typelink)) {
                info2.type = info.type;
            }
            if (jit_attr_getlong(p,_jit_sym_planelink)) {
                info2.planecount = info.planecount;
            }
            if (jit_attr_getlong(p,_jit_sym_dimlink)) {
                info2.dimcount = info.dimcount;
                for (j=0;j<info2.dimcount;j++) {
                    info2.dim[j] = info.dim[j];
                }
            }
            max_jit_mop_restrict_info(x,p,&info2);
            jit_object_method(m,_jit_sym_setinfo,&info2);
        }
    }

    for (i=1;i<=outcount;i++) {
        if ((p=jit_object_method(mop,_jit_sym_getoutput,i)) &&
            (m=jit_object_method(p,_jit_sym_getmatrix)))
        {
            jit_object_method(m,_jit_sym_getinfo,&info2);
            if (jit_attr_getlong(p,_jit_sym_typelink)) {
                info2.type = info.type;
            }
            if (jit_attr_getlong(p,_jit_sym_planelink)) {
                info2.planecount = info.planecount;
            }
            if (jit_attr_getlong(p,_jit_sym_dimlink)) {
                info2.dimcount = info.dimcount;
                for (j=0;j<info2.dimcount;j++) {
                    info2.dim[j] = info.dim[j];
                }
            }
            max_jit_mop_restrict_info(x,p,&info2);
            jit_object_method(m,_jit_sym_setinfo,&info2);
        }
    }
        
    return JIT_ERR_NONE;
}

/**
 * Default jit_matrix method for a MOP Max wrapper object.
 *
 * @ingroup maxmopmod
 *
 * @param   x       Max object pointer
 * @param   s       message symbol ("jit_matrix")
 * @param   argc    argument count
 * @param   argv    argument vector
 *
 * @return  t_jit_err error code
 *
 */
t_jit_err max_jit_mop_jit_matrix(void *x, t_symbol *s, long argc, t_atom *argv)
{
    void *matrix,*matrixout,*mop,*o,*p,*m;
    t_atom a;
    t_symbol *matrixname;
    long err=JIT_ERR_NONE,inlet,i;
    method ioproc,mproc;
    
    if (!(mop=max_jit_obex_adornment_get(x,_jit_sym_jit_mop)))
        return JIT_ERR_GENERIC;
    
    if (argc&&argv) {
        //find matrix
        matrixname = jit_atom_getsym(argv);
        matrix = jit_object_findregistered(matrixname);
        if (matrix&&jit_object_method(matrix, _jit_sym_class_jit_matrix)) {
            if (inlet=max_jit_obex_inletnumber_get(x)) {
                //right inputs
                if ((p=jit_object_method(mop,_jit_sym_getinput,inlet+1)) &&
                    (m=jit_object_method(p,_jit_sym_getmatrix))) 
                {
                    if (ioproc=(method)jit_object_method(p,_jit_sym_getioproc))
                        (*ioproc)(mop,p,matrix);
                    else
                        jit_object_method(m,_jit_sym_frommatrix,matrix,NULL);
                } else {
                    err=JIT_ERR_GENERIC;
                }
            } else {
                //calculate
                switch (jit_attr_getlong(mop,_jit_sym_outputmode)) {
                case 0: //nada
                    break;
                case 2: //input(no calc)
                    //pass input through leftmost output
                    if ((p=jit_object_method(mop,_jit_sym_getoutput,1)) &&
                        (o=max_jit_mop_io_getoutlet(p))) 
                    {
                        outlet_anything(o,_jit_sym_jit_matrix,1,argv);
                    }
                    break; 
                case 3: //output(no calc)
                    max_jit_mop_outputmatrix(x);
                    break; 
                default: //calc
                    //if adapt, resize
                    if (jit_attr_getlong(mop,_jit_sym_adapt))
                        max_jit_mop_adapt_matrix_all(x,matrix);
                    if ((p=jit_object_method(mop,_jit_sym_getoutput,1))&&
                        (ioproc=(method)jit_object_method(p,_jit_sym_getioproc)))
                    {   
                        (*ioproc)(mop,p,matrix);
                    }
                    p = jit_object_method(mop,_jit_sym_getinput,1);
                    jit_object_method(p,_jit_sym_matrix,matrix);
                    jit_attr_setsym(p,_jit_sym_matrixname,matrixname);
                    if (mproc=(method)max_jit_mop_getmproc(mop)) {
                        (*mproc)(x,mop);
                    } else {
                        if (err=(t_jit_err) jit_object_method(
                            max_jit_obex_jitob_get(x),
                            _jit_sym_matrix_calc,
                            jit_object_method(mop,_jit_sym_getinputlist),
                            jit_object_method(mop,_jit_sym_getoutputlist))) 
                        {
                            jit_error_code(x,err); 
                        } else {
                            max_jit_mop_outputmatrix(x);
                        }
                    }
                    jit_object_method(p,_jit_sym_matrix,NULL);
                    jit_attr_setsym(p,_jit_sym_matrixname,_jit_sym_nothing);
                    break; 
                }
            }
        } else {
            jit_error_code(x,JIT_ERR_MATRIX_UNKNOWN); 
        }
    }
    
    return err; 
}

/**
 * Default assist method for a MOP Max wrapper object.
 *
 * @ingroup maxmopmod
 *
 * @param   x       Max object pointer
 * @param   b       ignored
 * @param   m       inlet or outlet type
 * @param   a       index
 * @param   s       output string
 *
 * @return  t_jit_err error code
 *
 */
t_jit_err max_jit_mop_assist(void *x, void *b, long m, long a, char *s)
{
    void *mop,*p;
    
    if (!(mop=max_jit_obex_adornment_get(x,_jit_sym_jit_mop)))
        return JIT_ERR_GENERIC;

    if (m == 1) { //input
        if (p=jit_object_method(mop,_jit_sym_getinput,a+1))
            sprintf(s,"(matrix) %s",jit_attr_getsym(p,_jit_sym_ioname)->s_name);            
        else
            return JIT_ERR_GENERIC;
    } else {    //output
        if (p=jit_object_method(mop,_jit_sym_getoutput,a+1))
            sprintf(s,"(matrix) %s",jit_attr_getsym(p,_jit_sym_ioname)->s_name);            
        else {
            //dump outlet(alway righmost)
            //if (rightmost)
                sprintf(s,"dumpout");           
            //else 
            //  return JIT_ERR_GENERIC;
        }       
    }
    
    return JIT_ERR_NONE;
}

/**
 * Default bang method for a MOP Max wrapper object.
 *
 * Simply calls the default outputmatrix method.
 *
 * @ingroup maxmopmod
 *
 * @param   x       Max object pointer
 *
 * @return  t_jit_err error code
 *
 */
t_jit_err max_jit_mop_bang(void *x)
{
    typedmess(x,_jit_sym_outputmatrix,0,0L);
    return JIT_ERR_NONE;
}

/**
 * Default outputmatrix method for a MOP Max wrapper object.
 *
 * Calculates and outputs according to the MOP outputmode attribute.
 *
 * @ingroup maxmopmod
 *
 * @param   x       Max object pointer
 *
 * @return  t_jit_err error code
 *
 */
t_jit_err max_jit_mop_outputmatrix(void *x)
{
    t_atom a;
    void *mop,*p,*o;
    long outcount,outputmode,i;
        
    if (!(mop=max_jit_obex_adornment_get(x,_jit_sym_jit_mop)))
        return JIT_ERR_GENERIC;
    
    outcount   = jit_attr_getlong(mop,_jit_sym_outputcount);
    outputmode = jit_attr_getlong(mop,_jit_sym_outputmode);

    if (outputmode) { //always output unless output mode is none
        //right to left
        for (i=outcount;i>=1;i--) {
            if ((p=jit_object_method(mop,_jit_sym_getoutput,i)) &&
                (o=max_jit_mop_io_getoutlet(p))) 
            {
                jit_atom_setsym(&a,jit_attr_getsym(p,_jit_sym_matrixname)); 
                outlet_anything(o,_jit_sym_jit_matrix,1,&a);
            }
        }
    }
    
    return JIT_ERR_NONE;
}

/**
 * Default clear method for a MOP Max wrapper object.
 *
 * Calls the clear method on all input and output matrices.
 *
 * @ingroup maxmopmod
 *
 * @param   x       Max object pointer
 *
 * @return  t_jit_err error code
 *
 */
void max_jit_mop_clear(void *x)
{
    void *mop,*p,*m;
    long incount,outcount,i;
        
    if (!(mop=max_jit_obex_adornment_get(x,_jit_sym_jit_mop)))
        return;
    
    incount  = jit_attr_getlong(mop,_jit_sym_inputcount);
    outcount = jit_attr_getlong(mop,_jit_sym_outputcount);

    for (i=2;i<=incount;i++) {
        if ((p=jit_object_method(mop,_jit_sym_getinput,i)) &&
            (m=jit_object_method(p,_jit_sym_getmatrix))) 
        {
            jit_object_method(m,_jit_sym_clear);        
        }
    }

    for (i=1;i<=outcount;i++) {
        if ((p=jit_object_method(mop,_jit_sym_getoutput,i)) &&
            (m=jit_object_method(p,_jit_sym_getmatrix)))
        {
            jit_object_method(m,_jit_sym_clear);        
        }
    }
}

/**
 * Default notify method for a MOP Max wrapper object.
 *
 * Handles any notification methods from any input and output matrix.
 *
 * @ingroup maxmopmod
 *
 * @param   x       Max object pointer
 * @param   s       notifier name
 * @param   msg     notification message
 *
 * @return  t_jit_err error code
 *
 */
t_jit_err max_jit_mop_notify(void *x, t_symbol *s, t_symbol *msg)
{
    void *mop,*p,*m;
    t_symbol *name;
    long incount,outcount,i;
    t_jit_matrix_info info;

    if (!(mop=max_jit_obex_adornment_get(x,_jit_sym_jit_mop)))
        return JIT_ERR_GENERIC;
    
    incount  = jit_attr_getlong(mop,_jit_sym_inputcount);
    outcount = jit_attr_getlong(mop,_jit_sym_outputcount);

    if (msg==_jit_sym_free) {
        for (i=2;i<=incount;i++) {
            if (p=jit_object_method(mop,_jit_sym_getinput,i)) 
            {
                name=jit_attr_getsym(p,_jit_sym_matrixname);
                if (s==name) {
                    jit_object_method(jit_object_findregistered(s),_jit_sym_getinfo,&info);
                    m = jit_object_new(_jit_sym_jit_matrix,&info);
                    m = jit_object_register(m,name);
                    name = m?jit_symbol_unique():NULL;
                    jit_attr_setsym(p,_jit_sym_matrixname,name);
                    jit_object_attach(name, x);
                }
            }
        }

        for (i=1;i<=outcount;i++) {
            if (p=jit_object_method(mop,_jit_sym_getoutput,i)) 
            {
                name=jit_attr_getsym(p,_jit_sym_matrixname);
                if (s==name) {
                    jit_object_method(jit_object_findregistered(s),_jit_sym_getinfo,&info);
                    m = jit_object_new(_jit_sym_jit_matrix,&info);
                    m = jit_object_register(m,name);
                    name = m?jit_symbol_unique():NULL;
                    jit_attr_setsym(p,_jit_sym_matrixname,name);
                    jit_object_attach(name, x);
                }
            }
        }
    }
    
    return JIT_ERR_NONE;    
}

/**
 * Frees additional resources used by a MOP Max wrapper object.
 *
 * @ingroup maxmopmod
 *
 * @param   x       Max object pointer
 *
 */
void max_jit_mop_free(void *x)
{
    void *mop,*p,*m;
    t_symbol *name;
    long incount,outcount,i;
    
    if (x==g_jit_matrix_probe_obj)
        max_jit_mop_jit_matrix_endprobe(g_jit_matrix_probe_obj);        
        
    if (!(mop=max_jit_obex_adornment_get(x,_jit_sym_jit_mop)))
        return;
    
    incount  = jit_attr_getlong(mop,_jit_sym_inputcount);
    outcount = jit_attr_getlong(mop,_jit_sym_outputcount);

    if ((p=jit_object_method(mop,_jit_sym_getinput,1)) &&
        (m=jit_object_method(p,_jit_sym_getmatrix)))
    {
        jit_attr_setsym(p,_jit_sym_matrixname,NULL);
        jit_object_method(p,_jit_sym_matrix,NULL);
    }
    
    for (i=2;i<=incount;i++) {
        if ((p=jit_object_method(mop,_jit_sym_getinput,i)) &&
            (m=jit_object_method(p,_jit_sym_getmatrix))) 
        {
            name=jit_attr_getsym(p,_jit_sym_matrixname);
            jit_object_detach(name, x);
            jit_object_free(m);
            jit_attr_setsym(p,_jit_sym_matrixname,NULL);
            jit_object_method(p,_jit_sym_matrix,NULL);
        }
    }

    for (i=1;i<=outcount;i++) {
        if ((p=jit_object_method(mop,_jit_sym_getoutput,i)) &&
            (m=jit_object_method(p,_jit_sym_getmatrix))) 
        {
            name=jit_attr_getsym(p,_jit_sym_matrixname);
            jit_object_detach(name, x);
            jit_object_free(m);
            jit_attr_setsym(p,_jit_sym_matrixname,NULL);
            jit_object_method(p,_jit_sym_matrix,NULL);
        }
    }   
}

//name/type/dim/planecount/adapt get/set accessors
t_jit_err max_jit_mop_outputmode(void *x, void *attr, long argc, t_atom *argv)
{
    void *mop;
        
    if (!(mop=max_jit_obex_adornment_get(x,_jit_sym_jit_mop)))
        return JIT_ERR_GENERIC;
        
    return (t_jit_err) jit_object_method(mop,_jit_sym_outputmode,argc,argv);                    
}

//stupid name since I goofed
t_jit_err max_jit_mop_getoutputmode_attr(void *x, void *attr, long *argc, t_atom **argv)
{
    void *mop;
        
    if (!(mop=max_jit_obex_adornment_get(x,_jit_sym_jit_mop)))
        return JIT_ERR_GENERIC;
        
    return (t_jit_err) jit_object_method(mop,gensym("getoutputmode"),argc,argv);                    
}

t_jit_err max_jit_mop_adapt(void *x, void *attr, long argc, t_atom *argv)
{
    void *mop;
        
    if (!(mop=max_jit_obex_adornment_get(x,_jit_sym_jit_mop)))
        return JIT_ERR_GENERIC;
        
    return (t_jit_err) jit_object_method(mop,_jit_sym_adapt,argc,argv);                 
}

t_jit_err max_jit_mop_getadapt(void *x, void *attr, long *argc, t_atom **argv)
{
    void *mop;
        
    if (!(mop=max_jit_obex_adornment_get(x,_jit_sym_jit_mop)))
        return JIT_ERR_GENERIC;
        
    return (t_jit_err) jit_object_method(mop,gensym("getadapt"),argc,argv);                 
}

t_jit_err max_jit_mop_name(void *x, void *attr, long argc, t_atom *argv)
{
    void *mop,*p=NULL,*m,*n;
    t_symbol *name=_jit_sym_nothing,*name2,*s;
    long incount,outcount,iotype,idx;
    t_jit_matrix_info info;
    
    s = jit_object_method(attr,_jit_sym_getname);
    
    if (argc&&argv) {
        name = jit_atom_getsym(argv);
    }
    
    if (name==_jit_sym_nothing) {
        name = jit_symbol_unique();
    }

    //if already something registered with this name, check class_jit_matrix, and handle accordingly
    if (n=jit_object_findregistered(name)) {
        if (!jit_object_method(n,_jit_sym_class_jit_matrix)) {
            jit_object_error((t_object *)x,"%s exists and is not a matrix",name);
            return JIT_ERR_GENERIC;
        }
    }

    if (!(mop=max_jit_obex_adornment_get(x,_jit_sym_jit_mop)))
        return JIT_ERR_GENERIC;

    max_jit_mop_parse_name(s, &iotype, &idx);

    switch (iotype) {
    case JIT_MOP_INPUT:
        if (idx>=2) p=jit_object_method(mop,_jit_sym_getinput,idx);
        break; 
    case JIT_MOP_OUTPUT:
        if (idx>=1) p=jit_object_method(mop,_jit_sym_getoutput,idx);
        break; 
    }
    
    if (p) {
        m=jit_object_method(p,_jit_sym_getmatrix);
        name2 = jit_attr_getsym(p,_jit_sym_matrixname);
        if (name==name2) {
            //same name...check matrix pointer just in case
            if (m!=n) jit_object_error((t_object *)x,"loss of matrix sync %s",name);
        } else {
            //if matrix is null, and the named instance doesn't already exist, allocate a new one
            if (!m&&!n) {
                jit_matrix_info_default(&info);
                max_jit_mop_restrict_info(x,p,&info);
                m = jit_object_new(_jit_sym_jit_matrix, &info);
            }
            //could warn user here if incompatible type/dim/planecount
            jit_object_detach(name2, x);
            jit_attr_setsym(p,_jit_sym_matrixname,name);
            jit_object_method(p,_jit_sym_matrix,jit_object_method(m,_jit_sym_register,name));
            jit_object_attach(name, x); 
        }           
    }
        
    return JIT_ERR_NONE;
}

t_jit_err max_jit_mop_getname(void *x, void *attr, long *argc, t_atom **argv)
{
    void *p;
    t_symbol *s;
    
    s = jit_object_method(attr,_jit_sym_getname);
        
    if (p=max_jit_mop_get_io_by_name(x,s)) {
        return (t_jit_err) jit_object_method(p,gensym("getmatrixname"),argc,argv);                  
    }
        
    return JIT_ERR_GENERIC;
}


t_jit_err max_jit_mop_type(void *x, void *attr, long argc, t_atom *argv)
{
    void *mop,*p,*m;
    t_symbol *type,*s;
    long incount,outcount,iotype,idx,i;
    t_jit_matrix_info info;
    
    s = jit_object_method(attr,_jit_sym_getname);
    
    if (!argc&&!argv)
        return JIT_ERR_GENERIC;
    
    type = jit_atom_getsym(argv);
    
    if (!(mop=max_jit_obex_adornment_get(x,_jit_sym_jit_mop)))
        return JIT_ERR_GENERIC;

    max_jit_mop_parse_name(s, &iotype, &idx);

    if (idx!=0) {
        switch (iotype) {
        case JIT_MOP_INPUT:
            if (idx>=2) p=jit_object_method(mop,_jit_sym_getinput,idx);
            break; 
        case JIT_MOP_OUTPUT:
            if (idx>=1) p=jit_object_method(mop,_jit_sym_getoutput,idx);
            break; 
        }
        
        if (p) {
            m=jit_object_method(p,_jit_sym_getmatrix);
            if (m) {
                jit_object_method(m,_jit_sym_getinfo,&info);
                info.type = type;
                jit_object_method(p,_jit_sym_restrict_type,&info);
                jit_object_method(m,_jit_sym_setinfo,&info);
            }
        }
    } else {
    
        incount  = jit_attr_getlong(mop,_jit_sym_inputcount);
        outcount = jit_attr_getlong(mop,_jit_sym_outputcount);
        
        for (i=2;i<=incount;i++) {
            if ((p=jit_object_method(mop,_jit_sym_getinput,i)) &&
                (m=jit_object_method(p,_jit_sym_getmatrix)) &&
                jit_attr_getlong(p,_jit_sym_typelink)) 
            {
                jit_object_method(m,_jit_sym_getinfo,&info);
                info.type = type;
                jit_object_method(p,_jit_sym_restrict_type,&info);
                jit_object_method(m,_jit_sym_setinfo,&info);
            }
        }

        for (i=1;i<=outcount;i++) {
            if ((p=jit_object_method(mop,_jit_sym_getoutput,i)) &&
                (m=jit_object_method(p,_jit_sym_getmatrix)) && 
                jit_attr_getlong(p,_jit_sym_typelink)) 
            {
                jit_object_method(m,_jit_sym_getinfo,&info);
                info.type = type;
                jit_object_method(p,_jit_sym_restrict_type,&info);
                jit_object_method(m,_jit_sym_setinfo,&info);
            }
        }
    
    }
        
    return JIT_ERR_NONE;
}

t_jit_err max_jit_mop_gettype(void *x, void *attr, long *argc, t_atom **argv)
{
    void *p,*m;
    t_symbol *s;
    
    s = jit_object_method(attr,_jit_sym_getname);
        
    if ((p=max_jit_mop_get_io_by_name(x,s)) && 
        (m=jit_object_method(p,_jit_sym_getmatrix))) 
    {
        return (t_jit_err) jit_object_method(m,gensym("gettype"),argc,argv);                    
    } else if ((p=max_jit_mop_getoutput(x,1)) && 
        (m=jit_object_method(p,_jit_sym_getmatrix))) 
    {
        return (t_jit_err) jit_object_method(m,gensym("gettype"),argc,argv);                            
    }
        
    return JIT_ERR_GENERIC;
}

t_jit_err max_jit_mop_dim(void *x, void *attr, long argc, t_atom *argv)
{
    void *mop,*p,*m;
    t_symbol *s;
    long incount,outcount,iotype,idx,dim,i,j;
    t_jit_matrix_info info;
    
    s = jit_object_method(attr,_jit_sym_getname);
    
    if (!argc&&!argv)
        return JIT_ERR_GENERIC;
        
    if (!(mop=max_jit_obex_adornment_get(x,_jit_sym_jit_mop)))
        return JIT_ERR_GENERIC;

    max_jit_mop_parse_name(s, &iotype, &idx);

    if (idx!=0) {
        switch (iotype) {
        case JIT_MOP_INPUT:
            if (idx>=2) p=jit_object_method(mop,_jit_sym_getinput,idx);
            break; 
        case JIT_MOP_OUTPUT:
            if (idx>=1) p=jit_object_method(mop,_jit_sym_getoutput,idx);
            break; 
        }
        
        if (p) {
            m=jit_object_method(p,_jit_sym_getmatrix);
            if (m) {
                jit_object_method(m,_jit_sym_getinfo,&info);
                CLIP(argc,0,JIT_MATRIX_MAX_DIMCOUNT);
                info.dimcount = argc;
                for (i=0;i<argc;i++)
                    info.dim[i] = jit_atom_getlong(argv+i);
                for (;i<JIT_MATRIX_MAX_DIMCOUNT;i++)
                    info.dim[i] = 1;    
                jit_object_method(p,_jit_sym_restrict_dim,&info);
                jit_object_method(m,_jit_sym_setinfo,&info);
            }
        }
    } else {
        incount  = jit_attr_getlong(mop,_jit_sym_inputcount);
        outcount = jit_attr_getlong(mop,_jit_sym_outputcount);
        
        for (i=2;i<=incount;i++) {
            if ((p=jit_object_method(mop,_jit_sym_getinput,i)) &&
                (m=jit_object_method(p,_jit_sym_getmatrix)) &&
                jit_attr_getlong(p,_jit_sym_dimlink)) 
            {
                jit_object_method(m,_jit_sym_getinfo,&info);
                CLIP(argc,0,JIT_MATRIX_MAX_DIMCOUNT);
                info.dimcount = argc;
                for (j=0;j<argc;j++)
                    info.dim[j] = jit_atom_getlong(argv+j);
                for (;j<JIT_MATRIX_MAX_DIMCOUNT;j++)
                    info.dim[j] = 1;    
                jit_object_method(p,_jit_sym_restrict_dim,&info);
                jit_object_method(m,_jit_sym_setinfo,&info);
            }
        }

        for (i=1;i<=outcount;i++) {
            if ((p=jit_object_method(mop,_jit_sym_getoutput,i)) &&
                (m=jit_object_method(p,_jit_sym_getmatrix)) && 
                jit_attr_getlong(p,_jit_sym_dimlink)) 
            {
                jit_object_method(m,_jit_sym_getinfo,&info);
                CLIP(argc,0,JIT_MATRIX_MAX_DIMCOUNT);
                info.dimcount = argc;
                for (j=0;j<argc;j++)
                    info.dim[j] = jit_atom_getlong(argv+j);
                for (;j<JIT_MATRIX_MAX_DIMCOUNT;j++)
                    info.dim[j] = 1;    
                jit_object_method(p,_jit_sym_restrict_dim,&info);
                jit_object_method(m,_jit_sym_setinfo,&info);
            }
        }
    
    }
        
    return JIT_ERR_NONE;
}

t_jit_err max_jit_mop_getdim(void *x, void *attr, long *argc, t_atom **argv)
{
    void *p,*m;
    t_symbol *s;
    
    s = jit_object_method(attr,_jit_sym_getname);
        
    if ((p=max_jit_mop_get_io_by_name(x,s)) && 
        (m=jit_object_method(p,_jit_sym_getmatrix))) 
    {
        return (t_jit_err) jit_object_method(m,gensym("getdim"),argc,argv);                 
    } else if ((p=max_jit_mop_getoutput(x,1)) && 
        (m=jit_object_method(p,_jit_sym_getmatrix))) 
    {
        return (t_jit_err) jit_object_method(m,gensym("getdim"),argc,argv);                         
    }
        
    return JIT_ERR_GENERIC;
}

/**
 * Adapts all input and output matrices to matrix specified.
 *
 * Typically used within the MOP Max Wrapper jit_matrix method
 * for left most input.
 *
 * @ingroup maxmopmod
 *
 * @param   x       Max object pointer
 * @param   y       matrix to adapt to
 *
 * @return  t_jit_err error code
 *
 */
t_jit_err max_jit_mop_adapt_matrix_all(void *x, void *y)
{
    void *mop,*tmp,*p,*m,*ioproc;
    long incount,outcount,iotype,idx,dim,i,j,change;
    t_jit_matrix_info info,info2;
            
    if (!x||!y||!(mop=max_jit_obex_adornment_get(x,_jit_sym_jit_mop)))
        return JIT_ERR_GENERIC;

    incount  = jit_attr_getlong(mop,_jit_sym_inputcount);
    outcount = jit_attr_getlong(mop,_jit_sym_outputcount);
    
    jit_object_method(y,_jit_sym_getinfo,&info);

    for (i=2;i<=incount;i++) {  
        if ((p=jit_object_method(mop,_jit_sym_getinput,i)) &&
            (m=jit_object_method(p,_jit_sym_getmatrix)))
        {
            change = FALSE;
            jit_object_method(m,_jit_sym_getinfo,&info2);
            if (jit_attr_getlong(p,_jit_sym_typelink)&&(info2.type!=info.type)) { 
                change = TRUE;
                info2.type = info.type;
            }
            if (jit_attr_getlong(p,_jit_sym_planelink)&&(info2.planecount!=info.planecount)) {
                change = TRUE;
                info2.planecount = info.planecount;
            }
            if (jit_attr_getlong(p,_jit_sym_dimlink)) {
                if (info2.dimcount!=info.dimcount) {
                    change = TRUE;
                    info2.dimcount = info.dimcount;
                }
                for (j=0;j<info2.dimcount;j++) {
                    if (info2.dim[j]!=info.dim[j]) {
                        change = TRUE;
                        info2.dim[j] = info.dim[j];
                    }
                }
            }
            if (change) {
                max_jit_mop_restrict_info(x,p,&info2); 
                tmp = jit_object_new(_jit_sym_jit_matrix,&info2);
                jit_object_method(tmp,_jit_sym_frommatrix,m,NULL);
                jit_object_method(m,_jit_sym_setinfo,&info2);
                jit_object_method(m,_jit_sym_frommatrix,tmp,NULL);
                jit_object_free(tmp);
            }
        }
    }

    for (i=1;i<=outcount;i++) {
        if ((p=jit_object_method(mop,_jit_sym_getoutput,i)) &&
            (m=jit_object_method(p,_jit_sym_getmatrix)) &&
            (!(ioproc=jit_object_method(p,_jit_sym_getioproc))))
        {
            change = FALSE;
            jit_object_method(m,_jit_sym_getinfo,&info2);
            if (jit_attr_getlong(p,_jit_sym_typelink)) { 
                info2.type = info.type;
                change = TRUE;
            }
            if (jit_attr_getlong(p,_jit_sym_planelink)) {
                info2.planecount = info.planecount;
                change = TRUE;
            }
            if (jit_attr_getlong(p,_jit_sym_dimlink)) {
                info2.dimcount = info.dimcount;
                for (j=0;j<info2.dimcount;j++) {
                    info2.dim[j] = info.dim[j];
                    change = TRUE;
                }
            }
            if (change) {
                max_jit_mop_restrict_info(x,p,&info2);
                jit_object_method(m,_jit_sym_setinfo,&info2);
            }
        }
    }
        
    return JIT_ERR_NONE;
}

t_jit_err max_jit_mop_planecount(void *x, void *attr, long argc, t_atom *argv)
{
    void *mop,*p,*m;
    t_symbol *s;
    long incount,outcount,iotype,planecount,idx,i;
    t_jit_matrix_info info;
    
    s = jit_object_method(attr,_jit_sym_getname);
    
    if (!argc&&!argv)
        return JIT_ERR_GENERIC;
    
    planecount = jit_atom_getlong(argv);
    
    if (!(mop=max_jit_obex_adornment_get(x,_jit_sym_jit_mop)))
        return JIT_ERR_GENERIC;

    max_jit_mop_parse_name(s, &iotype, &idx);

    if (idx!=0) {
        switch (iotype) {
        case JIT_MOP_INPUT:
            if (idx>=2) p=jit_object_method(mop,_jit_sym_getinput,idx);
            break; 
        case JIT_MOP_OUTPUT:
            if (idx>=1) p=jit_object_method(mop,_jit_sym_getoutput,idx);
            break; 
        }
        
        if (p) {
            m=jit_object_method(p,_jit_sym_getmatrix);
            if (m) {
                jit_object_method(m,_jit_sym_getinfo,&info);
                info.planecount = planecount;
                jit_object_method(p,_jit_sym_restrict_planecount,&info);
                jit_object_method(m,_jit_sym_setinfo,&info);
            }
        }
    } else {
    
        incount  = jit_attr_getlong(mop,_jit_sym_inputcount);
        outcount = jit_attr_getlong(mop,_jit_sym_outputcount);
        
        for (i=2;i<=incount;i++) {
            if ((p=jit_object_method(mop,_jit_sym_getinput,i)) &&
                (m=jit_object_method(p,_jit_sym_getmatrix)) &&
                jit_attr_getlong(p,_jit_sym_planelink)) 
            {
                jit_object_method(m,_jit_sym_getinfo,&info);
                info.planecount = planecount;
                jit_object_method(p,_jit_sym_restrict_planecount,&info);
                jit_object_method(m,_jit_sym_setinfo,&info);
            }
        }

        for (i=1;i<=outcount;i++) {
            if ((p=jit_object_method(mop,_jit_sym_getoutput,i)) &&
                (m=jit_object_method(p,_jit_sym_getmatrix)) && 
                jit_attr_getlong(p,_jit_sym_planelink)) 
            {
                jit_object_method(m,_jit_sym_getinfo,&info);
                info.planecount = planecount;
                jit_object_method(p,_jit_sym_restrict_planecount,&info);
                jit_object_method(m,_jit_sym_setinfo,&info);
            }
        }
    
    }
        
    return JIT_ERR_NONE;
}

t_jit_err max_jit_mop_getplanecount(void *x, void *attr, long *argc, t_atom **argv)
{
    void *p,*m;
    t_symbol *s;
    
    s = jit_object_method(attr,_jit_sym_getname);
        
    if ((p=max_jit_mop_get_io_by_name(x,s)) && 
        (m=jit_object_method(p,_jit_sym_getmatrix))) 
    {
        return (t_jit_err) jit_object_method(m,gensym("getplanecount"),argc,argv);                  
    } else if ((p=max_jit_mop_getoutput(x,1)) && 
        (m=jit_object_method(p,_jit_sym_getmatrix))) 
    {
        return (t_jit_err) jit_object_method(m,gensym("getplanecount"),argc,argv);                          
    }
        
    return JIT_ERR_GENERIC;
}

t_jit_err max_jit_mop_parse_name(t_symbol *name, long *type, long *idx)
{
    long i=1,v=0;
    char *p;
    
    if (name&&type&&idx) {
        *type = 0;
        *idx = 0;
        if (name->s_name[0]=='i'&&
            name->s_name[1]=='n') 
        {
            *type = JIT_MOP_INPUT;
            p = name->s_name;
            //move forward until end of string or '_'
            while (p[1]&&p[1]!='_') p++;
            //now move backwards + count
            while (*p>='0'&&*p<='9'&&p>name->s_name) {
                v += ((*p)-'0')*i;
                i *= 10;
                p--;
            }
            *idx = v?v:1;
        } else 
        if (name->s_name[0]=='o'&&
            name->s_name[1]=='u'&&
            name->s_name[2]=='t')
        {       
            *type = JIT_MOP_OUTPUT;
            p = name->s_name;
            //move forward until end of string or '_'
            while (p[1]&&p[1]!='_') p++;
            //now move backwards + count
            while (*p>='0'&&*p<='9'&&p>name->s_name) {
                v += ((*p)-'0')*i;
                i *= 10;
                p--;
            }
            *idx = v?v:1;
        }
        return JIT_ERR_NONE;
    }

    return JIT_ERR_INVALID_PTR;
}

t_jit_err max_jit_mop_variable_parse_sym(t_symbol *name, t_symbol **msg, long *set)
{
    long i=1,v=0;
    char *p;
    
    if (name&&msg&&set) {
        p = name->s_name;
        *set = !(p[0]=='g'&&p[1]=='e'&&p[2]=='t');

        //move forward until end of string or '_'
        while (p[1]&&p[1]!='_') p++;
        if (!p[1]) 
            return JIT_ERR_GENERIC;
    
        *msg = gensym(p+2); 
        return JIT_ERR_NONE;
    }

    return JIT_ERR_INVALID_PTR;
}

t_jit_err max_jit_mop_restrict_info(void *x, void *p, t_jit_matrix_info *info)
{
    long rv=0; 
    rv = ((long) jit_object_method(p,_jit_sym_restrict_type,info)           || rv);
    rv = ((long) jit_object_method(p,_jit_sym_restrict_dim,info)            || rv);
    rv = ((long) jit_object_method(p,_jit_sym_restrict_planecount,info)     || rv);
    return rv?JIT_ERR_GENERIC:JIT_ERR_NONE;
}

/**
 * Retrieves t_jit_mop_io object pointer by name.
 *
 * @ingroup maxmopmod
 *
 * @param   x       Max object pointer
 * @param   s       input/output name (e.g. in, in2 , out, out2, etc.)
 *
 * @return  t_jit_err error code
 *
 */
void *max_jit_mop_get_io_by_name(void *x, t_symbol *s)
{
    void *mop,*p=NULL;
    long iotype,idx;
    
    
    if (!(mop=max_jit_obex_adornment_get(x,_jit_sym_jit_mop)))
        return NULL;

    max_jit_mop_parse_name(s, &iotype, &idx);

    if (idx!=0) {
        switch (iotype) {
        case JIT_MOP_INPUT:
            if (idx>=2) p=jit_object_method(mop,_jit_sym_getinput,idx);
            break; 
        case JIT_MOP_OUTPUT:
            if (idx>=1) p=jit_object_method(mop,_jit_sym_getoutput,idx);
            break; 
        }
    }
    return p;
}   

/**
 * Retrieves input t_jit_mop_io object pointer index.
 *
 * @ingroup maxmopmod
 *
 * @param   x       Max object pointer
 * @param   c       input index
 *
 * @return  t_jit_err error code
 *
 */
void *max_jit_mop_getinput(void *x, long c)
{
    void *mop;
    
    if (!(mop=max_jit_obex_adornment_get(x,_jit_sym_jit_mop)))
        return NULL;
    
    return jit_object_method(mop,_jit_sym_getinput,c);
}   

/**
 * Retrieves output t_jit_mop_io object pointer index.
 *
 * @ingroup maxmopmod
 *
 * @param   x       Max object pointer
 * @param   c       output index
 *
 * @return  t_jit_err error code
 *
 */
void *max_jit_mop_getoutput(void *x, long c)
{
    void *mop;
    
    if (!(mop=max_jit_obex_adornment_get(x,_jit_sym_jit_mop)))
        return NULL;
    
    return jit_object_method(mop,_jit_sym_getoutput,c);
}   

/**
 * Retrieves current MOP Max wrapper class output mode.
 *
 * @ingroup maxmopmod
 *
 * @param   x       Max object pointer
 *
 * @return  t_jit_err error code
 *
 */
long max_jit_mop_getoutputmode(void *x)
{
    void *mop;
    
    if (!(mop=max_jit_obex_adornment_get(x,_jit_sym_jit_mop)))
        return 0;
    
    return jit_attr_getlong(mop,_jit_sym_outputmode);
}

void *max_jit_mop_io_getoutlet(void *mop_io)
{
    return jit_object_method(mop_io,_jit_sym_getspecial);
}

void *max_jit_mop_getmproc(void *mop)
{
    return jit_object_method(mop,_jit_sym_getspecial);
}

t_jit_err max_jit_mop_io_setoutlet(void *mop_io, void *o)
{
    return (t_jit_err) jit_object_method(mop_io,_jit_sym_special,o);
}

/**
 * Initializes default state and resources for MOP Max wrapper class.
 *
 * @ingroup maxmopmod
 *
 * @param   x       Max object pointer
 * @param   o       Jitter object pointer
 * @param   argc    argument count
 * @param   argv    argument vector
 *
 * @return  t_jit_err error code
 *
 * @code
    max_jit_obex_jitob_set(x,o);
    max_jit_obex_dumpout_set(x,outlet_new(x,NULL));
    max_jit_mop_setup(x);
    max_jit_mop_inputs(x);
    max_jit_mop_outputs(x);
    max_jit_mop_matrix_args(x,argc,argv);

    return JIT_ERR_NONE; 
 * @endcode
 */
t_jit_err max_jit_mop_setup_simple(void *x, void *o, long argc, t_atom *argv)
{
    max_jit_obex_jitob_set(x,o);
    max_jit_obex_dumpout_set(x,outlet_new(x,NULL));
    max_jit_mop_setup(x);
    max_jit_mop_inputs(x);
    max_jit_mop_outputs(x);
    max_jit_mop_matrix_args(x,argc,argv);

    return JIT_ERR_NONE;
}


void *max_jit_mop_jit_matrix_startprobe(t_object *o) 
{
    void *mop;

    //jit_object_post((t_object *)x,"start probe %x",o);
    if (o == g_jit_matrix_probe_obj)
        return NULL;
    if (g_jit_matrix_probe_obj) 
        max_jit_mop_jit_matrix_endprobe(g_jit_matrix_probe_obj);
    
    if (!(mop=max_jit_obex_adornment_get(o,_jit_sym_jit_mop)))
        return NULL;
    
    //initialize o as the new probed object
    g_jit_matrix_probe_obj = o;
    
    // confused about return value based on singal probe which returns the t_proboxy * 
    //return NULL;
    return g_jit_matrix_probe_obj;
}

void *max_jit_mop_jit_matrix_probevalue(t_object *o, long innum, long outnum, long *status, long *argc, t_atom **argv)
{
    //jit_object_post((t_object *)x,"probe value %x outnum %d",o,outnum);

    // o is the object you said was OK to probe in startprobe
    // for now ignore innum (inlet number)
    // do something that is a side-effect of being called, such as passing a matrix the object
    // is outputting for outnum (starts at 0, left to right) to a jit.pwindow

    // we just set up the polling here
    // setup our qelem + clock
    g_jit_matrix_probe_outnum = outnum;
    
    if (!g_jit_matrix_probe_qelem)
        g_jit_matrix_probe_qelem = qelem_new(gensym("jitter")->s_thing, (method)max_jit_mop_jit_matrix_probe_qfn);
    if (!g_jit_matrix_probe_clock)
        g_jit_matrix_probe_clock = clock_new(gensym("jitter")->s_thing, (method)max_jit_mop_jit_matrix_probe_tick);

    // if this starts to be called more than once, I suppose we need more intelligence?
    //clock_unset(g_jit_matrix_probe_clock);
    //qelem_unset(g_jit_matrix_probe_qelem);
    clock_delay(g_jit_matrix_probe_clock,0);
    
    // anything you return in args is ignored
    return NULL;
}

void max_jit_mop_jit_matrix_endprobe(t_object *o)
{
    //jit_object_post((t_object *)x,"end probe %x",o);
    // clean up
    if (g_jit_matrix_probe_clock)
        clock_unset(g_jit_matrix_probe_clock);
    if (g_jit_matrix_probe_qelem)
        qelem_unset(g_jit_matrix_probe_qelem);
    g_jit_matrix_probe_obj = NULL;
}

void max_jit_mop_jit_matrix_probe_tick(t_object *x)
{
    qelem_set(g_jit_matrix_probe_qelem);
    clock_delay(g_jit_matrix_probe_clock,JIT_MATRIX_PROBE_INTERVAL);
}

void max_jit_mop_jit_matrix_probe_qfn(t_object *x)
{
    t_atom a;
    void *mop,*p;
    static t_symbol *rname=NULL;
    t_object *o=g_jit_matrix_probe_obj;
    
    if (!rname)
        rname = gensym("__jit_matrix_probe_receive");
    
    if (o) {
        if (!(mop = max_jit_obex_adornment_get(o,_jit_sym_jit_mop)))
            return;
        
        if (p=jit_object_method(mop,_jit_sym_getoutput,g_jit_matrix_probe_outnum+1)) { // one-based, not zerobased
            jit_atom_setsym(&a,jit_attr_getsym(p,_jit_sym_matrixname)); 

            //jit_object_post((t_object *)x,"probe value sending it");
            if (rname->s_thing) 
                typedmess(rname->s_thing,_jit_sym_jit_matrix,1,&a);
        }
    }
}

void max_jit_mop_jit_matrix_showprobe();
void max_jit_mop_jit_matrix_showprobe()
{
    t_atom a[2];
    atom_setsym(a,gensym("__jit_matrix_probe_window_ptr"));
    atom_setsym(a+1,gensym("jit_matrix_probe.maxpat"));
    typedmess(gensym("max")->s_thing,gensym("openfilefront"),2,a);
}

Copyright © 2008, Cycling '74