Max 5 API Reference

jit.attribute.util.c

/* 
    jit.attribute.util.c

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

#include "jit.common.h"
#include "ext_obex.h"

/**
 *  @defgroup attrmod Attribute Module
    @ingroup jitter
 */


// need to use the old functions for the time being as the 
// kernel attr functions will not handle decorator objects
// properly, as in the instance of jit_mop_io
long jit_attr_getlong_old(void *x, t_symbol *s);
t_jit_err jit_attr_setlong_old(void *x, t_symbol *s, long c);
float jit_attr_getfloat_old(void *x, t_symbol *s);
t_jit_err jit_attr_setfloat_old(void *x, t_symbol *s, float c);
t_symbol *jit_attr_getsym_old(void *x, t_symbol *s);
t_jit_err jit_attr_setsym_old(void *x, t_symbol *s, t_symbol *c);
//------------
long jit_attr_getlong_array_old(void *x, t_symbol *s, long max, long *vals);
t_jit_err jit_attr_setlong_array_old(void *x, t_symbol *s, long count, long *vals);
long jit_attr_getchar_array_old(void *x, t_symbol *s, long max, uchar *vals);
t_jit_err jit_attr_setchar_array_old(void *x, t_symbol *s, long count, uchar *vals);
long jit_attr_getfloat_array_old(void *x, t_symbol *s, long max, float *vals);
t_jit_err jit_attr_setfloat_array_old(void *x, t_symbol *s, long count, float *vals);
long jit_attr_getdouble_array_old(void *x, t_symbol *s, long max, double *vals);
t_jit_err jit_attr_setdouble_array_old(void *x, t_symbol *s, long count, double *vals);
long jit_attr_getsym_array_old(void *x, t_symbol *s, long max, t_symbol **vals);
t_jit_err jit_attr_setsym_array_old(void *x, t_symbol *s, long count, t_symbol **vals);

/**
 * Retrieves attribute value as a long integer value.
 *
 * @ingroup attrmod 
 *
 * @param   x   object pointer
 * @param   s   attribute name
 * 
 * @return  long integer value
 *
 */
long jit_attr_getlong(void *x, t_symbol *s)
{
    if (object_attr_get(x,s))
        return object_attr_getlong(x,s);
    else
        return jit_attr_getlong_old(x,s);
}

/**
 * Sets attribute value as a long integer value.
 *
 * @ingroup attrmod 
 *
 * @param   x   object pointer
 * @param   s   attribute name
 * @param   c   value
 * 
 * @return  t_jit_err error code.
 *
 */
t_jit_err jit_attr_setlong(void *x, t_symbol *s, long c)
{
    if (object_attr_get(x,s))
        return jit_err_from_max_err(object_attr_setlong(x,s,c));
    else
        return jit_attr_setlong_old(x,s,c);
}

/**
 * Retrieves attribute value as a floating point value.
 *
 * @ingroup attrmod 
 *
 * @param   x   object pointer
 * @param   s   attribute name
 * 
 * @return  floating point value
 *
 */
float jit_attr_getfloat(void *x, t_symbol *s)
{
    if (object_attr_get(x,s))
        return object_attr_getfloat(x,s);
    else
        return jit_attr_getfloat_old(x,s);
}

/**
 * Sets attribute value as a floating point value.
 *
 * @ingroup attrmod 
 *
 * @param   x   object pointer
 * @param   s   attribute name
 * @param   c   value
 * 
 * @return  t_jit_err error code.
 *
 */
t_jit_err jit_attr_setfloat(void *x, t_symbol *s, float c)
{
    if (object_attr_get(x,s))
        return jit_err_from_max_err(object_attr_setfloat(x,s,c));
    else
        return jit_attr_setfloat_old(x,s,c);
}

/**
 * Retrieves attribute value as a symbol value.
 *
 * @ingroup attrmod 
 *
 * @param   x   object pointer
 * @param   s   attribute name
 * 
 * @return  symbol value
 *
 */
t_symbol *jit_attr_getsym(void *x, t_symbol *s)
{
    if (object_attr_get(x,s))
        return object_attr_getsym(x,s);
    else
        return jit_attr_getsym_old(x,s);
}

/**
 * Sets attribute value as a symbol value.
 *
 * @ingroup attrmod 
 *
 * @param   x   object pointer
 * @param   s   attribute name
 * @param   c   value
 * 
 * @return  t_jit_err error code.
 *
 */
t_jit_err jit_attr_setsym(void *x, t_symbol *s, t_symbol *c)
{
    if (object_attr_get(x,s))
        return jit_err_from_max_err(object_attr_setsym(x,s,c));
    else
        return jit_attr_setsym_old(x,s,c);
}

//------------

/**
 * Retrieves attribute value as an array of long integer values.
 *
 * @ingroup attrmod 
 *
 * @param   x       object pointer
 * @param   s       attribute name
 * @param   max     maximum number of values to copy
 * @param   vals    pointer to retrieved values
 * 
 * @return  number of values retrieved.
 *
 */
long jit_attr_getlong_array(void *x, t_symbol *s, long max, long *vals)
{
    if (object_attr_get(x,s))
        return object_attr_getlong_array(x,s,max,vals);
    else    
        return jit_attr_getlong_array_old(x,s,max,vals);
}

/**
 * Sets attribute value as an array of long integer values.
 *
 * @ingroup attrmod 
 *
 * @param   x       object pointer
 * @param   s       attribute name
 * @param   count   number of values
 * @param   vals    pointer to values
 * 
 * @return  t_jit_err error code.
 *
 */
t_jit_err jit_attr_setlong_array(void *x, t_symbol *s, long count, long *vals)
{
    if (object_attr_get(x,s))
        return jit_err_from_max_err(object_attr_setlong_array(x,s,count,vals));
    else
        return jit_attr_setlong_array_old(x,s,count,vals);
}

/**
 * Retrieves attribute value as an array of char values.
 *
 * @ingroup attrmod 
 *
 * @param   x       object pointer
 * @param   s       attribute name
 * @param   max     maximum number of values to copy
 * @param   vals    pointer to retrieved values
 * 
 * @return  number of values retrieved.
 *
 */
long jit_attr_getchar_array(void *x, t_symbol *s, long max, uchar *vals)
{
    if (object_attr_get(x,s))
        return object_attr_getchar_array(x,s,max,vals);
    else    
        return jit_attr_getchar_array_old(x,s,max,vals);
}

/**
 * Sets attribute value as an array of char values.
 *
 * @ingroup attrmod 
 *
 * @param   x       object pointer
 * @param   s       attribute name
 * @param   count   number of values
 * @param   vals    pointer to values
 * 
 * @return  t_jit_err error code.
 *
 */
t_jit_err jit_attr_setchar_array(void *x, t_symbol *s, long count, uchar *vals)
{
    if (object_attr_get(x,s))
        return jit_err_from_max_err(object_attr_setchar_array(x,s,count,vals));
    else
        return jit_attr_setchar_array_old(x,s,count,vals);
}

/**
 * Retrieves attribute value as an array of floating point values.
 *
 * @ingroup attrmod 
 *
 * @param   x       object pointer
 * @param   s       attribute name
 * @param   max     maximum number of values to copy
 * @param   vals    pointer to retrieved values
 * 
 * @return  number of values retrieved.
 *
 */
long jit_attr_getfloat_array(void *x, t_symbol *s, long max, float *vals)
{
    if (object_attr_get(x,s))
        return object_attr_getfloat_array(x,s,max,vals);
    else    
        return jit_attr_getfloat_array_old(x,s,max,vals);
}

/**
 * Sets attribute value as an array of floating point values.
 *
 * @ingroup attrmod 
 *
 * @param   x       object pointer
 * @param   s       attribute name
 * @param   count   number of values
 * @param   vals    pointer to values
 * 
 * @return  t_jit_err error code.
 *
 */
t_jit_err jit_attr_setfloat_array(void *x, t_symbol *s, long count, float *vals)
{
    if (object_attr_get(x,s))
        return jit_err_from_max_err(object_attr_setfloat_array(x,s,count,vals));
    else
        return jit_attr_setfloat_array_old(x,s,count,vals);
}

/**
 * Retrieves attribute value as an array of double precision floating point values.
 *
 * @ingroup attrmod 
 *
 * @param   x       object pointer
 * @param   s       attribute name
 * @param   max     maximum number of values to copy
 * @param   vals    pointer to retrieved values
 * 
 * @return  number of values retrieved.
 *
 */
long jit_attr_getdouble_array(void *x, t_symbol *s, long max, double *vals)
{
    if (object_attr_get(x,s))
        return object_attr_getdouble_array(x,s,max,vals);
    else    
        return jit_attr_getdouble_array_old(x,s,max,vals);
}

/**
 * Sets attribute value as an array of double precision floating point values.
 *
 * @ingroup attrmod 
 *
 * @param   x       object pointer
 * @param   s       attribute name
 * @param   count   number of values
 * @param   vals    pointer to values
 * 
 * @return  t_jit_err error code.
 *
 */
t_jit_err jit_attr_setdouble_array(void *x, t_symbol *s, long count, double *vals)
{
    if (object_attr_get(x,s))
        return jit_err_from_max_err(object_attr_setdouble_array(x,s,count,vals));
    else
        return jit_attr_setdouble_array_old(x,s,count,vals);
}

/**
 * Retrieves attribute value as an array of symbol values.
 *
 * @ingroup attrmod 
 *
 * @param   x       object pointer
 * @param   s       attribute name
 * @param   max     maximum number of values to copy
 * @param   vals    pointer to retrieved values
 * 
 * @return  number of values retrieved.
 *
 */
long jit_attr_getsym_array(void *x, t_symbol *s, long max, t_symbol **vals)
{
    if (object_attr_get(x,s))
        return object_attr_getsym_array(x,s,max,vals);
    else    
        return jit_attr_getsym_array_old(x,s,max,vals);
}

/**
 * Sets attribute value as an array of symbol values.
 *
 * @ingroup attrmod 
 *
 * @param   x       object pointer
 * @param   s       attribute name
 * @param   count   number of values
 * @param   vals    pointer to values
 * 
 * @return  t_jit_err error code.
 *
 */
t_jit_err jit_attr_setsym_array(void *x, t_symbol *s, long count, t_symbol **vals)
{
    if (object_attr_get(x,s))
        return jit_err_from_max_err(object_attr_setsym_array(x,s,count,vals));
    else
        return jit_attr_setsym_array_old(x,s,count,vals);
}

//-----------------------------------------------

long jit_attr_getlong_old(void *x, t_symbol *s)
{
    long        ac=0;
    t_atom      *av=NULL;
    char        str[256];
    long        rv=0;
    
    if (x&&s) {
        sprintf(str,"get%s",s->s_name);
        
        if ((((t_jit_err)jit_object_method(x,gensym(str),&ac,&av))==JIT_ERR_NONE)&&av) {
            if (ac&&av) {
                rv = jit_atom_getlong(av);
                jit_freebytes(av,sizeof(t_atom)*ac);
            }
        }       
    }
    return rv;
}

t_jit_err jit_attr_setlong_old(void *x, t_symbol *s, long c)
{
    long        ac=1;
    t_atom      av[1];
    t_jit_err   rv=JIT_ERR_GENERIC;
    
    if (x&&s) {     
        jit_atom_setlong(av,c);
        rv = (t_jit_err)jit_object_method(x,s,ac,av);
    }
    return rv;
}

float jit_attr_getfloat_old(void *x, t_symbol *s)
{
    long        ac=0;
    t_atom      *av=NULL;
    char        str[256];
    float       rv=0;
    
    if (x&&s) {
        sprintf(str,"get%s",s->s_name);
        
        if ((((t_jit_err)jit_object_method(x,gensym(str),&ac,&av))==JIT_ERR_NONE)&&av) {
            if (ac&&av) {
                rv = jit_atom_getfloat(av);
                jit_freebytes(av,sizeof(t_atom)*ac);
            }
        }       
    }
    return rv;
}

t_jit_err jit_attr_setfloat_old(void *x, t_symbol *s, float c)
{
    long        ac=1;
    t_atom      av[1];
    t_jit_err   rv=JIT_ERR_GENERIC;
    
    if (x&&s) {     
        jit_atom_setfloat(av,c);
        rv = (t_jit_err)jit_object_method(x,s,ac,av);
    }
    return rv;
}

t_symbol *jit_attr_getsym_old(void *x, t_symbol *s)
{
    long        ac=0;
    t_atom      *av=NULL;
    char        str[256];
    t_symbol    *rv=NULL;
    
    if (x&&s) {
        sprintf(str,"get%s",s->s_name);
        
        if ((((t_jit_err)jit_object_method(x,gensym(str),&ac,&av))==JIT_ERR_NONE)&&av) {
            if (ac&&av) {
                rv = jit_atom_getsym(av);
                jit_freebytes(av,sizeof(t_atom)*ac);
            }
        }       
    }
    return rv;
}

t_jit_err jit_attr_setsym_old(void *x, t_symbol *s, t_symbol *c)
{
    long        ac=1;
    t_atom      av[1];
    t_jit_err   rv=JIT_ERR_GENERIC;
    
    if (x&&s) {     
        jit_atom_setsym(av,c);
        rv = (t_jit_err)jit_object_method(x,s,ac,av);
    }
    return rv;
}
//------------
long jit_attr_getlong_array_old(void *x, t_symbol *s, long max, long *vals)
{
    long        i,ac=0;
    t_atom      *av=NULL;
    char        str[256];
    
    if (x&&s&&vals) {
        sprintf(str,"get%s",s->s_name);
        
        if ((((t_jit_err)jit_object_method(x,gensym(str),&ac,&av))==JIT_ERR_NONE)&&av) {
            if (ac&&av) {
                max = MIN(max,ac);
                for (i=0;i<max;i++) {
                    vals[i]=jit_atom_getlong(av+i);
                }
                jit_freebytes(av,sizeof(t_atom)*ac);
            }
        }       
    }
    return ac;
}

t_jit_err jit_attr_setlong_array_old(void *x, t_symbol *s, long count, long *vals)
{
    t_atom      av[256];
    t_jit_err   rv=JIT_ERR_GENERIC;
    long        i;
    
    if (x&&s&&vals) {
        for (i=0;i<count;i++)
            jit_atom_setlong(av+i,vals[i]);
        rv = (t_jit_err)jit_object_method(x,s,count,av);
    }
    return rv;
}

long jit_attr_getchar_array_old(void *x, t_symbol *s, long max, uchar *vals)
{
    long        i,ac=0;
    t_atom      *av=NULL;
    char        str[256];
    
    if (x&&s&&vals) {
        sprintf(str,"get%s",s->s_name);
        
        if ((((t_jit_err)jit_object_method(x,gensym(str),&ac,&av))==JIT_ERR_NONE)&&av) {
            if (ac&&av) {
                max = MIN(max,ac);
                for (i=0;i<max;i++) {
                    vals[i]=jit_atom_getlong(av+i);
                }
                jit_freebytes(av,sizeof(t_atom)*ac);
            }
        }       
    }
    return ac;
}

t_jit_err jit_attr_setchar_array_old(void *x, t_symbol *s, long count, uchar *vals)
{
    t_atom      av[256];
    t_jit_err   rv=JIT_ERR_GENERIC;
    long        i;
    
    if (x&&s&&vals) {
        for (i=0;i<count;i++)
            jit_atom_setlong(av+i,vals[i]);
        rv = (t_jit_err)jit_object_method(x,s,count,av);
    }
    return rv;
}

long jit_attr_getfloat_array_old(void *x, t_symbol *s, long max, float *vals)
{
    long        i,ac=0;
    t_atom      *av=NULL;
    char        str[256];
    
    if (x&&s&&vals) {
        sprintf(str,"get%s",s->s_name);
        
        if ((((t_jit_err)jit_object_method(x,gensym(str),&ac,&av))==JIT_ERR_NONE)&&av) {
            if (ac&&av) {
                max = MIN(max,ac);
                for (i=0;i<max;i++) {
                    vals[i]=jit_atom_getfloat(av+i);
                }
                jit_freebytes(av,sizeof(t_atom)*ac);
            }
        }       
    }
    return ac;
}

t_jit_err jit_attr_setfloat_array_old(void *x, t_symbol *s, long count, float *vals)
{
    t_atom      av[256];
    t_jit_err   rv=JIT_ERR_GENERIC;
    long        i;
    
    if (x&&s&&vals) {
        for (i=0;i<count;i++)
            jit_atom_setfloat(av+i,vals[i]);
        rv = (t_jit_err)jit_object_method(x,s,count,av);
    }
    return rv;
}

long jit_attr_getdouble_array_old(void *x, t_symbol *s, long max, double *vals)
{
    long        i,ac=0;
    t_atom      *av=NULL;
    char        str[256];
    
    if (x&&s&&vals) {
        sprintf(str,"get%s",s->s_name);
        
        if ((((t_jit_err)jit_object_method(x,gensym(str),&ac,&av))==JIT_ERR_NONE)&&av) {
            if (ac&&av) {
                max = MIN(max,ac);
                for (i=0;i<max;i++) {
                    vals[i]=jit_atom_getfloat(av+i);
                }
                jit_freebytes(av,sizeof(t_atom)*ac);
            }
        }
    }
    return ac;
}

t_jit_err jit_attr_setdouble_array_old(void *x, t_symbol *s, long count, double *vals)
{
    t_atom      av[256];
    t_jit_err   rv=JIT_ERR_GENERIC;
    long        i;
    
    if (x&&s&&vals) {
        for (i=0;i<count;i++)
            jit_atom_setfloat(av+i,vals[i]);
        rv = (t_jit_err)jit_object_method(x,s,count,av);
    }
    return rv;
}

long jit_attr_getsym_array_old(void *x, t_symbol *s, long max, t_symbol **vals)
{
    long        i,ac=0;
    t_atom      *av=NULL;
    char        str[256];
    
    if (x&&s&&vals) {
        sprintf(str,"get%s",s->s_name);
        
        if ((((t_jit_err)jit_object_method(x,gensym(str),&ac,&av))==JIT_ERR_NONE)&&av) {
            if (ac&&av) {
                max = MIN(max,ac);
                for (i=0;i<max;i++) {
                    vals[i]=jit_atom_getsym(av+i);
                }
                jit_freebytes(av,sizeof(t_atom)*ac);
            }
        }       
    }
    return ac;
}

t_jit_err jit_attr_setsym_array_old(void *x, t_symbol *s, long count, t_symbol **vals)
{
    t_atom      av[256];
    t_jit_err   rv=JIT_ERR_GENERIC;
    long        i;
    
    if (x&&s&&vals) {
        for (i=0;i<count;i++)
            jit_atom_setsym(av+i,vals[i]);
        rv = (t_jit_err)jit_object_method(x,s,count,av);
    }
    return rv;
}





t_jit_err jit_attr_addfilterset_clip(void *x, double min, double max, long usemin, long usemax)
{
    void *o;

    if (x&&(o=jit_object_new(gensym("jit_attr_filter_clip")))) {
        jit_attr_setsym(o,_jit_sym_type,jit_object_method(x,gensym("gettype")));
        jit_attr_setfloat(o,gensym("min"),min);
        jit_attr_setfloat(o,gensym("max"),max);
        jit_attr_setlong(o,gensym("usemin"),usemin);
        jit_attr_setlong(o,gensym("usemax"),usemax);
        jit_object_method(x,gensym("filterset"),o);
        return JIT_ERR_NONE;
    }
    return JIT_ERR_GENERIC;
}

t_jit_err jit_attr_addfilterset_clip_scale(void *x, double scale, double min, double max, long usemin, long usemax)
{
    void *o;

    if (x&&(o=jit_object_new(gensym("jit_attr_filter_clip")))) {
        jit_attr_setsym(o,_jit_sym_type,jit_object_method(x,gensym("gettype")));
        jit_attr_setfloat(o,gensym("scale"),scale);
        jit_attr_setfloat(o,gensym("min"),min);
        jit_attr_setfloat(o,gensym("max"),max);
        jit_attr_setlong(o,gensym("usemin"),usemin);
        jit_attr_setlong(o,gensym("usemax"),usemax);
        jit_attr_setlong(o,gensym("usescale"),1);
        jit_object_method(x,gensym("filterset"),o);
        return JIT_ERR_NONE;
    }
    return JIT_ERR_GENERIC;
}
/*
t_jit_err jit_attr_addfilterset_enum(void *x, long argc, t_atom argv)
{
    void *o;
    long i;

    if (x&&(o=jit_object_new(gensym("jit_attr_filter_enum"),argc,argv))) {
        jit_attr_setsym(o,_jit_sym_type,jit_object_method(x,gensym("gettype")));
        jit_object_method(x,gensym("filterset"),o); 
    }
}
*/
t_jit_err jit_attr_addfilterget_clip(void *x, double min, double max, long usemin, long usemax)
{
    void *o;

    if (x&&(o=jit_object_new(gensym("jit_attr_filter_clip")))) {
        jit_attr_setsym(o,_jit_sym_type,jit_object_method(x,gensym("gettype")));
        jit_attr_setfloat(o,gensym("min"),min);
        jit_attr_setfloat(o,gensym("max"),max);
        jit_attr_setlong(o,gensym("usemin"),usemin);
        jit_attr_setlong(o,gensym("usemax"),usemax);
        jit_object_method(x,gensym("filterget"),o);
        return JIT_ERR_NONE;
    }
    return JIT_ERR_GENERIC;
}

t_jit_err jit_attr_addfilterget_clip_scale(void *x, double scale, double min, double max, long usemin, long usemax)
{
    void *o;

    if (x&&(o=jit_object_new(gensym("jit_attr_filter_clip")))) {
        jit_attr_setsym(o,_jit_sym_type,jit_object_method(x,gensym("gettype")));
        jit_attr_setfloat(o,gensym("scale"),scale);
        jit_attr_setfloat(o,gensym("min"),min);
        jit_attr_setfloat(o,gensym("max"),max);
        jit_attr_setlong(o,gensym("usemin"),usemin);
        jit_attr_setlong(o,gensym("usemax"),usemax);
        jit_attr_setlong(o,gensym("usescale"),1);
        jit_object_method(x,gensym("filterget"),o);
        return JIT_ERR_NONE;
    }
    return JIT_ERR_GENERIC;
}

t_jit_err jit_attr_addfilter_clip(void *x, double min, double max, long usemin, long usemax)
{
    return jit_attr_addfilterset_clip(x, min, max, usemin, usemax);
}


t_jit_err jit_attr_addfilter_clip_scale(void *x, double scale, double min, double max, long usemin, long usemax)
{
    t_jit_err err;
    err = jit_attr_addfilterset_clip_scale(x, scale, min, max, usemin, usemax);
    if (err) return err;    
    return jit_attr_addfilterget_clip_scale(x, 1./scale, 0, 0, 0, 0);
}

t_jit_err jit_attr_addfilterset_proc(void *x, method proc)
{
    void *o;

    if (x&&(o=jit_object_new(gensym("jit_attr_filter_proc"),proc))) {
        jit_object_method(x,gensym("filterset"),o);
        return JIT_ERR_NONE;
    }
    return JIT_ERR_GENERIC;
}

t_jit_err jit_attr_addfilterget_proc(void *x, method proc)
{
    void *o;

    if (x&&(o=jit_object_new(gensym("jit_attr_filter_proc"),proc))) {
        jit_object_method(x,gensym("filterset"),o);
        return JIT_ERR_NONE;
    }
    return JIT_ERR_GENERIC;
}

Copyright © 2008, Cycling '74