Max 5 API Reference

jit.mop.c

/* 
    jit.mop.c

    Copyright 2001-2005 - Cycling '74
    Joshua Kit Clayton jkc@cycling74.com
    
*/

#include "jit.common.h"

/**
 * @defgroup mopmod MOP Module
    @ingroup jitter
 */

#define JIT_MATRIX_MAX_TYPES        16  //for future use
#define JIT_MOP_SIZE_VARIABLE       -1  
#define JIT_MOP_INPUT_RESAMP        0   
#define JIT_MOP_INPUT_RESIZE        1   
#define JIT_MOP_INPUT_TRUNC         2           

void *_jit_mop_io_class;
void *_jit_mop_class;

/**
 * t_jit_mop_io object struct.
 *
 * @ingroup mopmod
 *
 * @warning This struct should not be accessed directly, 
 *          but is provided for reference when calling 
 *          Jitter attribute functions.
 */
typedef struct _jit_mop_io
{
    t_jit_object    ob;             ///< standard object header
    void            *special;       ///< special data pointer for use by wrappers of various kinds (e.g. max wrapper)
    t_symbol        *ioname;        ///< "ioname" attribute
    t_symbol        *matrixname;    ///< "matrixname" attribute
    void            *matrix;        ///< internal matrix, accessed via methods (unused in class template MOP)
    t_symbol        *types[JIT_MATRIX_MAX_TYPES];       ///< "types" attribute
    long            mindim[JIT_MATRIX_MAX_DIMCOUNT];    ///< "mindim" attribute
    long            maxdim[JIT_MATRIX_MAX_DIMCOUNT];    ///< "maxdim" attribute
    long            typescount;     ///< relevant to "types" attribute
    long            mindimcount;    ///< "mindimcount" attribute 
    long            maxdimcount;    ///< "maxdimcount" attribute
    long            minplanecount;  ///< "minplanecount" attribute
    long            maxplanecount;  ///< "maxplanecount" attribute
    //flags
    char            typelink;       ///< "typelink" attribute
    char            dimlink;        ///< "dimlink" attribute
    char            planelink;      ///< "planelink" attribute  
    method          ioproc;         ///< I/O procedure, accessed via methods
} t_jit_mop_io;

/**
 * t_jit_mop object struct.
 *
 * @ingroup mopmod
 *
 * @warning This struct should not be accessed directly, 
 *          but is provided for reference when calling 
 *          Jitter attribute functions.
 */
typedef struct _jit_mop
{
    t_jit_object        ob;             ///< standard object header
    void                *special;       ///< special data pointer for use by wrappers of various kinds (e.g. max wrapper)
    long                inputcount;     ///< "inputcount" attribute
    long                outputcount;    ///< "inputcount" attribute
    t_jit_linklist      *inputlist;     ///< linked list of inputs, accessed via methods
    t_jit_linklist      *outputlist;    ///< linked list of inputs, accessed via methods
    //flags
    char                caninplace;     ///< deprecated
    char                adapt;          ///< "adapt" attribute
    char                outputmode;     ///< "outputmode" attribute
} t_jit_mop;

//the first input is different than other inputs since 
//it doesn't store matrices, only processes them

t_jit_object *jit_mop_io_new(void);
t_jit_object *jit_mop_io_newcopy(t_jit_mop_io *x);
t_jit_err jit_mop_io_free(t_jit_mop *x);
t_jit_err jit_mop_io_restrict_type(t_jit_mop_io *x, t_jit_matrix_info *info);
t_jit_err jit_mop_io_restrict_planecount(t_jit_mop_io *x, t_jit_matrix_info *info);
t_jit_err jit_mop_io_restrict_dim(t_jit_mop_io *x, t_jit_matrix_info *info);
t_jit_err jit_mop_io_special(t_jit_mop_io *x, void *special);
void *jit_mop_io_getspecial(t_jit_mop_io *x);
t_jit_err jit_mop_io_matrix(t_jit_mop_io *x, void *m);
void *jit_mop_io_getmatrix(t_jit_mop_io *x);
t_jit_err jit_mop_io_ioproc(t_jit_mop_io *x, method ioproc);
method jit_mop_io_getioproc(t_jit_mop_io *x);
void *jit_mop_io_decorator(t_jit_mop_io *x, t_symbol *s);

t_jit_object *jit_mop_new(long inputcount, long outputcount);
t_jit_object *jit_mop_newcopy(t_jit_mop *x);
void *jit_mop_getinput(t_jit_mop *x, long i);
void *jit_mop_getoutput(t_jit_mop *x, long i);
void *jit_mop_getinputlist(t_jit_mop *x);
void *jit_mop_getoutputlist(t_jit_mop *x);
t_jit_err jit_mop_free(t_jit_mop *x);
t_jit_err jit_mop_matrix_calc(t_jit_mop *x, void *o);
t_jit_err jit_mop_special(t_jit_mop *x, void *special);
void *jit_mop_getspecial(t_jit_mop *x);
t_jit_err jit_mop_addinputs(t_jit_mop *x, long c); 
t_jit_err jit_mop_addoutputs(t_jit_mop *x, long c); 

static t_symbol *ps_resamp,*ps_adapt,*ps_trunc,*ps_trunc_zero,*ps_custom;

t_jit_err jit_mop_init(void)
{
    long attrflags;
    void *attr;
    
    //_jit_mop_io_class
    _jit_mop_io_class = jit_class_new("jit_mop_io",(method)jit_mop_io_new,(method)jit_mop_io_free,
        sizeof(t_jit_mop_io),A_CANT,0L); //A_CANT = untyped

    //add methods
    jit_class_addmethod(_jit_mop_io_class, (method)jit_mop_io_newcopy,              "newcopy",              A_CANT, 0L);
    jit_class_addmethod(_jit_mop_io_class, (method)jit_mop_io_restrict_type,        "restrict_type",        A_CANT, 0L);
    jit_class_addmethod(_jit_mop_io_class, (method)jit_mop_io_restrict_planecount,  "restrict_planecount",  A_CANT, 0L);
    jit_class_addmethod(_jit_mop_io_class, (method)jit_mop_io_restrict_dim,         "restrict_dim",         A_CANT, 0L);
    jit_class_addmethod(_jit_mop_io_class, (method)jit_mop_io_special,              "special",              A_CANT, 0L);
    jit_class_addmethod(_jit_mop_io_class, (method)jit_mop_io_getspecial,           "getspecial",           A_CANT, 0L);
    jit_class_addmethod(_jit_mop_io_class, (method)jit_mop_io_decorator,            "decorator",            A_CANT, 0L);
    jit_class_addmethod(_jit_mop_io_class, (method)jit_mop_io_matrix,               "matrix",               A_CANT, 0L);
    jit_class_addmethod(_jit_mop_io_class, (method)jit_mop_io_getmatrix,            "getmatrix",            A_CANT, 0L);
    jit_class_addmethod(_jit_mop_io_class, (method)jit_mop_io_ioproc,               "ioproc",               A_CANT, 0L);
    jit_class_addmethod(_jit_mop_io_class, (method)jit_mop_io_getioproc,            "getioproc",            A_CANT, 0L);

    //add attributes
    attrflags = 0;
    attr = jit_object_new(_jit_sym_jit_attr_offset_array,"types",_jit_sym_symbol,JIT_MATRIX_MAX_TYPES,attrflags,
        (method)0L,(method)0L,calcoffset(t_jit_mop_io,typescount),calcoffset(t_jit_mop_io,types));
    jit_class_addattr(_jit_mop_io_class,attr);
    attr = jit_object_new(_jit_sym_jit_attr_offset_array,"mindim",_jit_sym_long,JIT_MATRIX_MAX_DIMCOUNT,attrflags,
        (method)0L,(method)0L,calcoffset(t_jit_mop_io,mindimcount),calcoffset(t_jit_mop_io,mindim));
    jit_class_addattr(_jit_mop_io_class,attr);
    attr = jit_object_new(_jit_sym_jit_attr_offset_array,"maxdim",_jit_sym_long,JIT_MATRIX_MAX_DIMCOUNT,attrflags,
        (method)0L,(method)0L,calcoffset(t_jit_mop_io,maxdimcount),calcoffset(t_jit_mop_io,maxdim));
    jit_class_addattr(_jit_mop_io_class,attr);
    attr = jit_object_new(_jit_sym_jit_attr_offset,"mindimcount",_jit_sym_long,attrflags,
        (method)0L,(method)0L,calcoffset(t_jit_mop_io,mindimcount));
    jit_class_addattr(_jit_mop_io_class,attr);
    attr = jit_object_new(_jit_sym_jit_attr_offset,"maxdimcount",_jit_sym_long,attrflags,
        (method)0L,(method)0L,calcoffset(t_jit_mop_io,maxdimcount));
    jit_class_addattr(_jit_mop_io_class,attr);
    attr = jit_object_new(_jit_sym_jit_attr_offset,"minplanecount",_jit_sym_long,attrflags,
        (method)0L,(method)0L,calcoffset(t_jit_mop_io,minplanecount));
    jit_class_addattr(_jit_mop_io_class,attr);
    attr = jit_object_new(_jit_sym_jit_attr_offset,"maxplanecount",_jit_sym_long,attrflags,
        (method)0L,(method)0L,calcoffset(t_jit_mop_io,maxplanecount));
    jit_class_addattr(_jit_mop_io_class,attr);
    attr = jit_object_new(_jit_sym_jit_attr_offset,"typelink",_jit_sym_char,attrflags,
        (method)0L,(method)0L,calcoffset(t_jit_mop_io,typelink));
    jit_class_addattr(_jit_mop_io_class,attr);
    attr = jit_object_new(_jit_sym_jit_attr_offset,"dimlink",_jit_sym_char,attrflags,
        (method)0L,(method)0L,calcoffset(t_jit_mop_io,dimlink));
    jit_class_addattr(_jit_mop_io_class,attr);
    attr = jit_object_new(_jit_sym_jit_attr_offset,"planelink",_jit_sym_char,attrflags,
        (method)0L,(method)0L,calcoffset(t_jit_mop_io,planelink));
    jit_class_addattr(_jit_mop_io_class,attr);
    attr = jit_object_new(_jit_sym_jit_attr_offset,"ioname",_jit_sym_symbol,attrflags,
        (method)0L,(method)0L,calcoffset(t_jit_mop_io,ioname));
    jit_class_addattr(_jit_mop_io_class,attr);
    attr = jit_object_new(_jit_sym_jit_attr_offset,"matrixname",_jit_sym_symbol,attrflags,
        (method)0L,(method)0L,calcoffset(t_jit_mop_io,matrixname));
    jit_class_addattr(_jit_mop_io_class,attr);
        
    jit_class_register(_jit_mop_io_class);

    //_jit_mop_class
    _jit_mop_class = jit_class_new("jit_mop",(method)jit_mop_new,(method)jit_mop_free,
        sizeof(t_jit_mop),A_CANT,0L); //A_CANT = untyped

    jit_class_addmethod(_jit_mop_class, (method)jit_mop_matrix_calc,        "matrix_calc",      A_CANT, 0L);
    jit_class_addmethod(_jit_mop_class, (method)jit_mop_getinput,           "getinput",         A_CANT, 0L);
    jit_class_addmethod(_jit_mop_class, (method)jit_mop_getoutput,          "getoutput",        A_CANT, 0L);
    jit_class_addmethod(_jit_mop_class, (method)jit_mop_getinputlist,       "getinputlist",     A_CANT, 0L);
    jit_class_addmethod(_jit_mop_class, (method)jit_mop_getoutputlist,      "getoutputlist",    A_CANT, 0L);
    jit_class_addmethod(_jit_mop_class, (method)jit_mop_special,            "special",              A_CANT, 0L);
    jit_class_addmethod(_jit_mop_class, (method)jit_mop_getspecial,         "getspecial",           A_CANT, 0L);
    jit_class_addmethod(_jit_mop_class, (method)jit_mop_newcopy,            "newcopy",          A_CANT, 0L);
    jit_class_addmethod(_jit_mop_class, (method)jit_mop_addinputs,          "addinputs",            A_CANT, 0L);
    jit_class_addmethod(_jit_mop_class, (method)jit_mop_addoutputs,         "addoutputs",           A_CANT, 0L);
    //add attribute         s
    attrflags = 0;
    attr = jit_object_new(_jit_sym_jit_attr_offset,"inputcount",_jit_sym_long,attrflags,
        (method)0L,(method)0L,calcoffset(t_jit_mop,inputcount));
    jit_class_addattr(_jit_mop_class,attr);
    attr = jit_object_new(_jit_sym_jit_attr_offset,"outputcount",_jit_sym_long,attrflags,
        (method)0L,(method)0L,calcoffset(t_jit_mop,outputcount));
    jit_class_addattr(_jit_mop_class,attr);
    attr = jit_object_new(_jit_sym_jit_attr_offset,"caninplace",_jit_sym_char,attrflags,
        (method)0L,(method)0L,calcoffset(t_jit_mop,caninplace));
    jit_class_addattr(_jit_mop_class,attr);
    attr = jit_object_new(_jit_sym_jit_attr_offset,"adapt",_jit_sym_char,attrflags,
        (method)0L,(method)0L,calcoffset(t_jit_mop,adapt));
    jit_class_addattr(_jit_mop_class,attr);
    attr = jit_object_new(_jit_sym_jit_attr_offset,"outputmode",_jit_sym_char,attrflags,
        (method)0L,(method)0L,calcoffset(t_jit_mop,outputmode));
    jit_class_addattr(_jit_mop_class,attr);
        
    jit_class_register(_jit_mop_class);
    ps_resamp = gensym("resamp");
    ps_adapt = gensym("adapt");
    
    ps_trunc = gensym("trunc");
    ps_trunc_zero = gensym("trunc_zero");
    ps_custom = gensym("custom");
    
    return JIT_ERR_NONE;
}

/**
 * Constructs instance of t_jit_mop_io.
 *
 * @ingroup mopmod
 *
 * @return  t_jit_mop_io object pointer
 *
 * @warning This function is not exported, but is provided 
 *          for reference when calling via jit_object_new.
 */
t_jit_object *jit_mop_io_new(void)
{
    t_jit_mop_io *x;
    long i=0;
    
    if (x = (t_jit_mop_io *)jit_object_alloc(_jit_mop_io_class)) {
        x->special      = NULL;
        x->ioname       = gensym("io");
        x->matrixname   = NULL;
        x->matrix       = NULL;
        x->types[0]     = _jit_sym_char;        
        x->types[1]     = _jit_sym_long;        
        x->types[2]     = _jit_sym_float32;     
        x->types[3]     = _jit_sym_float64;     
        for (i=4;i<JIT_MATRIX_MAX_TYPES;i++) {
            x->types[i] = NULL;     
        }
        for (i=0;i<JIT_MATRIX_MAX_DIMCOUNT;i++) {
            x->mindim[i] = 0;       
            x->maxdim[i] = 0;       
        }
        x->minplanecount    = 1;
        x->maxplanecount    = JIT_MATRIX_MAX_PLANECOUNT;
        x->mindimcount      = 1;
        x->maxdimcount      = JIT_MATRIX_MAX_DIMCOUNT;
        x->typescount       = 4;
        x->typelink         = 1;
        x->dimlink          = 1;
        x->planelink        = 1;
        x->ioproc           = NULL;
    }

    return (t_jit_object *)x;
}

/**
 * Constructs instance of t_jit_mop_io, copying settings of input.
 *
 * @ingroup mopmod
 *
 * @param   x   t_jit_mop_io object pointer
 * @return  t_jit_mop_io object pointer
 *
 * @warning This function is not exported, but is provided 
 *          for reference when calling via jit_object_method
 *          on an intance of t_jit_mop_io.
 */
t_jit_object *jit_mop_io_newcopy(t_jit_mop_io *x)
{
    t_jit_mop_io *y;
    long i=0;
    
    if (y = (t_jit_mop_io *)jit_object_alloc(_jit_mop_io_class)) {
        *y = *x; //should be fine in this instance
    }

    return (t_jit_object *)y;
}

/**
 * Frees instance of t_jit_mop_io.
 *
 * @ingroup mopmod
 *
 * @param   x   t_jit_mop_io object pointer
 * @return  t_jit_err error code
 *
 * @warning Use jit_object_free instead.
 */
t_jit_err jit_mop_io_free(t_jit_mop *x)
{
//nada
    return JIT_ERR_NONE;
}

/**
 * Restricts the type specified in t_jit_matrix_info struct to those permitted by 
 * t_jit_mop_io instance, overwriting value in t_jit_matrix_info struct.
 *
 * @ingroup mopmod
 *
 * @param   x       t_jit_mop_io object pointer
 * @param   info    t_jit_matrix_info pointer
 *
 * @return  t_jit_err error code
 *
 * @warning This function is not exported, but is provided 
 *          for reference when calling via jit_object_method
 *          on an intance of t_jit_mop_io.
 */
t_jit_err jit_mop_io_restrict_type(t_jit_mop_io *x, t_jit_matrix_info *info)
{
    long i;
    
    if (x&&info) {
        for (i=0;i<x->typescount;i++) {
            if (info->type==x->types[i])
                return JIT_ERR_NONE;        
        }
        if (x->matrix)
            info->type = jit_attr_getsym(x->matrix,_jit_sym_type);
        else
            info->type = x->types[0];
    
        return JIT_ERR_GENERIC;
    }
    return JIT_ERR_INVALID_PTR;
}

/**
 * Restricts the planecount specified in t_jit_matrix_info struct to those permitted by 
 * t_jit_mop_io instance, overwriting value in t_jit_matrix_info struct.
 *
 * @ingroup mopmod
 *
 * @param   x       t_jit_mop_io object pointer
 * @param   info    t_jit_matrix_info pointer
 *
 * @return  t_jit_err error code
 *
 * @warning This function is not exported, but is provided 
 *          for reference when calling via jit_object_method
 *          on an intance of t_jit_mop_io.
 */
t_jit_err jit_mop_io_restrict_planecount(t_jit_mop_io *x, t_jit_matrix_info *info)
{
    
    if (x&&info) {
        if ((info->planecount>=x->minplanecount) &&
            (info->planecount<=x->maxplanecount))
        {
            return JIT_ERR_NONE;
        }
        CLIP(info->planecount,x->minplanecount,x->maxplanecount); 
        return JIT_ERR_GENERIC;
    }
    return JIT_ERR_INVALID_PTR;
}

/**
 * Restricts the dimension sizes specified in t_jit_matrix_info struct to those permitted by 
 * t_jit_mop_io instance, overwriting value in t_jit_matrix_info struct.
 *
 * @ingroup mopmod
 *
 * @param   x       t_jit_mop_io object pointer
 * @param   info    t_jit_matrix_info pointer
 *
 * @return  t_jit_err error code
 *
 * @warning This function is not exported, but is provided 
 *          for reference when calling via jit_object_method
 *          on an intance of t_jit_mop_io.
 */
t_jit_err jit_mop_io_restrict_dim(t_jit_mop_io *x, t_jit_matrix_info *info)
{   
    long i;
    t_jit_err err=JIT_ERR_NONE;
    
    if (x&&info) {
        if (x->mindimcount&&(info->dimcount<x->mindimcount)) {      
            for (i=MAX(info->dimcount,0);i<x->mindimcount;i++)
                info->dim[i] = 1;
            info->dimcount = x->mindimcount;
            err=JIT_ERR_GENERIC;
        } else if (x->maxdimcount&&(info->dimcount>x->maxdimcount)) {
            info->dimcount = x->maxdimcount;
            err=JIT_ERR_GENERIC;
        }
        for (i=0;i<JIT_MATRIX_MAX_DIMCOUNT;i++) {
            if (x->mindim[i]&&(info->dim[i]<x->mindim[i])) {
                info->dim[i] = x->mindim[i];
                err=JIT_ERR_GENERIC;
            } else if (x->maxdim[i]&&(info->dim[i]>x->maxdim[i])) {
                info->dim[i] = x->maxdim[i];
                err=JIT_ERR_GENERIC;
            }
        }
        return err;
    }
    return JIT_ERR_INVALID_PTR;
}

t_jit_err jit_mop_io_special(t_jit_mop_io *x, void *special)
{
    x->special = special;
    return JIT_ERR_NONE;
}

void *jit_mop_io_getspecial(t_jit_mop_io *x)
{
    return x->special;
}

/**
 * Sets the internal matrix reference.
 *
 * @ingroup mopmod
 *
 * @param   x       t_jit_mop_io object pointer
 * @param   m       t_jit_matrix object pointer
 *
 * @return  t_jit_err error code
 *
 * @warning This function is not exported, but is provided 
 *          for reference when calling via jit_object_method
 *          on an intance of t_jit_mop_io.
 */
t_jit_err jit_mop_io_matrix(t_jit_mop_io *x, void *m)
{
    x->matrix = m;
    return JIT_ERR_NONE;
}

/**
 * Retrieves the internal matrix reference.
 *
 * @ingroup mopmod
 *
 * @param   x       t_jit_mop_io object pointer
 *
 * @return  t_jit_matrix object pointer
 *
 * @warning This function is not exported, but is provided 
 *          for reference when calling via jit_object_method
 *          on an intance of t_jit_mop_io.
 */
void *jit_mop_io_getmatrix(t_jit_mop_io *x)
{
    return x->matrix;
}

/**
 * Sets the I/O procedure used when handling incoming matrices.
 *
 * @ingroup mopmod
 *
 * @param   x       t_jit_mop_io object pointer
 * @param   ioproc  I/O procedure
 *
 * @return  t_jit_err error code
 *
 * @warning This function is not exported, but is provided 
 *          for reference when calling via jit_object_method
 *          on an intance of t_jit_mop_io.
 */
t_jit_err jit_mop_io_ioproc(t_jit_mop_io *x, method ioproc)
{
    x->ioproc = ioproc;
    return JIT_ERR_NONE;
}

/**
 * Retrieves the I/O procedure used when handling incoming matrices.
 *
 * @ingroup mopmod
 *
 * @param   x       t_jit_mop_io object pointer
 *
 * @return  I/O procedure
 *
 * @warning This function is not exported, but is provided 
 *          for reference when calling via jit_object_method
 *          on an intance of t_jit_mop_io.
 */
method jit_mop_io_getioproc(t_jit_mop_io *x)
{
    return x->ioproc;
}

void *jit_mop_io_decorator(t_jit_mop_io *x, t_symbol *s)
{
    return (x)?x->matrix:NULL;
}

#pragma mark -
// --------------------------------------------------------------------------------
// 

/**
 * Constructs instance of t_jit_mop.
 *
 * @ingroup mopmod
 *
 * @return  t_jit_mop object pointer
 *
 * @warning This function is not exported, but is provided 
 *          for reference when calling via jit_object_new.
 */
t_jit_object *jit_mop_new(long inputcount, long outputcount)
{
    t_jit_mop *x;
    void *o;
    long i;
    char tmpstr[64];
    
    if (x = (t_jit_mop *)jit_object_alloc(_jit_mop_class)) {
        x->special      = NULL;
        x->inputcount   = inputcount;
        x->outputcount  = outputcount;
        x->inputlist    = jit_object_new(gensym("jit_linklist"));   
        x->outputlist   = jit_object_new(gensym("jit_linklist"));   
        x->caninplace   = 1;
        x->adapt        = 1;
        x->outputmode   = 1;
        if ((!x->inputlist)||(!x->outputlist)) {
            jit_object_free(x);
            x=NULL;
            goto out;
        }
        i=1;
        while (inputcount-- > 0) {
            if (o = jit_object_new(gensym("jit_mop_io"))) {
                jit_object_method(x->inputlist,_jit_sym_append,o);  
                if (i==1) { sprintf(tmpstr,"in"); i++; }
                else { sprintf(tmpstr,"in%d",i++); }
                jit_attr_setsym(o,gensym("ioname"),gensym(tmpstr)); 
            } else {
                jit_object_free(x);
                x=NULL;
                goto out;                   
            }
        }
        i=1;
        while (outputcount-- > 0) {
            if (o = jit_object_new(gensym("jit_mop_io"))) {
                jit_object_method(x->outputlist,_jit_sym_append,o); 
                if (i==1) { sprintf(tmpstr,"out"); i++; }
                else { sprintf(tmpstr,"out%d",i++); }
                jit_attr_setsym(o,gensym("ioname"),gensym(tmpstr)); 
            } else {
                jit_object_free(x);
                x=NULL;
                goto out;                   
            }
        }
    }
out:    
    return (t_jit_object *)x;
}

/**
 * Constructs instance of t_jit_mop, copying settings of input.
 *
 * @ingroup mopmod
 *
 * @param   x   t_jit_mop object pointer
 * @return  t_jit_mop object pointer
 *
 * @warning This function is not exported, but is provided 
 *          for reference when calling via jit_object_method
 *          on an intance of t_jit_mop.
 */
t_jit_object *jit_mop_newcopy(t_jit_mop *x)
{
    t_jit_mop *y;
    void *o,*p;
    long inputcount,outputcount;
    long i=0;
    
    if (y = (t_jit_mop *)jit_object_alloc(_jit_mop_class)) {
        *y = *x;
        y->inputlist    = jit_object_new(gensym("jit_linklist"));   
        y->outputlist   = jit_object_new(gensym("jit_linklist"));   
        inputcount  = x->inputcount;
        outputcount = x->outputcount;
        i=1;
        while (inputcount-- > 0) {
            if (o=jit_object_method(x->inputlist,_jit_sym_getindex,i-1)) {
                p = jit_object_method(o,_jit_sym_newcopy);  
                jit_object_method(y->inputlist,_jit_sym_append,p);  
            } else {
                jit_object_free(y);
                y=NULL;
                goto out;                   
            }
            i++;
        }
        i=1;
        while (outputcount-- > 0) {
            if (o=jit_object_method(x->outputlist,_jit_sym_getindex,i-1)) {
                p = jit_object_method(o,_jit_sym_newcopy);  
                jit_object_method(y->outputlist,_jit_sym_append,p); 
            } else {
                jit_object_free(y);
                y=NULL;
                goto out;                   
            }
            i++;
        }
    }
out:    
    return (t_jit_object *)y;
}


/**
 * Retrieves input at input list index specified.
 *
 * @ingroup mopmod
 *
 * @param   x       t_jit_mop object pointer
 * @param   i       index
 *
 * @return  t_jit_mop_io object pointer
 *
 * @warning This function is not exported, but is provided 
 *          for reference when calling via jit_object_method
 *          on an intance of t_jit_mop.
 */
void *jit_mop_getinput(t_jit_mop *x, long i)
{
    if (x&&x->inputlist&&i>=1)
        return jit_object_method(x->inputlist,_jit_sym_getindex,i-1);
    else 
        return NULL;
}

/**
 * Retrieves output at output list index specified.
 *
 * @ingroup mopmod
 *
 * @param   x       t_jit_mop object pointer
 * @param   i       index
 *
 * @return  t_jit_mop_io object pointer
 *
 * @warning This function is not exported, but is provided 
 *          for reference when calling via jit_object_method
 *          on an intance of t_jit_mop.
 */
void *jit_mop_getoutput(t_jit_mop *x, long i)
{
    if (x&&x->outputlist&&i>=1)
        return jit_object_method(x->outputlist,_jit_sym_getindex,i-1);
    else 
        return NULL;
}

/**
 * Retrieves input list.
 *
 * @ingroup mopmod
 *
 * @param   x       t_jit_mop object pointer
 *
 * @return  t_jit_linklist object pointer
 *
 * @warning This function is not exported, but is provided 
 *          for reference when calling via jit_object_method
 *          on an intance of t_jit_mop.
 */
void *jit_mop_getinputlist(t_jit_mop *x)
{
    if (x)
        return x->inputlist;
    else 
        return NULL;
}

/**
 * Retrieves output list.
 *
 * @ingroup mopmod
 *
 * @param   x       t_jit_mop object pointer
 *
 * @return  t_jit_linklist object pointer
 *
 * @warning This function is not exported, but is provided 
 *          for reference when calling via jit_object_method
 *          on an intance of t_jit_mop.
 */
void *jit_mop_getoutputlist(t_jit_mop *x)
{
    if (x)
        return x->outputlist;
    else 
        return NULL;
}


/**
 * Frees instance of t_jit_mop.
 *
 * @ingroup mopmod
 *
 * @param   x   t_jit_mop object pointer
 * @return  t_jit_err error code
 *
 * @warning Use jit_object_free instead.
 */
t_jit_err jit_mop_free(t_jit_mop *x)
{
    if (x->inputlist) jit_object_free(x->inputlist);    
    if (x->outputlist) jit_object_free(x->outputlist);
    return JIT_ERR_NONE;
}

t_jit_err jit_mop_special(t_jit_mop *x, void *special)
{
    x->special = special;
    return JIT_ERR_NONE;
}

void *jit_mop_getspecial(t_jit_mop *x)
{
    return x->special;
}

t_jit_err jit_mop_matrix_calc(t_jit_mop *x, void *o)
{
    return (t_jit_err) jit_object_method(o,_jit_sym_matrix_calc,x->inputlist,x->outputlist);
}

t_jit_err jit_mop_addinputs(t_jit_mop *x, long c) 
{
    long i;
    void *o;
    char tmpstr[256];

    if (x&&x->inputlist) {
        if (x->inputcount<0) {
            x->inputcount = c;
            i = 1;
        } else {
            x->inputcount += c;
            i = x->inputcount+1;
        }
        while (c-- > 0) {
            if (o = jit_object_new(gensym("jit_mop_io"))) {
                jit_object_method(x->inputlist,_jit_sym_append,o);  
                if (i==1) { sprintf(tmpstr,"in"); i++; }
                else { sprintf(tmpstr,"in%d",i++); }
                jit_attr_setsym(o,gensym("ioname"),gensym(tmpstr)); 
            } else {
                return JIT_ERR_OUT_OF_MEM;
            }
        }
    }
    return JIT_ERR_NONE;
}

t_jit_err jit_mop_addoutputs(t_jit_mop *x, long c) 
{
    long i;
    void *o;
    char tmpstr[256];

    if (x&&x->outputlist) {
        if (x->outputcount<0) {
            x->outputcount = c;
            i = 1;
        } else {
            x->outputcount += c;
            i = x->outputcount+1;
        }
        while (c-- > 0) {
            if (o = jit_object_new(gensym("jit_mop_io"))) {
                jit_object_method(x->outputlist,_jit_sym_append,o); 
                if (i==1) { sprintf(tmpstr,"out"); i++; }
                else { sprintf(tmpstr,"out%d",i++); }
                jit_attr_setsym(o,gensym("ioname"),gensym(tmpstr)); 
            } else {
                return JIT_ERR_OUT_OF_MEM;
            }
        }
    }
    return JIT_ERR_NONE;
}

#pragma mark -
// --------------------------------------------------------------------------------
// utils

/**
 * Utility function to set the type attribute for all MOP inputs and outputs.
 *
 * @ingroup mopmod
 *
 * @param   mop     t_jit_mop object pointer
 * @param   s       type symbol
 * 
 * @return  t_jit_err error code
 *
 */
t_jit_err jit_mop_single_type(void *mop, t_symbol *s)
{
    void *o;
    long i;
    t_atom a;
    t_jit_mop *x=mop;
    
    if (x&&s) {
        jit_atom_setsym(&a,s);
        for (i=1;i<=x->inputcount;i++) {
            if (o=jit_object_method(x->inputlist,_jit_sym_getindex,i-1)) {
                jit_object_method(o,gensym("types"),1,&a);
            } 
        }
        for (i=1;i<=x->outputcount;i++) {
            if (o=jit_object_method(x->outputlist,_jit_sym_getindex,i-1)) {
                jit_object_method(o,gensym("types"),1,&a);
            } 
        }
    }
    return JIT_ERR_NONE;
}   
    
/**
 * Utility function to set the planecount attribute for all MOP inputs and outputs.
 *
 * @ingroup mopmod
 *
 * @param   mop     t_jit_mop object pointer
 * @param   c       planecount
 * 
 * @return  t_jit_err error code
 *
 */
t_jit_err jit_mop_single_planecount(void *mop, long c)
{
    void *o;
    long i;
    t_jit_mop *x=mop;
    
    if (x) {
        for (i=1;i<=x->inputcount;i++) {
            if (o=jit_object_method(x->inputlist,_jit_sym_getindex,i-1)) {
                jit_attr_setlong(o,gensym("minplanecount"),c);
                jit_attr_setlong(o,gensym("maxplanecount"),c);
            } 
        }
        for (i=1;i<=x->outputcount;i++) {
            if (o=jit_object_method(x->outputlist,_jit_sym_getindex,i-1)) {
                jit_attr_setlong(o,gensym("minplanecount"),c);
                jit_attr_setlong(o,gensym("maxplanecount"),c);
            } 
        }
    }
    return JIT_ERR_NONE;
}   

/**
 * Utility function to send the same method to all MOP inputs and outputs.
 *
 * @ingroup mopmod
 *
 * @param   mop     t_jit_mop object pointer
 * @param   s       method symbol
 * @param   ...     untyped arguments
 * 
 * @return  t_jit_err error code
 *
 */
t_jit_err jit_mop_methodall(void *mop, t_symbol *s, ...)
{
    void *o;
    long i;
    t_jit_mop *x=mop;
    
    if (x) {
        for (i=1;i<=x->inputcount;i++) {
            if (o=jit_object_method(x->inputlist,_jit_sym_getindex,i-1)) {
                jit_object_method(o,s,*((t_stack_splat *)(((char *)(&s))+4)));
            } 
        }
        for (i=1;i<=x->outputcount;i++) {
            if (o=jit_object_method(x->outputlist,_jit_sym_getindex,i-1)) {
                jit_object_method(o,s,*((t_stack_splat *)(((char *)(&s))+4)));
            } 
        }
    }
    return JIT_ERR_NONE;
}

/**
 * Utility function to disable all linking attributes for a MOP input.
 *
 * @ingroup mopmod
 *
 * @param   mop     t_jit_mop object pointer
 * @param   c       input index
 * 
 * @return  t_jit_err error code
 *
 */
t_jit_err jit_mop_input_nolink(void *mop, long c)
{
    void *o;
    t_jit_mop *x=mop;
    
    if (x) {
        if (o=jit_object_method(x->inputlist,_jit_sym_getindex,c-1)) {
            jit_attr_setlong(o,gensym("typelink"),0);
            jit_attr_setlong(o,gensym("planelink"),0);
            jit_attr_setlong(o,gensym("dimlink"),0);
        }   
    }
    return JIT_ERR_NONE;
}   

/**
 * Utility function to disable all linking attributes for a MOP output.
 *
 * @ingroup mopmod
 *
 * @param   mop     t_jit_mop object pointer
 * @param   c       output index
 * 
 * @return  t_jit_err error code
 *
 */
t_jit_err jit_mop_output_nolink(void *mop, long c)
{
    void *o;
    t_jit_mop *x=mop;
    
    if (x) {
        if (o=jit_object_method(x->outputlist,_jit_sym_getindex,c-1)) {
            jit_attr_setlong(o,gensym("typelink"),0);
            jit_attr_setlong(o,gensym("planelink"),0);
            jit_attr_setlong(o,gensym("dimlink"),0);
        }   
    }
    return JIT_ERR_NONE;
}   

/**
 * MOP I/O procedure to copy and adapt to input.
 *
 * @ingroup mopmod
 *
 * @param   mop     t_jit_mop object pointer
 * @param   mop_io  t_jit_mop_io object pointer
 * @param   matrix  t_jit_matrix object pointer
 * 
 * @return  t_jit_err error code
 *
 * @code
    void *m;
    t_jit_matrix_info info;
    
    if (matrix&&(m=jit_object_method(mop_io,_jit_sym_getmatrix))) {
        jit_object_method(matrix,_jit_sym_getinfo,&info);
        jit_object_method(mop_io,_jit_sym_restrict_type,&info);
        jit_object_method(mop_io,_jit_sym_restrict_dim,&info);
        jit_object_method(mop_io,_jit_sym_restrict_planecount,&info);
        jit_object_method(m,_jit_sym_setinfo,&info);
        jit_object_method(m,_jit_sym_frommatrix,matrix,NULL);
    }

    return JIT_ERR_NONE;
 * @endcode
 *
 */
t_jit_err jit_mop_ioproc_copy_adapt(void *mop, void *mop_io, void *matrix)
{
    void *m;
    t_jit_matrix_info info;
    
    if (matrix&&(m=jit_object_method(mop_io,_jit_sym_getmatrix))) {
        jit_object_method(matrix,_jit_sym_getinfo,&info);
        jit_object_method(mop_io,_jit_sym_restrict_type,&info);
        jit_object_method(mop_io,_jit_sym_restrict_dim,&info);
        jit_object_method(mop_io,_jit_sym_restrict_planecount,&info);
        jit_object_method(m,_jit_sym_setinfo,&info);
        jit_object_method(m,_jit_sym_frommatrix,matrix,NULL);
    }

    return JIT_ERR_NONE;
}

/**
 * MOP I/O procedure to copy, but truncate input.
 *
 * @ingroup mopmod
 *
 * @param   mop     t_jit_mop object pointer
 * @param   mop_io  t_jit_mop_io object pointer
 * @param   matrix  t_jit_matrix object pointer
 * 
 * @return  t_jit_err error code
 *
 * @code
    void *m;
    t_jit_matrix_info info;
    
    if (matrix&&(m=jit_object_method(mop_io,_jit_sym_getmatrix))) {
        jit_object_method(m,_jit_sym_frommatrix_trunc,matrix);
    }

    return JIT_ERR_NONE;
 * @endcode
 *
 */
t_jit_err jit_mop_ioproc_copy_trunc(void *mop, void *mop_io, void *matrix)
{
    void *m;
    
    if (matrix&&(m=jit_object_method(mop_io,_jit_sym_getmatrix))) {
        jit_object_method(m,_jit_sym_frommatrix_trunc,matrix);
    }

    return JIT_ERR_NONE;
}

/**
 * MOP I/O procedure to copy, but truncate input. Zero elsewhere.
 *
 * @ingroup mopmod
 *
 * @param   mop     t_jit_mop object pointer
 * @param   mop_io  t_jit_mop_io object pointer
 * @param   matrix  t_jit_matrix object pointer
 * 
 * @return  t_jit_err error code
 *
 * @code
    void *m;
    t_jit_matrix_info info;
    
    if (matrix&&(m=jit_object_method(mop_io,_jit_sym_getmatrix))) {
        jit_object_method(m,_jit_sym_clear);
        jit_object_method(m,_jit_sym_frommatrix_trunc,matrix);
    }

    return JIT_ERR_NONE;
 * @endcode
 *
 */
t_jit_err jit_mop_ioproc_copy_trunc_zero(void *mop, void *mop_io, void *matrix)
{
    void *m;
    
    if (matrix&&(m=jit_object_method(mop_io,_jit_sym_getmatrix))) {
        //could be faster without the full clear
        jit_object_method(m,_jit_sym_clear);
        jit_object_method(m,_jit_sym_frommatrix_trunc,matrix);
    }

    return JIT_ERR_NONE;
}


/**
 * Utility to convert MOP I/O procedure function to a human-readable type name.
 *
 * @ingroup mopmod
 *
 * @param   ioproc  t_jit_mop_io procedure pointer
 * 
 * @return  t_symbol pointer
 *
 * @code
 if (ioproc==NULL) {
 return ps_resamp;
 } else if (ioproc==jit_mop_ioproc_copy_adapt) {
 return ps_adapt;   
 } else if (ioproc==jit_mop_ioproc_copy_trunc) {
 return ps_trunc;   
 } else if (ioproc==jit_mop_ioproc_copy_trunc_zero) {
 return ps_trunc_zero;  
 } else {
 return ps_custom;  
 }
 return ps_resamp;
 * @endcode
 *
 */
t_symbol *jit_mop_ioproc_tosym(void *ioproc)
{
    if (ioproc==NULL) {
        return ps_resamp;
    } else if (ioproc==jit_mop_ioproc_copy_adapt) {
        return ps_adapt;    
    } else if (ioproc==jit_mop_ioproc_copy_trunc) {
        return ps_trunc;    
    } else if (ioproc==jit_mop_ioproc_copy_trunc_zero) {
        return ps_trunc_zero;   
    } else {
        return ps_custom;   
    }
    return ps_resamp;
}

Copyright © 2008, Cycling '74