Max 5 API Reference

jit.matrix.c

/* 
    jit.matrix.c

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

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

/**
 * @defgroup matrixmod Matrix Module
    @ingroup jitter
 */

typedef struct _jit_matrix
{
    t_jit_object        ob;
    t_jit_matrix_info   info;           
    void                *data;          // this is where we keep the "stuff"
    void                **hdata;        // if it stores data in a handle
    void                *realdata;
    long                realsize;   
} t_jit_matrix;

//default raster size
#define JIT_MATRIX_DEF_TYPE             _jit_sym_char 
#define JIT_MATRIX_DEF_FLAGS            0L 
#define JIT_MATRIX_DEF_DIMCOUNT         2 
#define JIT_MATRIX_DEF_DIMSIZE          1 
#define JIT_MATRIX_DEF_PLANECOUNT       4 
#define JIT_MATRIX_BIGMATRIX            2048

#define JIT_MATRIX_MAX_DATA_SIZE        (2<<29L)
#define JIT_MATRIX_INC_THRESH           (1./(double)(1<<16L))     
#define JIT_MATRIX_FUDGE                (0.001) //to deal w/ fixed point roundoff error (nointerp)

#define DIRECTION(x) (((x)==0) ? 0 : (((x)>0) ? 1 : -1))

#include "jit.frommatrix.h"

// for PowerPC use of "__dcbz" below...

#if TARGET_RT_MAC_MACHO && __ppc__
#include "ppc_intrinsics.h"
#endif

static void *_jit_matrix_class;
void *jit_matrix_new(t_jit_matrix_info *info);
void *jit_matrix_newcopy(t_jit_matrix *copyme);
void *jit_matrix_new_typed(t_symbol *s, long argc, t_atom *argv);
t_jit_err jit_matrix_free(t_jit_matrix *x);
t_jit_err jit_matrix_type(t_jit_matrix *x, void *attr, long argc, t_atom *argv);
t_jit_err jit_matrix_dimensions(t_jit_matrix *x, void *attr, long argc, t_atom *argv);
t_jit_err jit_matrix_planecount(t_jit_matrix *x, void *attr, long argc, t_atom *argv);
t_jit_err jit_matrix_dosetinfo(t_jit_matrix *x, t_jit_matrix_info *info);
t_jit_err jit_matrix_setinfo(t_jit_matrix *x, t_jit_matrix_info *info);
t_jit_err jit_matrix_setinfo_typed(t_jit_matrix *x,t_symbol *s, long argc, t_atom *argv);
t_jit_err jit_matrix_setinfo_ex(t_jit_matrix *x, t_jit_matrix_info *info);
t_jit_err jit_matrix_getinfo(t_jit_matrix *x, t_jit_matrix_info *info);
t_jit_err jit_matrix_getdata(t_jit_matrix *x, void **data);
t_jit_err jit_matrix_data(t_jit_matrix *x, void *data);
t_jit_err jit_matrix_data16(t_jit_matrix *x, void *data, long size);
t_jit_err jit_matrix_freedata(t_jit_matrix *x);
t_jit_err jit_matrix_rebuild(t_jit_matrix *x);
t_jit_err jit_matrix_clear(t_jit_matrix *x);
t_jit_err jit_matrix_clear_custom(t_jit_matrix *x, long cval);
t_jit_err jit_matrix_setcell1d(t_jit_matrix *x, t_symbol *s, long argc, t_atom *argv);
t_jit_err jit_matrix_setcell2d(t_jit_matrix *x, t_symbol *s, long argc, t_atom *argv);
t_jit_err jit_matrix_setcell3d(t_jit_matrix *x, t_symbol *s, long argc, t_atom *argv);
t_jit_err jit_matrix_setplane1d(t_jit_matrix *x, t_symbol *s, long argc, t_atom *argv);
t_jit_err jit_matrix_setplane2d(t_jit_matrix *x, t_symbol *s, long argc, t_atom *argv);
t_jit_err jit_matrix_setplane3d(t_jit_matrix *x, t_symbol *s, long argc, t_atom *argv);
t_jit_err jit_matrix_setcell(t_jit_matrix *x, t_symbol *s, long argc, t_atom *argv);
t_jit_err jit_matrix_getcell(t_jit_matrix *x, t_symbol *s, long argc, t_atom *argv, long *rac, t_atom **rav);
t_jit_err jit_matrix_getcell_typed(t_jit_matrix *x, t_symbol *s, long argc, t_atom *argv, t_atom *rv);
t_jit_err jit_matrix_setall(t_jit_matrix *x, t_symbol *s, long argc, t_atom *argv);
t_jit_err jit_matrix_togworld(t_jit_matrix *x, GWorldPtr gp, t_gworld_conv_info *gcinfo);
t_jit_err jit_matrix_fromgworld(t_jit_matrix *x, GWorldPtr gp, t_gworld_conv_info *gcinfo);
t_jit_err jit_matrix_frommatrix(t_jit_matrix *dst_matrix, t_jit_matrix *src_matrix, t_matrix_conv_info *mcinfo);
t_jit_err jit_matrix_frommatrix_trunc(t_jit_matrix *dst_matrix, t_jit_matrix *src_matrix);
void *jit_matrix_getindex(t_jit_matrix *x, long i); //fake matrix as list for mops

void jit_matrix_setall_ndim(long dimcount, long *dim, long planecount, void *cells, t_jit_matrix_info *in_minfo, char *bip);

void jit_matrix_frommatrix_calculate_ndim(long dim, t_matrix_conv_info *mcinfo, t_jit_matrix_info *dst_minfo, char *dst_bp, 
    t_jit_matrix_info *src_minfo, char *src_bp);
void jit_matrix_frommatrix_2d_char(t_matrix_conv_info *mcinfo, t_jit_matrix_info *dst_minfo, char *dst_bp, 
    t_jit_matrix_info *src_minfo, char *src_bp); 
void jit_matrix_frommatrix_2d_long(t_matrix_conv_info *mcinfo, t_jit_matrix_info *dst_minfo, char *dst_bp, 
    t_jit_matrix_info *src_minfo, char *src_bp); 
void jit_matrix_frommatrix_2d_float32(t_matrix_conv_info *mcinfo, t_jit_matrix_info *dst_minfo, char *dst_bp, 
    t_jit_matrix_info *src_minfo, char *src_bp); 
void jit_matrix_frommatrix_2d_float64(t_matrix_conv_info *mcinfo, t_jit_matrix_info *dst_minfo, char *dst_bp, 
    t_jit_matrix_info *src_minfo, char *src_bp); 

long jit_matrix_canfastcopy(t_matrix_conv_info *mcinfo, t_jit_matrix_info *dst_minfo, t_jit_matrix_info *src_minfo);
t_jit_err jit_matrix_fastcopy(long size, void *dst, void *src);
t_jit_err jit_matrix_fastcopy_altivec(long size, void *dst, void *src);

long jit_matrix_lock(t_jit_matrix *x, long lock);
t_jit_err jit_matrix_op(t_jit_matrix *x, t_symbol *s, long argc, t_atom *argv);
t_jit_err jit_matrix_exprfill(t_jit_matrix *x, t_symbol *s, long argc, t_atom *argv);
t_jit_err jit_matrix_jit_gl_texture(t_jit_matrix *x, t_symbol *s, long argc, t_atom *argv);

t_symbol *ps_atomarray,*ps_nobox;
static t_symbol *ps_getcell,*ps_jit_op,*ps_op,*ps_jit_expr,*ps_expr,*ps_tomatrix;

t_jit_err jit_matrix_init(void) 
{
    long i,attrflags=0;
    t_jit_object *attr;
    t_symbol *atsym;
    
    atsym = _jit_sym_jit_attr_offset;
    
    _jit_matrix_class = jit_class_new("jit_matrix",(method)jit_matrix_new,(method)jit_matrix_free,
        sizeof(t_jit_matrix),A_CANT,0L); //A_CANT = untyped
    
    //add attributes    
    attrflags = JIT_ATTR_GET_DEFER_LOW | JIT_ATTR_SET_USURP_LOW ;
    attr = jit_object_new(atsym,"type",_jit_sym_symbol,attrflags,
        (method)0L,(method)jit_matrix_type,calcoffset(t_jit_matrix,info.type));
    jit_class_addattr(_jit_matrix_class,attr);
        
    attr = jit_object_new(_jit_sym_jit_attr_offset_array,"dim",_jit_sym_long,JIT_MATRIX_MAX_DIMCOUNT,attrflags,
        (method)0L,(method)jit_matrix_dimensions,calcoffset(t_jit_matrix,info.dimcount),calcoffset(t_jit_matrix,info.dim));
    jit_class_addattr(_jit_matrix_class,attr);
    
    attr = jit_object_new(atsym,"planecount",_jit_sym_long,attrflags,
        (method)0L,(method)jit_matrix_planecount,calcoffset(t_jit_matrix,info.planecount));
    jit_class_addattr(_jit_matrix_class,attr);

    //user opaque attributes
    attrflags = JIT_ATTR_SET_OPAQUE_USER | JIT_ATTR_GET_DEFER_LOW;

    attr = jit_object_new(_jit_sym_jit_attr_offset_array,"dimstride",_jit_sym_long,JIT_MATRIX_MAX_DIMCOUNT,attrflags,
        (method)0L,(method)0L,calcoffset(t_jit_matrix,info.dimcount),calcoffset(t_jit_matrix,info.dimstride));
    jit_class_addattr(_jit_matrix_class,attr);

    attr = jit_object_new(atsym,"size",_jit_sym_long,attrflags,
        (method)0L,(method)0L,calcoffset(t_jit_matrix,info.size));  
    jit_class_addattr(_jit_matrix_class,attr);
            
    attrflags = JIT_ATTR_SET_OPAQUE_USER | JIT_ATTR_GET_OPAQUE_USER;

    //may wish to expose some flags to the user?
    attr = jit_object_new(atsym,"flags",_jit_sym_long,attrflags,
        (method)0L,(method)0L,calcoffset(t_jit_matrix,info.flags));
    jit_class_addattr(_jit_matrix_class,attr);

    //add methods
    jit_class_addmethod(_jit_matrix_class, (method)jit_method_true,     "class_jit_matrix" , A_CANT, 0L);
    jit_class_addmethod(_jit_matrix_class, (method)jit_matrix_getindex, "getindex", A_CANT, 0L); //fake as list for mops
    jit_class_addmethod(_jit_matrix_class, (method)jit_object_register, "register", A_CANT, 0L); //can register
    jit_class_addmethod(_jit_matrix_class, (method)jit_matrix_newcopy,  "newcopy",  A_CANT, 0L); 
    jit_class_addmethod(_jit_matrix_class, (method)jit_matrix_setinfo,  "setinfo",  A_CANT, 0L);
    jit_class_addmethod(_jit_matrix_class, (method)jit_matrix_setinfo_ex, "setinfo_ex", A_CANT, 0L);
    jit_class_addmethod(_jit_matrix_class, (method)jit_matrix_getinfo,  "getinfo",  A_CANT, 0L);
    jit_class_addmethod(_jit_matrix_class, (method)jit_matrix_getdata,  "getdata",  A_CANT, 0L);
    jit_class_addmethod(_jit_matrix_class, (method)jit_matrix_data,     "data",     A_CANT, 0L);
    jit_class_addmethod(_jit_matrix_class, (method)jit_matrix_data16,   "data16",   A_CANT, 0L);
    jit_class_addmethod(_jit_matrix_class, (method)jit_matrix_freedata, "freedata", A_CANT, 0L);
    jit_class_addmethod(_jit_matrix_class, (method)jit_matrix_lock,     "lock",     A_CANT, 0L);
    //user methods
    jit_class_addmethod(_jit_matrix_class, (method)jit_matrix_clear,    "clear",    A_DEFER_LOW, 0L);
    jit_class_addmethod(_jit_matrix_class, (method)jit_matrix_clear_custom, "clear_custom", A_CANT, 0L);
    jit_class_addmethod(_jit_matrix_class, (method)jit_matrix_setcell,  "setcell",  A_DEFER_LOW, 0L);
    jit_class_addmethod(_jit_matrix_class, (method)jit_matrix_setall,   "setall",   A_DEFER_LOW, 0L);
    jit_class_addmethod(_jit_matrix_class, (method)jit_matrix_getcell,  "getcell",  A_CANT, 0L); //no defer since called via max
    jit_class_addmethod(_jit_matrix_class, (method)jit_matrix_setcell1d,"setcell1d",A_DEFER_LOW, 0L);
    jit_class_addmethod(_jit_matrix_class, (method)jit_matrix_setcell2d,"setcell2d",A_DEFER_LOW, 0L);
    jit_class_addmethod(_jit_matrix_class, (method)jit_matrix_setcell3d,"setcell3d",A_DEFER_LOW, 0L);
    jit_class_addmethod(_jit_matrix_class, (method)jit_matrix_setplane1d,"setplane1d",A_DEFER_LOW, 0L);
    jit_class_addmethod(_jit_matrix_class, (method)jit_matrix_setplane2d,"setplane2d",A_DEFER_LOW, 0L);
    jit_class_addmethod(_jit_matrix_class, (method)jit_matrix_setplane3d,"setplane3d",A_DEFER_LOW, 0L);
    jit_class_addmethod(_jit_matrix_class, (method)jit_matrix_togworld, "togworld", A_CANT, 0L);
    jit_class_addmethod(_jit_matrix_class, (method)jit_matrix_fromgworld, "fromgworld", A_CANT, 0L);
    jit_class_addmethod(_jit_matrix_class, (method)jit_matrix_frommatrix, "frommatrix", A_CANT, 0L);
    jit_class_addmethod(_jit_matrix_class, (method)jit_matrix_frommatrix_trunc, "frommatrix_trunc", A_CANT, 0L);
    jit_class_addmethod(_jit_matrix_class, (method)jit_matrix_op,        "op",          A_DEFER_LOW, 0L);
    jit_class_addmethod(_jit_matrix_class, (method)jit_matrix_exprfill,  "exprfill",    A_DEFER_LOW, 0L);
    jit_class_addmethod(_jit_matrix_class, (method)jit_matrix_jit_gl_texture,   "jit_gl_texture",   A_DEFER_LOW, 0L);

    //additional typed wrapper methods
    jit_class_addtypedwrapper(_jit_matrix_class, (method)jit_matrix_new_typed,              "new" , A_GIMME, 0L);
    jit_class_addtypedwrapper(_jit_matrix_class, (method)jit_matrix_setinfo_typed,          "setinfo" , A_GIMME, 0L);
    jit_class_addtypedwrapper(_jit_matrix_class, (method)jit_matrix_getcell_typed,          "getcell" , A_GIMMEBACK, 0L);
    //should add somethings for copying from matrices, newfrom matrices, etc.
    
    jit_class_register(_jit_matrix_class);

    ps_getcell = gensym("getcell");
    ps_atomarray = gensym("atomarray");
    ps_nobox = gensym("nobox");
    ps_jit_op = gensym("jit_op");
    ps_op = gensym("op");
    ps_jit_expr = gensym("jit_expr");
    ps_expr = gensym("expr");
    ps_tomatrix = gensym("tomatrix");

    // initialize char to float lookups
    for (i=0;i<256;i++) 
        _c2ftab[i] = (float) (_c2dtab[i] = ((double)i)/255.);   
    
    return JIT_ERR_NONE;
}

/**
 * Constructs instance of t_jit_matrix.
 *
 * @ingroup matrixmod
 *
 * @param   info    t_jit_matrix_info struct pointer
 *
 * @return  t_jit_matrix object pointer
 *
 * @warning This function is not exported, but is provided 
 *          for reference when calling via jit_object_new.
 */
void *jit_matrix_new(t_jit_matrix_info *info)
{
    t_jit_matrix *x;
    t_jit_err   err;
    
    if (x=(t_jit_matrix *)jit_object_alloc(_jit_matrix_class)) {
        x->data         = NULL;
        x->hdata        = NULL;
        x->realdata     = NULL;
        x->realsize     = 0;
        if (info) {
            x->info = *info;
            if (x->info.flags&JIT_MATRIX_DATA_FLAGS_USE) {
                //leave data flags, but don't store JIT_MATRIX_DATA_FLAGS_USE
                x->info.flags &= ~JIT_MATRIX_DATA_FLAGS_USE; 
            } else { 
                x->info.flags &= ~(JIT_MATRIX_DATA_FLAGS_USE | 
                                    JIT_MATRIX_DATA_REFERENCE | 
                                    JIT_MATRIX_DATA_HANDLE); 
            }
            err = jit_matrix_rebuild(x);
        } else {
            jit_matrix_info_default(&x->info);
            err = jit_matrix_rebuild(x);
        }
        if (err) {
            jit_object_free(x);
            x = NULL;
        } 
    }
    return x;
}

/**
 * Constructs instance of t_jit_matrix, copying from input.
 *
 * @ingroup matrixmod
 *
 * @param   copyme  t_jit_matrix 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_matrix.
 */
void *jit_matrix_newcopy(t_jit_matrix *copyme)
{
    t_jit_matrix *x=NULL;
    long i=0,savelock;
    
    if (copyme&&(x=(t_jit_matrix *)jit_object_alloc(_jit_matrix_class))) {
        savelock = jit_matrix_lock(copyme,1);
        x->info = copyme->info;
        if (x->info.flags&JIT_MATRIX_DATA_REFERENCE) {
            x->data         = NULL;
            x->hdata        = copyme->hdata;
        } else {
            x->data         = NULL;
            x->hdata        = NULL;
        }
        jit_matrix_lock(copyme,savelock);
        if (jit_matrix_rebuild(x)) {
            jit_object_free(x);
            x = NULL;
        } else {
            //copy the data?
        }
    }
    return x;
}

void *jit_matrix_new_typed(t_symbol *s, long argc, t_atom *argv)
{
    t_jit_matrix_info info;
    long i;
    
    jit_matrix_info_default(&info);
    if (argc>0)
        info.planecount = CLAMP(jit_atom_getlong(argv),1,32);
    if (argc>1)
        info.type = jit_atom_getsym(argv+1);
    if (argc>2) {
        info.dimcount = MIN(32,argc-2);
        for (i=0;i<info.dimcount;i++)
            info.dim[i] = jit_atom_getlong(argv+i+2);
    }
    return jit_matrix_new(&info);
}

t_jit_err jit_matrix_setinfo_typed(t_jit_matrix *x,t_symbol *s, long argc, t_atom *argv)
{
    t_jit_matrix_info info;
    t_object *o=NULL;
    long i;
    
    if (x) {
        jit_matrix_info_default(&info);
        if (argc&&(argv[0].a_type==A_OBJ)&&
            jit_object_method(argv[0].a_w.w_obj,_jit_sym_class_jit_matrix)) 
        {
            // matrix object passed in (could also look for named symbols?)
            // perhaps make this a common function that could be called?
            jit_object_method(argv[0].a_w.w_obj,_jit_sym_getinfo,&info);
        } else {
            if ((argc==1)&&(argv[0].a_type==A_SYM)&&
                (o=jit_object_findregistered(argv[0].a_w.w_sym))&&
                jit_object_method(o,_jit_sym_class_jit_matrix)) 
            {
                jit_object_method(o,_jit_sym_getinfo,&info);        
            } else {
                jit_matrix_getinfo(x,&info);
                if (argc>0)
                    info.planecount = CLAMP(jit_atom_getlong(argv),1,32);
                if (argc>1)
                    info.type = jit_atom_getsym(argv+1);
                if (argc>2) {
                    info.dimcount = MIN(32,argc-2);
                    for (i=0;i<info.dimcount;i++)
                        info.dim[i] = jit_atom_getlong(argv+i+2);
                }
            }
        }
        jit_matrix_setinfo(x,&info);
    }
    return JIT_ERR_NONE;
}

/**
 * Frees instance of t_jit_matrix.
 *
 * @ingroup matrixmod
 *
 * @param   x       t_jit_matrix object pointer
 *
 * @return  t_jit_err error code
 *
 * @warning Use jit_object_free instead.
 */
t_jit_err jit_matrix_free(t_jit_matrix *x)
{
    void *data;
    
    if (x) {
        //only free it if it's your memory
        if (!(x->info.flags&JIT_MATRIX_DATA_REFERENCE)) {
            if (x->info.flags&JIT_MATRIX_DATA_HANDLE) {
                data = x->hdata;
                x->data = NULL; //data being used as "valid" flag
                x->hdata = NULL; 
                if (data) jit_handle_free(data);
            } else {
                data = x->data;
                x->data = NULL; //data being used as "valid" flag 
                if (data) jit_matrix_freedata(x);
            }
        }
    }
    return JIT_ERR_NONE;
}

t_jit_err jit_matrix_rebuild(t_jit_matrix *x)
{
    long i,typesize=1;
    unsigned long size=0;
    void *data;
            
    if (x) {
        // "rebuilding" notification for peek~ + poke~ since data ptr  
        // is not safe to use as valid flag inside perform routine
        jit_object_notify(x,_jit_sym_rebuilding,NULL); 
        data = x->data;
        x->data = NULL;     //data being used as "valid" flag
        if (x->info.type==_jit_sym_char)
            typesize=sizeof(uchar);
        else if (x->info.type==_jit_sym_long)
            typesize=sizeof(long);
        else if (x->info.type==_jit_sym_float32)
            typesize=sizeof(float);
        else if (x->info.type==_jit_sym_float64)
            typesize=sizeof(double);
        else if (x->info.type==_jit_sym_symbol)
            typesize=sizeof(void *);
        else if (x->info.type==_jit_sym_object)
            typesize=sizeof(void *);
        else if (x->info.type==_jit_sym_pointer)
            typesize=sizeof(void *);
        else {
            jit_object_post((t_object *)x,"warning: attempting to allocate matrix with unknown type");
            x->info.type=_jit_sym_char;
            typesize=sizeof(uchar);
        }
        if (x->info.flags&JIT_MATRIX_DATA_REFERENCE) {
            jit_object_notify(x,_jit_sym_modified,NULL);
            //jit_object_post((t_object *)x,"modifying reference");
            return JIT_ERR_NONE;    
        }
        if (x->info.planecount>JIT_MATRIX_MAX_PLANECOUNT) {
            jit_object_post((t_object *)x,"warning: attempting to allocate matrix with more than 32 planes");
        } else if (x->info.planecount<1){
            jit_object_post((t_object *)x,"warning: attempting to allocate matrix with less than 1 plane");
        }
        CLIP(x->info.planecount,1,JIT_MATRIX_MAX_DIMCOUNT);
            
        size = typesize * x->info.planecount;
        
        for (i=0;i<JIT_MATRIX_MAX_DIMCOUNT;i++) {
            x->info.dim[i] = MAX(1,x->info.dim[i]);
        }
        for (i=0;i<x->info.dimcount;i++) {
            x->info.dimstride[i] = size;
            size *= x->info.dim[i];
            //overflow error
            if ((size>=JIT_MATRIX_MAX_DATA_SIZE)||(size<(unsigned long)x->info.dimstride[i])) {
                jit_object_error((t_object *)x,"could not allocate matrix");
                if (x->info.flags&JIT_MATRIX_DATA_HANDLE) {
                    if (x->hdata)
                        jit_handle_free(x->hdata);
                    x->hdata = NULL;
                    x->info.size = 0;
                    jit_object_notify(x,_jit_sym_modified,NULL);
                    return JIT_ERR_OUT_OF_MEM;  
                } else {
                    jit_matrix_freedata(x);
                    x->data = NULL;
                    x->info.size = 0;
                    jit_object_notify(x,_jit_sym_modified,NULL);
                    return JIT_ERR_OUT_OF_MEM;  
                }
            }
            //round row dimension to nearest 16 bytes for altivec
            if (i==0&&!(x->info.flags&JIT_MATRIX_DATA_PACK_TIGHT)) {
                if (size%16)
                    size = ((size/16)+1)*16;
            }
        } 
        for (i=x->info.dimcount;i<JIT_MATRIX_MAX_DIMCOUNT;i++) {
            x->info.dim[i] = 1;
            x->info.dimstride[i] = 0;   
        }
        if (x->info.flags&JIT_MATRIX_DATA_HANDLE) {
            if (x->hdata) {
                if (jit_handle_size_set(x->hdata,size)) {
                    x->info.size = 0;
                    jit_object_notify(x,_jit_sym_modified,NULL);
                    return JIT_ERR_OUT_OF_MEM;
                }   
            } else {
                if (!(x->hdata=jit_handle_new(size))) {
                    x->info.size = 0;
                    jit_object_notify(x,_jit_sym_modified,NULL);
                    return JIT_ERR_OUT_OF_MEM;
                }   
            }
        } else {
            jit_matrix_freedata(x);

            if ((size==0)||(!(data=jit_getbytes(size+16)))) {
                jit_object_error((t_object *)x,"could not allocate matrix");
                x->info.size = 0;
                x->data = NULL;
                
                jit_object_notify(x,_jit_sym_modified,NULL);
                return JIT_ERR_OUT_OF_MEM;
            }
            x->realdata = data;
            x->realsize = size+16;
            data = (void *)(((unsigned long)x->realdata + 15L) & 0xFFFFFFF0L);
        }
        x->info.size = size;
        x->data = data; //data being used as "valid" flag           
        jit_object_notify(x,_jit_sym_modified,NULL);
        jit_matrix_clear(x);
        return JIT_ERR_NONE;
    } else {
        return JIT_ERR_INVALID_PTR;
    }
}

t_jit_err jit_matrix_type(t_jit_matrix *x, void *attr, long argc, t_atom *argv)
{   
    t_symbol *type;
    
    if (x){
        if (argc&&argv) {
            type=jit_atom_getsym(argv);
            if (x->info.type!=type) {
                x->info.type=type;
                return jit_matrix_rebuild(x);
            } else { 
                return JIT_ERR_NONE;
            }
        } else {
            return JIT_ERR_NONE;
        }
    }
    return JIT_ERR_INVALID_PTR;
}

t_jit_err jit_matrix_dimensions(t_jit_matrix *x, void *attr, long argc, t_atom *argv)
{
    long i=0,zap=JIT_MATRIX_MAX_DIMCOUNT;
    long c,dimcount,dim[JIT_MATRIX_MAX_DIMCOUNT];
    long rebuild=FALSE;
    
    if (x) {
        CLIP(argc,0,JIT_MATRIX_MAX_DIMCOUNT);
        dimcount = argc;
        if (dimcount!=x->info.dimcount) rebuild = TRUE;
        if (argc&&argv) {
            zap -= argc;
            while (argc--) {
                c = jit_atom_getlong(argv+i);
                dim[i] = MAX(c,1);
                if (dim[i]!=x->info.dim[i]) rebuild = TRUE;
                i++;
            }
        }
        while (zap--) {
            dim[i] = 1;
            i++;
        }
        if (rebuild) {
            x->info.dimcount = dimcount;
            for (i=0;i<JIT_MATRIX_MAX_DIMCOUNT;i++)
                x->info.dim[i] = MAX(1,dim[i]);
            return jit_matrix_rebuild(x);
        } else {
            return JIT_ERR_NONE;
        }
    }
    return JIT_ERR_INVALID_PTR;
}
    
t_jit_err jit_matrix_planecount(t_jit_matrix *x, void *attr, long argc, t_atom *argv)
{
    long c=1;
    long planecount;
    
    if (x) {
        if(argc&&argv) {
            c = jit_atom_getlong(argv);
            CLIP(c,1,JIT_MATRIX_MAX_PLANECOUNT);
            planecount=c;
            if (x->info.planecount!=planecount) {
                x->info.planecount=planecount;
                return jit_matrix_rebuild(x);
            } else { 
                return JIT_ERR_NONE;
            }
        }
    }
    return JIT_ERR_INVALID_PTR;
}

t_jit_err jit_matrix_dosetinfo(t_jit_matrix *x, t_jit_matrix_info *info)
{
    long rebuild=FALSE,flags,i;
    
    if (x) {
        if (info) {
            rebuild |= (x->info.type!=info->type); 
            rebuild |= (x->info.planecount!=info->planecount); 
            rebuild |= (x->info.dimcount!=info->dimcount); 
            for (i=0;i<info->dimcount;i++) {
                rebuild |= (x->info.dim[i]!=info->dim[i]); 
            }
            if (rebuild) {
                x->info.type        = info->type; 
                x->info.planecount  = info->planecount; 
                x->info.dimcount    = info->dimcount; 
                for (i=0;i<info->dimcount;i++) {
                    x->info.dim[i]  = MAX(1,info->dim[i]); 
                }
                return jit_matrix_rebuild(x);
            } else
                return JIT_ERR_NONE;
        } else {
            jit_matrix_info_default(&x->info);
            return jit_matrix_rebuild(x);
        }
    } else {
        return JIT_ERR_INVALID_PTR;
    }
}

/**
 * Sets all attributes according to the t_jit_matrix_info struct provided.
 *
 * @ingroup matrixmod
 *
 * @param   x       t_jit_matrix 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_matrix.
 */
t_jit_err jit_matrix_setinfo(t_jit_matrix *x, t_jit_matrix_info *info)
{
    t_jit_err rv;
    
    rv = jit_matrix_dosetinfo(x, info);
    jit_object_notify(x, _jit_sym_setinfo, NULL); // i need this for uyvy dim changes (jb)
    return rv;
}

/**
 * Sets all attributes according to the t_jit_matrix_info struct provided (including data flags).
 *
 * @ingroup matrixmod
 *
 * @param   x       t_jit_matrix 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_matrix.
 */
t_jit_err jit_matrix_setinfo_ex(t_jit_matrix *x, t_jit_matrix_info *info)
{   
    if (x&&info) {
        if (info->flags&JIT_MATRIX_DATA_REFERENCE) {
            //currently this should only be used by jit.coerce + jit.submatrix
            x->info = *info;
            x->realsize = x->info.size;
            jit_object_notify(x, _jit_sym_modified, NULL);
            return JIT_ERR_NONE;
        }
        else if (x->info.flags&JIT_MATRIX_DATA_REFERENCE) { // so, do this without an explicit flag
            x->info.flags = info->flags & ~(JIT_MATRIX_DATA_REFERENCE);
            x->realdata = x->data = NULL;
            x->realsize = x->info.size = 0;
            x->info.type = _jit_sym_nothing; // force a rebuild
        } else {
            x->info.flags = info->flags;
        }
    }
    return jit_matrix_setinfo(x, info);
}

/**
 * Retrieves all attributes, copying into the t_jit_matrix_info struct provided.
 *
 * @ingroup matrixmod
 *
 * @param   x       t_jit_matrix 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_matrix.
 */
t_jit_err jit_matrix_getinfo(t_jit_matrix *x, t_jit_matrix_info *info)
{   
    if (x&&info) {  
        *info = x->info;
        return JIT_ERR_NONE;
    } else {
        return JIT_ERR_INVALID_PTR;
    }
}

void *jit_matrix_getindex(t_jit_matrix *x, long i) //matrix fakes as a list of matrices for mop code
{
    if (x&&(i==0)) {    
        return x;
    } else {
        return NULL;
    }
}

/**
 * Retrieves matrix data pointer.
 *
 * @ingroup matrixmod
 *
 * @param   x       t_jit_matrix object pointer
 * @param   data    pointer to data pointer (set to NULL if matrix is not available)
 *
 * @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_matrix.
 */
t_jit_err jit_matrix_getdata(t_jit_matrix *x, void **data)
{
    if (x&&data) {  
        *data = x->data;
        return JIT_ERR_NONE;
    } else {
        return JIT_ERR_INVALID_PTR;
    }
}

/**
 * Sets matrix data pointer.
 *
 * @ingroup matrixmod
 *
 * @param   x       t_jit_matrix object pointer
 * @param   data    data 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_matrix.
 */
t_jit_err jit_matrix_data(t_jit_matrix *x, void *data)
{
    if (x) {    
        x->data = data;
        x->realdata = data;
        return JIT_ERR_NONE;
    } else {
        return JIT_ERR_INVALID_PTR;
    }
}

t_jit_err jit_matrix_data16(t_jit_matrix *x, void *data, long size)
{
    if (x) {    
        x->data = (void *)((unsigned long)x->realdata & 0xFFFFFFF0);
        x->info.size = size - ((unsigned long)data - (unsigned long)x->data);
        x->realdata = data;
        x->realsize = size;
        return JIT_ERR_NONE;
    } else {
        return JIT_ERR_INVALID_PTR;
    }
}

/**
 * Frees matrix's internal data pointer if an internal reference and sets to NULL.
 *
 * @ingroup matrixmod
 *
 * @param   x       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_matrix.
 */
t_jit_err jit_matrix_freedata(t_jit_matrix *x)
{
    if (x) {
        if (x->realdata&&x->realsize&& !(x->info.flags & JIT_MATRIX_DATA_REFERENCE))    
            jit_freebytes(x->realdata,x->realsize);
        x->realdata = x->data = NULL;
        x->realsize = x->info.size = 0;
        return JIT_ERR_NONE;
    } else {
        return JIT_ERR_INVALID_PTR;
    }
}

/**
 * Initializes matrix info struct to default values.
 *
 * @ingroup matrixmod
 *
 * @param   info        t_jit_matrix_info struct 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_matrix.
 */
t_jit_err jit_matrix_info_default(t_jit_matrix_info *info)
{
    long i=0;
    
    if (info) { 
        info->size          = 0;
        info->type          = JIT_MATRIX_DEF_TYPE;
        info->flags         = JIT_MATRIX_DEF_FLAGS;
        info->dimcount      = JIT_MATRIX_DEF_DIMCOUNT;
        info->planecount    = JIT_MATRIX_DEF_PLANECOUNT;
        for (i=0;i<JIT_MATRIX_MAX_DIMCOUNT;i++) {
            info->dim[i]=1;
            info->dimstride[i]=0;
        }
        for (i=0;i<JIT_MATRIX_DEF_DIMCOUNT;i++) {
            info->dim[i]=JIT_MATRIX_DEF_DIMSIZE;
        }
        return JIT_ERR_NONE;
    } else {
        return JIT_ERR_INVALID_PTR;
    }
}

/**
 * Sets all cells in matrix to the zero.
 * See Jitter user documentation for more information.
 * 
 * @ingroup matrixmod
 *
 * @param   x       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_matrix.
 */
t_jit_err jit_matrix_clear(t_jit_matrix *x)
{
    long savelock;
    long size,*lp;
    char *cp;
    
    if (x) {    
        savelock = jit_matrix_lock(x,1);
        if (!x->data) {
            jit_matrix_lock(x,savelock);
            return JIT_ERR_GENERIC;
        }
        if (x->info.size%4) {
            size = (x->info.size/4)+1;
            lp = ((long *)(x->data))-1;
            while (--size) *++lp=0;         
            size = (x->info.size%4)+1;
            cp = ((char *)lp)-1;
            while (--size) *++cp=0;         
        } else {
            size = (x->info.size/4)+1;
            lp = ((long *)(x->data))-1;
            while (--size) *++lp=0;         
        }
        jit_matrix_lock(x,savelock);
        return JIT_ERR_NONE;
    } else {
        return JIT_ERR_INVALID_PTR;
    }
}

t_jit_err jit_matrix_clear_custom(t_jit_matrix *x, long cval)
{
    long savelock;
    long size,*lp;
    char *cp;
    long val = BE_I32(cval);

    if (x) {
        savelock = jit_matrix_lock(x,1);
        if (!x->data) {
            jit_matrix_lock(x,savelock);
            return JIT_ERR_GENERIC;
        }
        if (x->info.size%4) {
            size = (x->info.size/4)+1;
            lp = ((long *)(x->data))-1;
            while (--size) *++lp=val;           
            size = (x->info.size%4)+1;
            cp = ((char *)lp)-1;
            while (--size) *++cp=val;           
        } else {
            size = (x->info.size/4)+1;
            lp = ((long *)(x->data))-1;
            while (--size) *++lp=val;           
        }
        jit_matrix_lock(x,savelock);
        return JIT_ERR_NONE;
    } else {
        return JIT_ERR_INVALID_PTR;
    }
}

// utilities for js/java efficiency (no symbol generation for val/plane keywords is 25-50% performance boost
/**
 * Sets cell at index to the value provided. 
 * See Jitter user documentation for more information.
 * 
 * @ingroup matrixmod
 *
 * @param   x       t_jit_matrix object pointer
 * @param   s       message symbol pointer
 * @param   argc    argument count
 * @param   argv    argument vector
 *
 * @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_matrix.
 */
t_jit_err jit_matrix_setcell1d(t_jit_matrix *x, t_symbol *s, long argc, t_atom *argv)
{
    long i;
    t_atom a[128];

    if (argc<1) return JIT_ERR_NONE;
    if (argc>100) argc=100;
            
    jit_atom_setlong(a,jit_atom_getlong(argv));
    jit_atom_setsym(a+1,_jit_sym_val);
    for (i=1;i<argc;i++) { 
        a[i+1] = argv[i];
    }
    jit_matrix_setcell(x,s,argc+1,a);
    return JIT_ERR_NONE;
}

/**
 * Sets cell at index to the value provided. 
 * See Jitter user documentation for more information.
 * 
 * @ingroup matrixmod
 *
 * @param   x       t_jit_matrix object pointer
 * @param   s       message symbol pointer
 * @param   argc    argument count
 * @param   argv    argument vector
 *
 * @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_matrix.
 */
t_jit_err jit_matrix_setcell2d(t_jit_matrix *x, t_symbol *s, long argc, t_atom *argv)
{
    long i;
    t_atom a[128];

    if (argc<2) return JIT_ERR_NONE;
    if (argc>100) argc=100;
            
    jit_atom_setlong(a,jit_atom_getlong(argv));
    jit_atom_setlong(a+1,jit_atom_getlong(argv+1));
    jit_atom_setsym(a+2,_jit_sym_val);
    for (i=2;i<argc;i++) { 
        a[i+1] = argv[i];
    }
    jit_matrix_setcell(x,s,argc+1,a);
    return JIT_ERR_NONE;
}

/**
 * Sets cell at index to the value provided. 
 * See Jitter user documentation for more information.
 * 
 * @ingroup matrixmod
 *
 * @param   x       t_jit_matrix object pointer
 * @param   s       message symbol pointer
 * @param   argc    argument count
 * @param   argv    argument vector
 *
 * @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_matrix.
 */
t_jit_err jit_matrix_setcell3d(t_jit_matrix *x, t_symbol *s, long argc, t_atom *argv)
{
    long i;
    t_atom a[128];

    if (argc<3) return JIT_ERR_NONE;
    if (argc>100) argc=100;
            
    jit_atom_setlong(a,jit_atom_getlong(argv));
    jit_atom_setlong(a+1,jit_atom_getlong(argv+1));
    jit_atom_setlong(a+2,jit_atom_getlong(argv+2));
    jit_atom_setsym(a+3,_jit_sym_val);
    for (i=3;i<argc;i++) { 
        a[i+1] = argv[i];
    }
    jit_matrix_setcell(x,s,argc+1,a);
    return JIT_ERR_NONE;
}

/**
 * Sets plane of cell at index to the value provided. 
 * See Jitter user documentation for more information.
 * 
 * @ingroup matrixmod
 *
 * @param   x       t_jit_matrix object pointer
 * @param   s       message symbol pointer
 * @param   argc    argument count
 * @param   argv    argument vector
 *
 * @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_matrix.
 */
t_jit_err jit_matrix_setplane1d(t_jit_matrix *x, t_symbol *s, long argc, t_atom *argv)
{
    long i;
    t_atom a[128];

    if (argc<2) return JIT_ERR_NONE;
    if (argc>100) argc=100;
            
    jit_atom_setlong(a,jit_atom_getlong(argv));
    jit_atom_setsym(a+1,_jit_sym_plane);
    jit_atom_setlong(a+2,jit_atom_getlong(argv+1));
    jit_atom_setsym(a+3,_jit_sym_val);
    for (i=2;i<argc;i++) { 
        a[i+2] = argv[i];
    }
    jit_matrix_setcell(x,s,argc+2,a);
    return JIT_ERR_NONE;
}

/**
 * Sets plane of cell at index to the value provided. 
 * See Jitter user documentation for more information.
 * 
 * @ingroup matrixmod
 *
 * @param   x       t_jit_matrix object pointer
 * @param   s       message symbol pointer
 * @param   argc    argument count
 * @param   argv    argument vector
 *
 * @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_matrix.
 */
t_jit_err jit_matrix_setplane2d(t_jit_matrix *x, t_symbol *s, long argc, t_atom *argv)
{
    long i;
    t_atom a[128];

    if (argc<3) return JIT_ERR_NONE;
    if (argc>100) argc=100;
            
    jit_atom_setlong(a,jit_atom_getlong(argv));
    jit_atom_setlong(a+1,jit_atom_getlong(argv+1));
    jit_atom_setsym(a+2,_jit_sym_plane);
    jit_atom_setlong(a+3,jit_atom_getlong(argv+2));
    jit_atom_setsym(a+4,_jit_sym_val);
    for (i=3;i<argc;i++) { 
        a[i+2] = argv[i];
    }
    jit_matrix_setcell(x,s,argc+2,a);
    return JIT_ERR_NONE;
}

/**
 * Sets plane of cell at index to the value provided. 
 * See Jitter user documentation for more information.
 * 
 * @ingroup matrixmod
 *
 * @param   x       t_jit_matrix object pointer
 * @param   s       message symbol pointer
 * @param   argc    argument count
 * @param   argv    argument vector
 *
 * @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_matrix.
 */
t_jit_err jit_matrix_setplane3d(t_jit_matrix *x, t_symbol *s, long argc, t_atom *argv)
{
    long i;
    t_atom a[128];

    if (argc<4) return JIT_ERR_NONE;
    if (argc>100) argc=100;
            
    jit_atom_setlong(a,jit_atom_getlong(argv));
    jit_atom_setlong(a+1,jit_atom_getlong(argv+1));
    jit_atom_setlong(a+2,jit_atom_getlong(argv+2));
    jit_atom_setsym(a+3,_jit_sym_plane);
    jit_atom_setlong(a+4,jit_atom_getlong(argv+3));
    jit_atom_setsym(a+5,_jit_sym_val);
    for (i=4;i<argc;i++) { 
        a[i+2] = argv[i];
    }
    jit_matrix_setcell(x,s,argc+2,a);
    return JIT_ERR_NONE;
}

/**
 * Sets cell at index to the value provided. 
 * See Jitter user documentation for more information.
 * 
 * @ingroup matrixmod
 *
 * @param   x       t_jit_matrix object pointer
 * @param   s       message symbol pointer
 * @param   argc    argument count
 * @param   argv    argument vector
 *
 * @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_matrix.
 */
t_jit_err jit_matrix_setcell(t_jit_matrix *x, t_symbol *s, long argc, t_atom *argv)
{
    long savelock;
    long stride,i,j,plane=0,useplane=0;
    long cell[JIT_MATRIX_MAX_DIMCOUNT];
    char *p;
    
    if (x) {
        if (argc&&argv) {
            //parse args
            for (i=0;(i<argc)&&(i<=JIT_MATRIX_MAX_DIMCOUNT);i++) {
                if ((argv[i].a_type==A_SYM)&&(argv[i].a_w.w_sym==_jit_sym_val)) {   
                    goto pikka;
                }
                if ((argv[i].a_type==A_SYM)&&(argv[i].a_w.w_sym==_jit_sym_plane)) {
                    useplane = 1;   
                    goto pikka;
                }
                cell[i] = jit_atom_getlong(argv+i);
            }
            goto pakka; //too many dimensions without "val" token
pikka:      
            if (useplane) {
                for (j=i;j<x->info.dimcount;j++) cell[j] = 0;           
                if (++i<argc) plane = jit_atom_getlong(argv+i);
                if (plane>=x->info.planecount) goto pakka;
                i++;
                if ((argv[i].a_type!=A_SYM)||(argv[i].a_w.w_sym!=_jit_sym_val)) {   
                    goto pakka;
                }
                i++;
                savelock = jit_matrix_lock(x,1);
                if (!x->data) goto pakka;
                //find ptr
                p = ((char *)(x->data));
                for (j=0;j<x->info.dimcount;j++) {
                    if ((cell[j]>=0)&&(cell[j]<x->info.dim[j]))
                        p += cell[j]*x->info.dimstride[j];                  
                    else goto pakka;
                }
                if (i<argc) {   
                    if (x->info.type==_jit_sym_char) {
                        ((uchar *)p)[plane]     = jit_atom_getcharfix(argv+i);
                    } else if (x->info.type==_jit_sym_long) {
                        ((long *)p)[plane]      = jit_atom_getlong(argv+i);
                    } else if (x->info.type==_jit_sym_float32) {
                        ((float *)p)[plane]     = jit_atom_getfloat(argv+i);
                    } else if (x->info.type==_jit_sym_float64) {
                        ((double *)p)[plane]    = jit_atom_getfloat(argv+i);
                    } else if (x->info.type==_jit_sym_symbol) {
                        ((t_symbol **)p)[plane] = jit_atom_getsym(argv+i);
                    } else if (x->info.type==_jit_sym_object) {
                        ((t_object **)p)[plane] = jit_atom_getobj(argv+i);
                    }
                }
            } else {    
                for (j=i;j<x->info.dimcount;j++) cell[j] = 0;           
                savelock = jit_matrix_lock(x,1);
                if (!x->data) goto pakka;
                //find ptr
                p = ((char *)(x->data));
                for (j=0;j<x->info.dimcount;j++) {
                    if ((cell[j]>=0)&&(cell[j]<x->info.dim[j]))
                        p += cell[j]*x->info.dimstride[j];                  
                    else goto pakka;
                }
                for (i++,j=0;j<x->info.planecount;i++,j++) {
                    if (i<argc) {   
                        if (x->info.type==_jit_sym_char) {
                            *((uchar *)p) = jit_atom_getcharfix(argv+i);        p+=1;
                        } else if (x->info.type==_jit_sym_long) {
                            *((long *)p) = jit_atom_getlong(argv+i);        p+=4;
                        } else if (x->info.type==_jit_sym_float32) {
                            *((float *)p) = jit_atom_getfloat(argv+i);      p+=4;
                        } else if (x->info.type==_jit_sym_float64) {
                            *((double *)p) = jit_atom_getfloat(argv+i);     p+=8;
                        } else if (x->info.type==_jit_sym_symbol) {
                            *((t_symbol **)p) = jit_atom_getsym(argv+i);    p+=4;
                        } else if (x->info.type==_jit_sym_object) {
                            *((t_object **)p) = jit_atom_getobj(argv+i);    p+=4;
                        }
                    } else {
                        if (x->info.type==_jit_sym_char) {
                            *p = 0;                 p+=1;
                        } else if (x->info.type==_jit_sym_long) {
                            *((long *)p) = 0;       p+=4;
                        } else if (x->info.type==_jit_sym_float32) {
                            *((float *)p) = 0;      p+=4;
                        } else if (x->info.type==_jit_sym_float64) {
                            *((double *)p) = 0;     p+=8;
                        } else if (x->info.type==_jit_sym_symbol) {
                            *((t_symbol **)p) = 0;  p+=4;
                        } else if (x->info.type==_jit_sym_object) {
                            *((t_object **)p) = 0;  p+=4;
                        }
                    }
                }
            }
            jit_matrix_lock(x,savelock);
        } 
        return JIT_ERR_NONE;
    } else {
        return JIT_ERR_INVALID_PTR;
    }
    
pakka:
    jit_matrix_lock(x,savelock);
    return JIT_ERR_OUT_OF_BOUNDS;   
}

/**
 * Gets cell at index to the value provided. 
 * See Jitter user documentation for more information.
 * 
 * @ingroup matrixmod
 *
 * @param   x       t_jit_matrix object pointer
 * @param   s       message symbol pointer
 * @param   argc    argument count
 * @param   argv    argument vector
 * @param   rac     return value atom count
 * @param   rav     return value atom vector
 *
 * @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_matrix.
 */
t_jit_err jit_matrix_getcell(t_jit_matrix *x, t_symbol *s, long argc, t_atom *argv, long *rac, t_atom **rav)
{
    long savelock;
    long stride,i,off;
    long cell[JIT_MATRIX_MAX_DIMCOUNT];
    char *p;
    
    //perhaps allow caller to pass in memory.
    *rac = 0; 
    *rav = NULL;
    
    if (x) {
        if (argc&&argv) {
            //parse args
            for (i=0;(i<argc)&&(i<JIT_MATRIX_MAX_DIMCOUNT);) {
                cell[i] = jit_atom_getlong(argv+i);
                i++;
            }

            for (;i<x->info.dimcount;i++) cell[i] = 0;
            
            savelock = jit_matrix_lock(x,1);
            if (!x->data) goto pakka;
            //find ptr
            p = ((char *)(x->data));
            for (i=0;i<x->info.dimcount;i++) {
                if ((cell[i]>=0)&&(cell[i]<x->info.dim[i]))
                    p += cell[i]*x->info.dimstride[i];                  
                else goto pakka;
            }
            if (!(*rav=jit_getbytes(sizeof(t_atom)*(x->info.dimcount+x->info.planecount+1))))
                goto pakka;
            *rac = x->info.dimcount+x->info.planecount+1;
            for (i=0;i<x->info.dimcount;i++) {
                jit_atom_setlong((*rav)+i,cell[i]);
            }
            jit_atom_setsym((*rav)+i,_jit_sym_val);
            off = i+1;
            for (i=0;i<x->info.planecount;i++) {
                if (x->info.type==_jit_sym_char) {
                    jit_atom_setlong((*rav)+off+i,*((uchar *)p));       p+=1;
                } else if (x->info.type==_jit_sym_long) {
                    jit_atom_setlong((*rav)+off+i,*((long *)p));        p+=4;
                } else if (x->info.type==_jit_sym_float32) {
                    jit_atom_setfloat((*rav)+off+i,*((float *)p));      p+=4;
                } else if (x->info.type==_jit_sym_float64) {
                    jit_atom_setfloat((*rav)+off+i,*((double *)p));     p+=8;
                } else if (x->info.type==_jit_sym_symbol) {
                    jit_atom_setsym((*rav)+off+i,*((t_symbol **)p));    p+=4;
                } else if (x->info.type==_jit_sym_object) {
                    jit_atom_setobj((*rav)+off+i,*((t_object **)p));    p+=4;
                }
                
            }
            jit_matrix_lock(x,savelock);
        } 
        return JIT_ERR_NONE;
    } else {
        return JIT_ERR_INVALID_PTR;
    }

pakka:
    jit_matrix_lock(x,savelock);
    return JIT_ERR_OUT_OF_BOUNDS;   
}

t_jit_err jit_matrix_getcell_typed(t_jit_matrix *x, t_symbol *s, long argc, t_atom *argv, t_atom *rv)
{
        long rac=0,i;
        t_atom *rav=NULL;
        t_jit_err err;

        if (err=jit_matrix_getcell(x,ps_getcell,argc,argv,&rac,&rav))
            return JIT_ERR_GENERIC;
        if (rac&&rav) {
            if (rv&&rac) {
                for (i=0;(i<rac)&&(rav[i].a_w.w_sym!=_jit_sym_val);i++)
                        ;
                if (rav[i].a_w.w_sym==_jit_sym_val) 
                    i++;    
                jit_atom_setobj(rv,object_new(ps_nobox,ps_atomarray,rac-i,rav+i));
                jit_freebytes(rav, sizeof(t_atom)*rac);
                return JIT_ERR_NONE;
            }
            jit_freebytes(rav, sizeof(t_atom)*rac);
        }
        return JIT_ERR_GENERIC;
}

/**
 * Sets all cells to the value provided. 
 * See Jitter user documentation for more information.
 * 
 * @ingroup matrixmod
 *
 * @param   x       t_jit_matrix object pointer
 * @param   s       message symbol pointer
 * @param   argc    argument count
 * @param   argv    argument vector
 *
 * @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_matrix.
 */
t_jit_err jit_matrix_setall(t_jit_matrix *x, t_symbol *s, long argc, t_atom *argv)
{
    long savelock,i;
    uchar   cval[JIT_MATRIX_MAX_PLANECOUNT];
    long    lval[JIT_MATRIX_MAX_PLANECOUNT];
    float   fval[JIT_MATRIX_MAX_PLANECOUNT];
    double  dval[JIT_MATRIX_MAX_PLANECOUNT];
    void *cells;
    
    if (x) {
        CLIP(argc,0,JIT_MATRIX_MAX_PLANECOUNT);
        if (argc&&argv) {
            if (x->info.type==_jit_sym_char) {              
                for (i=0;i<argc;i++) cval[i] = jit_atom_getcharfix(argv+i);
                if (argc==1)
                    for (;i<x->info.planecount;i++) cval[i] = cval[0];
                else
                    for (;i<x->info.planecount;i++) cval[i] = 0;
                cells = cval;           
            } else if (x->info.type==_jit_sym_long) {               
                for (i=0;i<argc;i++) lval[i] = jit_atom_getlong(argv+i);
                if (argc==1)
                    for (;i<x->info.planecount;i++) lval[i] = lval[0];
                else
                    for (;i<x->info.planecount;i++) lval[i] = 0;
                cells = lval;           
            } else if (x->info.type==_jit_sym_float32) {                
                for (i=0;i<argc;i++) fval[i] = jit_atom_getfloat(argv+i);
                if (argc==1)
                    for (;i<x->info.planecount;i++) fval[i] = fval[0];
                else
                    for (;i<x->info.planecount;i++) fval[i] = 0;
                cells = fval;           
            } else if (x->info.type==_jit_sym_float64) {                
                for (i=0;i<argc;i++) dval[i] = jit_atom_getfloat(argv+i);
                if (argc==1)
                    for (;i<x->info.planecount;i++) dval[i] = dval[0];
                else
                    for (;i<x->info.planecount;i++) dval[i] = 0;
                cells = dval;           
            }
            savelock = jit_matrix_lock(x,1);
            if (!x->data) goto pakka;
            jit_matrix_setall_ndim(x->info.dimcount, x->info.dim, x->info.planecount, cells, &x->info, x->data);
            jit_matrix_lock(x,savelock);
        } 
        return JIT_ERR_NONE;
    } else {
        return JIT_ERR_INVALID_PTR;
    }
    
pakka:
    jit_matrix_lock(x,savelock);
    return JIT_ERR_OUT_OF_BOUNDS;   
}

#ifdef WIN_32
#define ASM_DWORD_PTR dword ptr
#else
#define ASM_DWORD_PTR
#endif

void jit_matrix_setall_ndim(long dimcount, long *dim, long planecount, void *cells, t_jit_matrix_info *in_minfo, char *bip)
{
    long i,j,n;
    char *ip;
    t_jit_op_info in_opinfo,val_opinfo;
        
    if (dimcount<1) return; //safety
    
    switch(dimcount) {
    case 1:
        dim[1]=1;
    case 2:
        n = dim[0];
        in_opinfo.stride = in_minfo->dim[0]>1?in_minfo->planecount:0;
        val_opinfo.stride = 0;
        if (in_minfo->type==_jit_sym_char) {
            for (i=0;i<dim[1];i++){
                for (j=0;j<planecount;j++) {
                    in_opinfo.p  = bip + i*in_minfo->dimstride[1] + j%in_minfo->planecount;
                    val_opinfo.p = &(((uchar *)cells)[j]);
                    jit_op_vector_pass_char(n, NULL, &val_opinfo, NULL, &in_opinfo); 
                }
            }
        } else if (in_minfo->type==_jit_sym_long) {
            for (i=0;i<dim[1];i++){
                for (j=0;j<planecount;j++) {
                    in_opinfo.p  = bip + i*in_minfo->dimstride[1] + (j%in_minfo->planecount)*4;
                    val_opinfo.p = &(((long *)cells)[j]);
                    jit_op_vector_pass_long(n, NULL, &val_opinfo, NULL, &in_opinfo); 
                }
            }
        } else if (in_minfo->type==_jit_sym_float32) {
            for (i=0;i<dim[1];i++){
                for (j=0;j<planecount;j++) {
                    in_opinfo.p  = bip + i*in_minfo->dimstride[1] + (j%in_minfo->planecount)*4;
                    val_opinfo.p = &(((float *)cells)[j]);
                    jit_op_vector_pass_float32(n, NULL, &val_opinfo, NULL, &in_opinfo); 
                }
            }
        } else if (in_minfo->type==_jit_sym_float64) {
            for (i=0;i<dim[1];i++){
                for (j=0;j<planecount;j++) {
                    in_opinfo.p  = bip + i*in_minfo->dimstride[1] + (j%in_minfo->planecount)*8;
                    val_opinfo.p = &(((double *)cells)[j]);
                    jit_op_vector_pass_float64(n, NULL, &val_opinfo, NULL, &in_opinfo); 
                }
            }
        }
        break;
    default:
        for (i=0;i<dim[dimcount-1];i++) {
            ip = bip + i*in_minfo->dimstride[dimcount-1];
            jit_matrix_setall_ndim(dimcount-1,dim,planecount,cells,in_minfo,ip);
        }
    }
}

/**
 * Copies Jitter matrix data to GWorld data. 
 * 
 * @ingroup matrixmod
 *
 * @param   x       t_jit_matrix object pointer
 * @param   gp      gworld pointer
 * @param   gcinfo  conversion information 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_matrix.
 */
t_jit_err jit_matrix_togworld(t_jit_matrix *x, GWorldPtr gp, t_gworld_conv_info *gcinfo)
{
    long savelock,i,j;
    long srcheight,srcwidth,srccellstride,srcrowstride;
    long dstheight,dstwidth,dstrowstride;
    uchar *srcaddress,*dstaddress;
    PixMapHandle pmh;
    long pmap0,pmap1,pmap2,pmap3;
    long flags=0,xdir,ydir;
    long xmin,xmax,ymin,ymax;
    double dxinc=0,dyinc=0;
    Rect r;
    long quickswap = FALSE; 
    long widfactor;
    
    if (x&&gp) {    
        pmh = GetGWorldPixMap(gp);
        if (!pmh) { 
            goto pakka;
        }   
        LockPixels(pmh); 
        savelock = jit_matrix_lock(x,1);

        srcaddress = x->data;
        dstaddress = (uchar *)GetPixBaseAddr(pmh);
        if ((!srcaddress)||(!dstaddress)) { 
            UnlockPixels(pmh); 
            jit_matrix_lock(x,savelock);
            goto pakka;
        }
        srcwidth    = x->info.dim[0];
        srcheight   = x->info.dim[1];
        GetPortBounds(gp,&r);
        if ((**pmh).pixelSize == 16) // uyvy
            widfactor = 1L;
        else
            widfactor = 0L;
        dstwidth    = (r.right-r.left) >> widfactor;
        dstheight   = (r.bottom-r.top);                 
        srccellstride   = x->info.dimstride[0];
        srcrowstride    = x->info.dimstride[1];
        dstrowstride    = GetPixRowBytes(pmh);
        
        if (gcinfo) {
            flags = gcinfo->flags;
            pmap0 = CLAMP(gcinfo->planemap[0] % x->info.planecount,0,3);
            pmap1 = CLAMP(gcinfo->planemap[1] % x->info.planecount,0,3);
            pmap2 = CLAMP(gcinfo->planemap[2] % x->info.planecount,0,3);
            pmap3 = CLAMP(gcinfo->planemap[3] % x->info.planecount,0,3);
            if (flags&JIT_MATRIX_CONVERT_SRCDIM) {
                if (gcinfo->srcrect.top<0) gcinfo->srcrect.top = 0;
                else if (gcinfo->srcrect.top>=srcheight) gcinfo->srcrect.top = srcheight-1;
                if (gcinfo->srcrect.bottom<0) gcinfo->srcrect.bottom = 0;
                else if (gcinfo->srcrect.bottom>=srcheight) gcinfo->srcrect.bottom = srcheight-1;
                if (gcinfo->srcrect.left<0) gcinfo->srcrect.left = 0;
                else if (gcinfo->srcrect.left>=srcwidth) gcinfo->srcrect.left = srcwidth-1;
                if (gcinfo->srcrect.right<0) gcinfo->srcrect.right = 0;
                else if (gcinfo->srcrect.right>=srcwidth) gcinfo->srcrect.right = srcwidth-1;
                srcheight = gcinfo->srcrect.bottom - gcinfo->srcrect.top;
                srcheight = (srcheight>=0) ? srcheight+1 : srcheight-1;
                srcwidth  = gcinfo->srcrect.right  - gcinfo->srcrect.left;
                srcwidth  = (srcwidth>=0) ? srcwidth+1 : srcwidth-1;
                srcaddress += (srccellstride*gcinfo->srcrect.left) + (srcrowstride*gcinfo->srcrect.top);
            }
            if (flags&JIT_MATRIX_CONVERT_DSTDIM) {
                if (gcinfo->dstrect.top<0) gcinfo->dstrect.top = 0;
                else if (gcinfo->dstrect.top>=dstheight) gcinfo->dstrect.top = dstheight-1;
                if (gcinfo->dstrect.bottom<0) gcinfo->dstrect.bottom = 0;
                else if (gcinfo->dstrect.bottom>=dstheight) gcinfo->dstrect.bottom = dstheight-1;
                if (gcinfo->dstrect.left<0) gcinfo->dstrect.left = 0;
                else if (gcinfo->dstrect.left>=dstwidth) gcinfo->dstrect.left = dstwidth-1;
                if (gcinfo->dstrect.right<0) gcinfo->dstrect.right = 0;
                else if (gcinfo->dstrect.right>=dstwidth) gcinfo->dstrect.right = dstwidth-1;
                dstheight = ABS(gcinfo->dstrect.bottom - gcinfo->dstrect.top) + 1;
                dstwidth  = ABS(gcinfo->dstrect.right  - gcinfo->dstrect.left) + 1;
                dstaddress += (4*MIN(gcinfo->dstrect.left,gcinfo->dstrect.right)) + 
                    (dstrowstride*MIN(gcinfo->dstrect.top,gcinfo->dstrect.bottom));
            }
        } else {
            pmap0 = 0;
            pmap1 = 1 % x->info.planecount;
            pmap2 = 2 % x->info.planecount;
            pmap3 = 3 % x->info.planecount;
        }

        if ((x->info.planecount==4) &&
            (pmap0==3) &&
            (pmap1==2) &&
            (pmap2==1) &&
            (pmap3==0))
        {
            quickswap = TRUE;
        }

        //calculate scale factor
        if (gcinfo&&(gcinfo->flags&JIT_MATRIX_CONVERT_INTERP)) {
            if ((ABS(srcwidth)>1)&&(ABS(dstwidth)>1)) 
                dxinc = ((double)srcwidth-DIRECTION(srcwidth))/((double)dstwidth-1);
            if ((ABS(srcheight)>1)&&(ABS(dstheight)>1))
                dyinc = ((double)srcheight-DIRECTION(srcheight))/((double)dstheight-1);
        } else {
            if ((ABS(srcwidth)>1)&&(ABS(dstwidth)>1)) 
                dxinc = ((double)srcwidth)/((double)dstwidth);
            if ((ABS(srcheight)>1)&&(ABS(dstheight)>1))
                dyinc = ((double)srcheight)/((double)dstheight);
        }
                
        //compensate for potential FP error
        if (ABS(dxinc)<JIT_MATRIX_INC_THRESH) dxinc = 0;
        if (ABS(dyinc)<JIT_MATRIX_INC_THRESH) dyinc = 0;
        
        xdir = DIRECTION(dxinc);
        ydir = DIRECTION(dyinc);
        
        switch (xdir) 
        {
        case 1:     xmax = srcwidth-1; xmin = 0;    break;
        case -1:    xmin = srcwidth+1; xmax = 0;    break;
        default:    xmin = xmax = 0;                break;
        }
        switch (ydir) 
        {
        case 1:     ymax = srcheight-1; ymin = 0;   break;
        case -1:    ymin = srcheight+1; ymax = 0;   break;
        default:    ymin = ymax = 0;                break;
        }

        //xidx,yidx should be the top left of the src rect(clip to zero)
        //xinc,yinc should be the ratio of the source vs. destination rects
        if (x->info.type==_jit_sym_char) {
            Fixed xidx=0,xinc=0,yidx=0,yinc=0;
            Fixed xfudge,yfudge;
        
            xfudge = DoubleToFixed((xdir>=0)?JIT_MATRIX_FUDGE:1.-JIT_MATRIX_FUDGE);
            yfudge = DoubleToFixed((ydir>=0)?JIT_MATRIX_FUDGE:1.-JIT_MATRIX_FUDGE);
                                             
            xinc = DoubleToFixed(dxinc);
            yinc = DoubleToFixed(dyinc);

            if (flags&JIT_MATRIX_CONVERT_INTERP) {
                uchar *src,*src2,*dst,*x0,*x1,*x2,*x3;
                long xidx_int,xidx_int2,yidx_int,yidx_int2;
                Fixed c0,c1,c2,c3;
                Fixed xfrak,yfrak,xfrak_inv,yfrak_inv;
            
                for(i=0;i<dstheight;i++)                
                {
                    yidx_int = FixedToInt(yidx);
                    yidx_int2 = yidx_int+ydir;
                    CLIP(yidx_int2,ymin,ymax);
                    src = (uchar *)(srcaddress + (yidx_int * srcrowstride));    
                    src2 = (uchar *)(srcaddress + (yidx_int2 * srcrowstride)); //this should never be past the end            
                    dst = (uchar *)(dstaddress + (i * dstrowstride));
                    
                    --dst;    
                    xidx = 0;
                    yfrak = FixedFraction(yidx);
                    if (ydir<0&&yfrak!=0) yfrak = fixed1-yfrak;  //FixedFraction() always positive
                    yfrak_inv = fixed1-yfrak;
                    for(j=0;j<dstwidth;j++)
                    {   
                        xidx_int = FixedToInt(xidx);
                        xidx_int2 = xidx_int+xdir;
                        CLIP(xidx_int2,xmin,xmax);
                        xfrak = FixedFraction(xidx);
                        if (xdir<0&&xfrak!=0) xfrak = fixed1-xfrak; //FixedFraction() always positive
                        xfrak_inv = fixed1-xfrak;
                        xidx_int *= srccellstride;
                        xidx_int2 *= srccellstride;
                        x0 = src + xidx_int;
                        x1 = src + xidx_int2;
                        x2 = src2 + xidx_int;
                        x3 = src2 + xidx_int2;
                        c0 = FixMul(xfrak_inv,yfrak_inv);
                        c1 = FixMul(xfrak,yfrak_inv);
                        c2 = FixMul(xfrak_inv,yfrak);
                        c3 = FixMul(xfrak,yfrak);
                        *++dst=((long)(*(x0+pmap0))*c0 + (long)(*(x1+pmap0))*c1 + (long)(*(x2+pmap0))*c2 + (long)(*(x3+pmap0))*c3)>>16L; 
                        *++dst=((long)(*(x0+pmap1))*c0 + (long)(*(x1+pmap1))*c1 + (long)(*(x2+pmap1))*c2 + (long)(*(x3+pmap1))*c3)>>16L; 
                        *++dst=((long)(*(x0+pmap2))*c0 + (long)(*(x1+pmap2))*c1 + (long)(*(x2+pmap2))*c2 + (long)(*(x3+pmap2))*c3)>>16L; 
                        *++dst=((long)(*(x0+pmap3))*c0 + (long)(*(x1+pmap3))*c1 + (long)(*(x2+pmap3))*c2 + (long)(*(x3+pmap3))*c3)>>16L; 
                        xidx+=xinc;
                    }
                    yidx+=yinc;
                }       
            
            } else {
                long xidx_int,yidx_int;
                
                yidx = yfudge;
                
                if ((x->info.planecount==4)&&(quickswap||((pmap0==0)&&(pmap1==1)&&(pmap2==2)&&(pmap3==3)))) {
                    long *src,*dst;
                    long quad=dstwidth/4;
                    long rem=dstwidth%4;
                    //optimized cases
                    if (xinc==fixed1) {
                        for(i=0;i<dstheight;i++)                
                        {
                            yidx_int = FixedToInt(yidx);
                            CLIP(yidx_int,ymin,ymax);           
                            src = (long *)(srcaddress + (yidx_int*srcrowstride));            
                            dst = (long *)(dstaddress + (i*dstrowstride));
                                        
                            if (quickswap) {
#ifdef JIT_LITTLE_ENDIAN                                
                                for(j=0;j<quad;j++) {   
                                    __asm {
                                        // load pointers
                                        MOV esi,ASM_DWORD_PTR src
                                        MOV edi,ASM_DWORD_PTR dst
                                        // move + swap one 32bit word, increment ptrs
                                        MOV eax,[esi]
                                        BSWAP eax
                                        MOV [edi],eax
                                        ADD esi,4
                                        ADD edi,4
                                        // move + swap one 32bit word, increment ptrs
                                        MOV eax,[esi]
                                        BSWAP eax
                                        MOV [edi],eax
                                        ADD esi,4
                                        ADD edi,4
                                        // move + swap one 32bit word, increment ptrs
                                        MOV eax,[esi]
                                        BSWAP eax
                                        MOV [edi],eax
                                        ADD esi,4
                                        ADD edi,4
                                        // move + swap one 32bit word, increment ptrs
                                        MOV eax,[esi]
                                        BSWAP eax
                                        MOV [edi],eax
                                        ADD esi,4
                                        ADD edi,4
                                        // write pointers
                                        MOV ASM_DWORD_PTR src,esi
                                        MOV ASM_DWORD_PTR dst,edi
                                    }
                                }

                                for(j=0;j<rem;j++) {    
                                    __asm {
                                        // load pointers
                                        MOV esi,ASM_DWORD_PTR src
                                        MOV edi,ASM_DWORD_PTR dst
                                        // move + swap one 32bit word, increment ptrs
                                        MOV eax,[esi]
                                        BSWAP eax
                                        MOV [edi],eax
                                        ADD esi,4
                                        ADD edi,4
                                        // write pointers
                                        MOV ASM_DWORD_PTR src,esi
                                        MOV ASM_DWORD_PTR dst,edi
                                    }
                                }
#else
                                --dst;    
                                --src; 
                                for(j=0;j<quad;j++) {   
                                    FAST_INC(src);
                                    FAST_INC(dst);
                                    ((char *)dst)[0] = ((char *)src)[3];
                                    ((char *)dst)[1] = ((char *)src)[2];
                                    ((char *)dst)[2] = ((char *)src)[1];
                                    ((char *)dst)[3] = ((char *)src)[0];
                                    FAST_INC(src);
                                    FAST_INC(dst);
                                    ((char *)dst)[0] = ((char *)src)[3];
                                    ((char *)dst)[1] = ((char *)src)[2];
                                    ((char *)dst)[2] = ((char *)src)[1];
                                    ((char *)dst)[3] = ((char *)src)[0];
                                    FAST_INC(src);
                                    FAST_INC(dst);
                                    ((char *)dst)[0] = ((char *)src)[3];
                                    ((char *)dst)[1] = ((char *)src)[2];
                                    ((char *)dst)[2] = ((char *)src)[1];
                                    ((char *)dst)[3] = ((char *)src)[0];
                                    FAST_INC(src);
                                    FAST_INC(dst);
                                    ((char *)dst)[0] = ((char *)src)[3];
                                    ((char *)dst)[1] = ((char *)src)[2];
                                    ((char *)dst)[2] = ((char *)src)[1];
                                    ((char *)dst)[3] = ((char *)src)[0];
                                }
                                for(j=0;j<rem;j++) {    
                                    FAST_INC(src);
                                    FAST_INC(dst);
                                    ((char *)dst)[0] = ((char *)src)[3];
                                    ((char *)dst)[1] = ((char *)src)[2];
                                    ((char *)dst)[2] = ((char *)src)[1];
                                    ((char *)dst)[3] = ((char *)src)[0];
                                }
#endif
                            } else {
                                FAST_INC_SETUP(src);
                                FAST_INC_SETUP(dst);
                                for(j=0;j<quad;j++)
                                {   
                                    FAST_INC_DEREF(dst) = FAST_INC_DEREF(src);
                                    FAST_INC_DEREF(dst) = FAST_INC_DEREF(src);
                                    FAST_INC_DEREF(dst) = FAST_INC_DEREF(src);
                                    FAST_INC_DEREF(dst) = FAST_INC_DEREF(src);
                                }
                                for(j=0;j<rem;j++)
                                {   
                                    FAST_INC_DEREF(dst) = FAST_INC_DEREF(src);
                                }
                            }
                            yidx+=yinc;
                        }
                    } else {
                        for(i=0;i<dstheight;i++)                
                        {
                            yidx_int = FixedToInt(yidx);
                            CLIP(yidx_int,ymin,ymax);           
                            src = (long *)(srcaddress + (yidx_int*srcrowstride));            
                            dst = (long *)(dstaddress + (i*dstrowstride));
                                        
                            xidx = xfudge;

                            //should only need clipping at boundaries
                            xidx_int = FixedToInt(xidx);
                            CLIP(xidx_int,xmin,xmax);           
                            *dst=*(src + xidx_int);             
                            xidx+=xinc;
                            
                            if (quickswap)
                                *dst = SWAP32(*dst);

                            dst++;

                            if (quickswap) {
                                long tmp;
                                for(j=2;j<dstwidth;j++)
                                {   
                                    tmp=*(src + FixedToInt(xidx));
                                    *dst++ = SWAP32(tmp);
                                    xidx+=xinc;
                                }
                            } else { 
                                for(j=2;j<dstwidth;j++)
                                {   
                                    *dst++=*(src + FixedToInt(xidx));
                                    xidx+=xinc;
                                }
                            }
                            if (dstwidth>1) {
                                xidx_int = FixedToInt(xidx);
                                CLIP(xidx_int,xmin,xmax);           
                                *dst=*(src + xidx_int);
                                if (quickswap)
                                    *dst = SWAP32(*dst);
                            }
                                                            
                            yidx+=yinc;
                        }
                    }
                } else {
                    uchar *src0,*src,*dst;
                    
                    for(i=0;i<dstheight;i++)                
                    {
                        yidx_int = FixedToInt(yidx);
                        CLIP(yidx_int,ymin,ymax);           
                        src0 = (uchar *)(srcaddress + (yidx_int*srcrowstride));            
                        dst = (uchar *)(dstaddress + (i*dstrowstride));
                                    
                        --dst;    
                        xidx = xfudge;
                               
                        for(j=0;j<dstwidth;j++)
                        {   
                            xidx_int = FixedToInt(xidx);
                            CLIP(xidx_int,xmin,xmax);           
                            src = src0 + (xidx_int*srccellstride);
                            *++dst=*(src+pmap0);            
                            *++dst=*(src+pmap1);            
                            *++dst=*(src+pmap2);            
                            *++dst=*(src+pmap3);            
                            xidx+=xinc;
                        }
                        yidx+=yinc;
                    }
                }
            }
        } else if (x->info.type==_jit_sym_long) {                                
            srccellstride  /= 4;
            
            if (flags&JIT_MATRIX_CONVERT_INTERP) {
                uchar *dst;
                long *src,*src2,*x0,*x1,*x2,*x3;
                long xidx_int,xidx_int2,yidx_int,yidx_int2;
                float c0,c1,c2,c3;
                float xfrak,yfrak,xfrak_inv,yfrak_inv;
                double xidx=0,xinc=0,yidx=0,yinc=0;
                
                xinc = dxinc;
                yinc = dyinc;

                for(i=0;i<dstheight;i++)                
                {
                    yidx_int = (long)yidx;
                    yidx_int2 = yidx_int+ydir;
                    CLIP(yidx_int2,ymin,ymax);
                    src = (long *)(srcaddress + (yidx_int * srcrowstride));    
                    src2 = (long *)(srcaddress + (yidx_int2 * srcrowstride)); //this should never be past the end            
                    dst = (uchar *)(dstaddress + (i * dstrowstride));
                    
                    --dst;    
                    xidx = 0;       
                    yfrak = yidx-((long)yidx);            
                    if (ydir<0) yfrak = -yfrak; //float frak is neg
                    yfrak_inv = 1-yfrak;
                    for(j=0;j<dstwidth;j++)
                    {   
                        xidx_int = (long)xidx;
                        xidx_int2 = xidx_int+xdir;
                        CLIP(xidx_int2,xmin,xmax);
                        xfrak = xidx-xidx_int;
                        if (xdir<0) xfrak = -xfrak; //float frak is neg
                        xfrak_inv = 1-xfrak;
                        xidx_int *= srccellstride;
                        xidx_int2 *= srccellstride;
                        x0 = src + xidx_int;
                        x1 = src + xidx_int2;
                        x2 = src2 + xidx_int;
                        x3 = src2 + xidx_int2;
                        c0 = xfrak_inv*yfrak_inv;
                        c1 = xfrak*yfrak_inv;
                        c2 = xfrak_inv*yfrak;
                        c3 = xfrak*yfrak;
                        *++dst=(uchar)((float)(*(x0+pmap0))*c0 + (float)(*(x1+pmap0))*c1 + (float)(*(x2+pmap0))*c2 + (float)(*(x3+pmap0))*c3); 
                        *++dst=(uchar)((float)(*(x0+pmap1))*c0 + (float)(*(x1+pmap1))*c1 + (float)(*(x2+pmap1))*c2 + (float)(*(x3+pmap1))*c3); 
                        *++dst=(uchar)((float)(*(x0+pmap2))*c0 + (float)(*(x1+pmap2))*c1 + (float)(*(x2+pmap2))*c2 + (float)(*(x3+pmap2))*c3); 
                        *++dst=(uchar)((float)(*(x0+pmap3))*c0 + (float)(*(x1+pmap3))*c1 + (float)(*(x2+pmap3))*c2 + (float)(*(x3+pmap3))*c3); 
                        xidx+=xinc;
                    }
                    yidx+=yinc;
                }       
            } else {
                uchar *dst;
                long *src0,*src;
                Fixed xidx=0,xinc=0,yidx=0,yinc=0;
                Fixed xfudge,yfudge;
                long xidx_int,yidx_int;
        
                xfudge = DoubleToFixed((xdir>=0)?JIT_MATRIX_FUDGE:1.-JIT_MATRIX_FUDGE);
                yfudge = DoubleToFixed((ydir>=0)?JIT_MATRIX_FUDGE:1.-JIT_MATRIX_FUDGE);
                        
                xinc = DoubleToFixed(dxinc);
                yinc = DoubleToFixed(dyinc);
                
                yidx = yfudge;
                            
                for(i=0;i<dstheight;i++)                
                {
                    yidx_int = FixedToInt(yidx);
                    CLIP(yidx_int,ymin,ymax);           
                    src0 = (long *)(srcaddress + (yidx_int*srcrowstride));            
                    dst = (uchar *)(dstaddress + (i*dstrowstride));
                                
                    --dst;    
                    xidx = xfudge;
                           
                    for(j=0;j<dstwidth;j++)
                    {   
                        xidx_int = FixedToInt(xidx);
                        CLIP(xidx_int,xmin,xmax);           
                        src = src0 + (xidx_int*srccellstride);
                        *++dst=(uchar)(*(src+pmap0));           
                        *++dst=(uchar)(*(src+pmap1));           
                        *++dst=(uchar)(*(src+pmap2));           
                        *++dst=(uchar)(*(src+pmap3));           
                        xidx+=xinc;
                    }
                    yidx+=yinc;
                }
            }
        } else if (x->info.type==_jit_sym_float32) { 
            srccellstride  /= 4;
            
            if (flags&JIT_MATRIX_CONVERT_INTERP) {
                uchar *dst;
                float *src,*src2,*x0,*x1,*x2,*x3;
                long xidx_int,xidx_int2,yidx_int,yidx_int2;
                float c0,c1,c2,c3;
                float xfrak,yfrak,xfrak_inv,yfrak_inv;
                double xidx=0,xinc=0,yidx=0,yinc=0;
                float tmp;

                xinc = dxinc;
                yinc = dyinc;
                
                for(i=0;i<dstheight;i++)                
                {
                    yidx_int = (long)yidx;
                    yidx_int2 = yidx_int+ydir;
                    CLIP(yidx_int2,ymin,ymax);
                    src = (float *)(srcaddress + (yidx_int * srcrowstride));    
                    src2 = (float *)(srcaddress + (yidx_int2 * srcrowstride)); //this should never be past the end            
                    dst = (uchar *)(dstaddress + (i * dstrowstride));
                    
                    --dst;    
                    xidx = 0;       
                    yfrak = yidx-((long)yidx);            
                    if (ydir<0) yfrak = -yfrak; //float frak is neg
                    yfrak_inv = 1-yfrak;
                    for(j=0;j<dstwidth;j++)
                    {   
                        xidx_int = (long)xidx;
                        xidx_int2 = xidx_int+xdir;
                        CLIP(xidx_int2,xmin,xmax);
                        xfrak = xidx-xidx_int;
                        if (xdir<0) xfrak = -xfrak; //float frak is neg
                        xfrak_inv = 1-xfrak;
                        xidx_int *= srccellstride;
                        xidx_int2 *= srccellstride;
                        x0 = src + xidx_int;
                        x1 = src + xidx_int2;
                        x2 = src2 + xidx_int;
                        x3 = src2 + xidx_int2;
                        c0 = xfrak_inv*yfrak_inv;
                        c1 = xfrak*yfrak_inv;
                        c2 = xfrak_inv*yfrak;
                        c3 = xfrak*yfrak;
                        
                        tmp = ((float)(*(x0+pmap0))*c0 + (float)(*(x1+pmap0))*c1 + (float)(*(x2+pmap0))*c2 + (float)(*(x3+pmap0))*c3); 
                        *++dst = FM_CONVFN_FLOATTOCHAR(tmp);
                        tmp = ((float)(*(x0+pmap1))*c0 + (float)(*(x1+pmap1))*c1 + (float)(*(x2+pmap1))*c2 + (float)(*(x3+pmap1))*c3); 
                        *++dst = FM_CONVFN_FLOATTOCHAR(tmp);
                        tmp = ((float)(*(x0+pmap2))*c0 + (float)(*(x1+pmap2))*c1 + (float)(*(x2+pmap2))*c2 + (float)(*(x3+pmap2))*c3); 
                        *++dst = FM_CONVFN_FLOATTOCHAR(tmp);
                        tmp = ((float)(*(x0+pmap3))*c0 + (float)(*(x1+pmap3))*c1 + (float)(*(x2+pmap3))*c2 + (float)(*(x3+pmap3))*c3); 
                        *++dst = FM_CONVFN_FLOATTOCHAR(tmp);
                        xidx+=xinc;
                    }
                    yidx+=yinc;
                }       
            } else {
                uchar *dst;
                float *src0,*src;
                Fixed xidx=0,xinc=0,yidx=0,yinc=0;
                Fixed xfudge,yfudge;
                long xidx_int,yidx_int;
                float tmp;

                xfudge = DoubleToFixed((xdir>=0)?JIT_MATRIX_FUDGE:1.-JIT_MATRIX_FUDGE);
                yfudge = DoubleToFixed((ydir>=0)?JIT_MATRIX_FUDGE:1.-JIT_MATRIX_FUDGE);
            
                xinc = DoubleToFixed(dxinc);
                yinc = DoubleToFixed(dyinc);

                yidx = yfudge;
                                
                for(i=0;i<dstheight;i++)                
                {
                    yidx_int = FixedToInt(yidx);
                    CLIP(yidx_int,ymin,ymax);           
                    src0 = (float *)(srcaddress + (yidx_int*srcrowstride));            
                    dst = (uchar *)(dstaddress + (i*dstrowstride));
                                
                    --dst;    
                    xidx = xfudge;
                           
                    for(j=0;j<dstwidth;j++)
                    {   
                        xidx_int = FixedToInt(xidx);
                        CLIP(xidx_int,xmin,xmax);           
                        src = src0 + (xidx_int*srccellstride);
                        tmp = *(src+pmap0);
                        *++dst = FM_CONVFN_FLOATTOCHAR(tmp);
                        tmp = *(src+pmap1);
                        *++dst = FM_CONVFN_FLOATTOCHAR(tmp);
                        tmp = *(src+pmap2);
                        *++dst = FM_CONVFN_FLOATTOCHAR(tmp);
                        tmp = *(src+pmap3);
                        *++dst = FM_CONVFN_FLOATTOCHAR(tmp);
                        xidx+=xinc;
                    }
                    yidx+=yinc;
                }
            }
        } else if (x->info.type==_jit_sym_float64) { 
            srccellstride  /= 8;
            
            if (flags&JIT_MATRIX_CONVERT_INTERP) {
                uchar *dst;
                double *src,*src2,*x0,*x1,*x2,*x3;
                long xidx_int,xidx_int2,yidx_int,yidx_int2;
                double c0,c1,c2,c3;
                double xfrak,yfrak,xfrak_inv,yfrak_inv;
                double xidx=0,xinc=0,yidx=0,yinc=0;
                double tmp;

                xinc = dxinc;
                yinc = dyinc;
                
                for(i=0;i<dstheight;i++)                
                {
                    yidx_int = (long)yidx;
                    yidx_int2 = yidx_int+ydir;
                    CLIP(yidx_int2,ymin,ymax);
                    src = (double *)(srcaddress + (yidx_int * srcrowstride));    
                    src2 = (double *)(srcaddress + (yidx_int2 * srcrowstride)); //this should never be past the end            
                    dst = (uchar *)(dstaddress + (i * dstrowstride));
                    
                    --dst;    
                    xidx = 0;       
                    yfrak = yidx-((long)yidx);            
                    if (ydir<0) yfrak = -yfrak; //float frak is neg
                    yfrak_inv = 1-yfrak;
                    for(j=0;j<dstwidth;j++)
                    {   
                        xidx_int = (long)xidx;
                        xidx_int2 = xidx_int+xdir;
                        CLIP(xidx_int2,xmin,xmax);
                        xfrak = xidx-xidx_int;
                        if (xdir<0) xfrak = -xfrak; //float frak is neg
                        xfrak_inv = 1-xfrak;
                        xidx_int *= 4;
                        xidx_int2 *= 4;
                        x0 = src + xidx_int;
                        x1 = src + xidx_int2;
                        x2 = src2 + xidx_int;
                        x3 = src2 + xidx_int2;
                        c0 = xfrak_inv*yfrak_inv;
                        c1 = xfrak*yfrak_inv;
                        c2 = xfrak_inv*yfrak;
                        c3 = xfrak*yfrak;
                        tmp = ((double)(*(x0+pmap0))*c0 + (double)(*(x1+pmap0))*c1 + (double)(*(x2+pmap0))*c2 + (double)(*(x3+pmap0))*c3); 
                        *++dst = FM_CONVFN_DOUBLETOCHAR(tmp);
                        tmp = ((double)(*(x0+pmap1))*c0 + (double)(*(x1+pmap1))*c1 + (double)(*(x2+pmap1))*c2 + (double)(*(x3+pmap1))*c3); 
                        *++dst = FM_CONVFN_DOUBLETOCHAR(tmp);
                        tmp = ((double)(*(x0+pmap2))*c0 + (double)(*(x1+pmap2))*c1 + (double)(*(x2+pmap2))*c2 + (double)(*(x3+pmap2))*c3); 
                        *++dst = FM_CONVFN_DOUBLETOCHAR(tmp);
                        tmp = ((double)(*(x0+pmap3))*c0 + (double)(*(x1+pmap3))*c1 + (double)(*(x2+pmap3))*c2 + (double)(*(x3+pmap3))*c3); 
                        *++dst = FM_CONVFN_DOUBLETOCHAR(tmp);
                        xidx+=xinc;
                    }
                    yidx+=yinc;
                }       
            } else {
                uchar *dst;
                double *src0,*src;
                Fixed xidx=0,xinc=0,yidx=0,yinc=0;
                Fixed xfudge,yfudge;
                long xidx_int,yidx_int;
                double tmp;

                xfudge = DoubleToFixed((xdir>=0)?JIT_MATRIX_FUDGE:1.-JIT_MATRIX_FUDGE);
                yfudge = DoubleToFixed((ydir>=0)?JIT_MATRIX_FUDGE:1.-JIT_MATRIX_FUDGE);
            
                xinc = DoubleToFixed(dxinc);
                yinc = DoubleToFixed(dyinc);
                
                yidx = yfudge;
                
                for(i=0;i<dstheight;i++)                
                {
                    yidx_int = FixedToInt(yidx);
                    CLIP(yidx_int,ymin,ymax);           
                    src0 = (double *)(srcaddress + (yidx_int*srcrowstride));            
                    dst = (uchar *)(dstaddress + (i*dstrowstride));
                                
                    --dst;    
                    xidx = xfudge;
                           
                    for(j=0;j<dstwidth;j++)
                    {   
                        xidx_int = FixedToInt(xidx);
                        CLIP(xidx_int,xmin,xmax);           
                        src = src0 + (xidx_int*srccellstride);
                        tmp = *(src+pmap0);
                        *++dst = FM_CONVFN_DOUBLETOCHAR(tmp);
                        tmp = *(src+pmap1);
                        *++dst = FM_CONVFN_DOUBLETOCHAR(tmp);
                        tmp = *(src+pmap2);
                        *++dst = FM_CONVFN_DOUBLETOCHAR(tmp);
                        tmp = *(src+pmap3);
                        *++dst = FM_CONVFN_DOUBLETOCHAR(tmp);
                        xidx+=xinc;
                    }
                    yidx+=yinc;
                }
            }
        }
        
        UnlockPixels(pmh); 
        jit_matrix_lock(x,savelock);
        return JIT_ERR_NONE;
    } else {
        return JIT_ERR_INVALID_PTR;
    }

pakka:
    return JIT_ERR_GENERIC; 
}

/**
 * Copies Jitter matrix data from GWorld data. 
 * 
 * @ingroup matrixmod
 *
 * @param   x       t_jit_matrix object pointer
 * @param   gp      gworld pointer
 * @param   gcinfo  conversion information 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_matrix.
 */
t_jit_err jit_matrix_fromgworld(t_jit_matrix *x, GWorldPtr gp, t_gworld_conv_info *gcinfo)
{
    long savelock,i,j;
    long srcheight,srcwidth,srcrowstride;
    long dstheight,dstwidth,dstcellstride,dstrowstride;
    uchar *srcaddress,*dstaddress;
    PixMapHandle pmh;
    long pmap0,pmap1,pmap2,pmap3;
    long flags=0,xdir,ydir;
    long xmin,xmax,ymin,ymax;
    double dxinc=0,dyinc=0;
    Rect r;
    long quickswap=FALSE;
    long widfactor;
    
    if (x&&gp) {    
        pmh = GetGWorldPixMap(gp);
        if (!pmh) { 
            goto pakka;
        }   
        LockPixels(pmh); 
        savelock = jit_matrix_lock(x,1);

        dstaddress = x->data;
        srcaddress = (uchar *)GetPixBaseAddr(pmh);
        if ((!srcaddress)||(!dstaddress)) { 
            UnlockPixels(pmh); 
            jit_matrix_lock(x,savelock);
            goto pakka;
        }
        dstwidth    = x->info.dim[0];
        dstheight   = x->info.dim[1];
        GetPortBounds(gp,&r);
        if ((**pmh).pixelSize == 16) // uyvy
            widfactor = 1L;
        else
            widfactor = 0L;
        srcwidth    = (r.right-r.left) >> widfactor;
        srcheight   = (r.bottom-r.top);                 
        dstcellstride   = x->info.dimstride[0];
        dstrowstride    = x->info.dimstride[1];
        srcrowstride    = GetPixRowBytes(pmh);
        
        if (gcinfo) {
            flags = gcinfo->flags;
            pmap0 = CLAMP(gcinfo->planemap[0] % x->info.planecount,0,3);
            pmap1 = CLAMP(gcinfo->planemap[1] % x->info.planecount,0,3);
            pmap2 = CLAMP(gcinfo->planemap[2] % x->info.planecount,0,3);
            pmap3 = CLAMP(gcinfo->planemap[3] % x->info.planecount,0,3);
            if (flags&JIT_MATRIX_CONVERT_DSTDIM) {
                if (gcinfo->dstrect.top<0) gcinfo->dstrect.top = 0;
                else if (gcinfo->dstrect.top>=dstheight) gcinfo->dstrect.top = dstheight-1;
                if (gcinfo->dstrect.bottom<0) gcinfo->dstrect.bottom = 0;
                else if (gcinfo->dstrect.bottom>=dstheight) gcinfo->dstrect.bottom = dstheight-1;
                if (gcinfo->dstrect.left<0) gcinfo->dstrect.left = 0;
                else if (gcinfo->dstrect.left>=dstwidth) gcinfo->dstrect.left = dstwidth-1;
                if (gcinfo->dstrect.right<0) gcinfo->dstrect.right = 0;
                else if (gcinfo->dstrect.right>=dstwidth) gcinfo->dstrect.right = dstwidth-1;
                dstheight = ABS(gcinfo->dstrect.bottom - gcinfo->dstrect.top) + 1;
                dstwidth  = ABS(gcinfo->dstrect.right  - gcinfo->dstrect.left) + 1;
                dstaddress += (dstcellstride*MIN(gcinfo->dstrect.left,gcinfo->dstrect.right)) + 
                    (dstrowstride*MIN(gcinfo->dstrect.top,gcinfo->dstrect.bottom));
            }
            if (flags&JIT_MATRIX_CONVERT_SRCDIM) {
                if (gcinfo->srcrect.top<0) gcinfo->srcrect.top = 0;
                else if (gcinfo->srcrect.top>=srcheight) gcinfo->srcrect.top = srcheight-1;
                if (gcinfo->srcrect.bottom<0) gcinfo->srcrect.bottom = 0;
                else if (gcinfo->srcrect.bottom>=srcheight) gcinfo->srcrect.bottom = srcheight-1;
                if (gcinfo->srcrect.left<0) gcinfo->srcrect.left = 0;
                else if (gcinfo->srcrect.left>=srcwidth) gcinfo->srcrect.left = srcwidth-1;
                if (gcinfo->srcrect.right<0) gcinfo->srcrect.right = 0;
                else if (gcinfo->srcrect.right>=srcwidth) gcinfo->srcrect.right = srcwidth-1;
                srcheight = gcinfo->srcrect.bottom - gcinfo->srcrect.top;
                srcwidth  = gcinfo->srcrect.right  - gcinfo->srcrect.left;
                if (srcheight>=0) srcheight++; else srcheight--;
                if (srcwidth>=0) srcwidth++; else srcwidth--;
                srcaddress += (4*gcinfo->srcrect.left) + (srcrowstride*gcinfo->srcrect.top);
            }
        } else {
            pmap0 = 0;
            pmap1 = 1 % x->info.planecount;
            pmap2 = 2 % x->info.planecount;
            pmap3 = 3 % x->info.planecount;
            
        }

        if ((x->info.planecount==4) &&
            (pmap0==3) &&
            (pmap1==2) &&
            (pmap2==1) &&
            (pmap3==0))
        {
            quickswap = TRUE;
        }

        //calculate scale factor
        if (gcinfo&&(gcinfo->flags&JIT_MATRIX_CONVERT_INTERP)) {
            if ((ABS(srcwidth)>1)&&(ABS(dstwidth)>1)) 
                dxinc = ((double)srcwidth-DIRECTION(srcwidth))/((double)dstwidth-1);
            if ((ABS(srcheight)>1)&&(ABS(dstheight)>1))
                dyinc = ((double)srcheight-DIRECTION(srcheight))/((double)dstheight-1);
        } else {
            if ((ABS(srcwidth)>1)&&(ABS(dstwidth)>1)) 
                dxinc = ((double)srcwidth)/((double)dstwidth);
            if ((ABS(srcheight)>1)&&(ABS(dstheight)>1))
                dyinc = ((double)srcheight)/((double)dstheight);
        }
        
        //compensate for potential FP error
        if (ABS(dxinc)<JIT_MATRIX_INC_THRESH) dxinc = 0;
        if (ABS(dyinc)<JIT_MATRIX_INC_THRESH) dyinc = 0;
        
        xdir = DIRECTION(dxinc);
        ydir = DIRECTION(dyinc);
        
        switch (xdir) 
        {
        case 1:     xmax = srcwidth-1; xmin = 0;    break;
        case -1:    xmin = srcwidth+1; xmax = 0;    break;
        default:    xmin = xmax = 0;                break;
        }
        switch (ydir) 
        {
        case 1:     ymax = srcheight-1; ymin = 0;   break;
        case -1:    ymin = srcheight+1; ymax = 0;   break;
        default:    ymin = ymax = 0;                break;
        }

        //xidx,yidx should be the top left of the src rect(clip to zero)
        //xinc,yinc should be the ratio of the source vs. destination rects
        if (x->info.type==_jit_sym_char) {
            Fixed xidx=0,xinc=0,yidx=0,yinc=0;
            Fixed xfudge,yfudge;
    
            xfudge = DoubleToFixed((xdir>=0)?JIT_MATRIX_FUDGE:1.-JIT_MATRIX_FUDGE);
            yfudge = DoubleToFixed((ydir>=0)?JIT_MATRIX_FUDGE:1.-JIT_MATRIX_FUDGE);

            xinc = DoubleToFixed(dxinc);
            yinc = DoubleToFixed(dyinc);
                        
            if (flags&JIT_MATRIX_CONVERT_INTERP) {
                uchar *src,*src2,*dst,*x0,*x1,*x2,*x3;
                long xidx_int,xidx_int2,yidx_int,yidx_int2;
                Fixed c0,c1,c2,c3;
                Fixed xfrak,yfrak,xfrak_inv,yfrak_inv;
                                            
                for(i=0;i<dstheight;i++)                
                {
                    yidx_int = FixedToInt(yidx);
                    yidx_int2 = yidx_int+ydir;
                    CLIP(yidx_int2,ymin,ymax);
                    src = (uchar *)(srcaddress + (yidx_int * srcrowstride));    
                    src2 = (uchar *)(srcaddress + (yidx_int2 * srcrowstride)); //this should never be past the end            
                    dst = (uchar *)(dstaddress + (i * dstrowstride));
                    
                    xidx = 0;                   
                    yfrak = FixedFraction(yidx);
                    if (ydir<0&&yfrak!=0) yfrak = fixed1-yfrak;  //FixedFraction() always positive
                    yfrak_inv = fixed1-yfrak;
                    for(j=0;j<dstwidth;j++)
                    {   
                        xidx_int = FixedToInt(xidx);
                        xidx_int2 = xidx_int+xdir;
                        CLIP(xidx_int2,xmin,xmax);
                        xidx_int *= 4;
                        xidx_int2 *= 4;
                        xfrak = FixedFraction(xidx);
                        if (xdir<0&&xfrak!=0) xfrak = fixed1-xfrak; //FixedFraction() always positive
                        xfrak_inv = fixed1-xfrak;
                        x0 = src + xidx_int;
                        x1 = src + xidx_int2;
                        x2 = src2 + xidx_int;
                        x3 = src2 + xidx_int2;
                        c0 = FixMul(xfrak_inv,yfrak_inv);
                        c1 = FixMul(xfrak,yfrak_inv);
                        c2 = FixMul(xfrak_inv,yfrak);
                        c3 = FixMul(xfrak,yfrak);
                        *(dst+pmap0)=(uchar)(((long)(*x0)*c0 + (long)(*x1)*c1 + (long)(*x2)*c2 + (long)(*x3)*c3)>>16L); 
                        *(dst+pmap1)=(uchar)(((long)(*++x0)*c0 + (long)(*++x1)*c1 + (long)(*++x2)*c2 + (long)(*++x3)*c3)>>16L); 
                        *(dst+pmap2)=(uchar)(((long)(*++x0)*c0 + (long)(*++x1)*c1 + (long)(*++x2)*c2 + (long)(*++x3)*c3)>>16L); 
                        *(dst+pmap3)=(uchar)(((long)(*++x0)*c0 + (long)(*++x1)*c1 + (long)(*++x2)*c2 + (long)(*++x3)*c3)>>16L); 
                        xidx+=xinc;
                        dst+=dstcellstride;
                    }
                    yidx+=yinc;
                }       
            
            } else {
                long xidx_int,yidx_int;
                
                yidx = yfudge;
                
                if ((x->info.planecount==4)&&(quickswap||((pmap0==0)&&(pmap1==1)&&(pmap2==2)&&(pmap3==3)))) {
                    long *src,*dst;
                    //optimized cases
                    if (xinc==fixed1) {
                        for(i=0;i<dstheight;i++)                
                        {
                            yidx_int = FixedToInt(yidx);
                            CLIP(yidx_int,ymin,ymax);           
                            src = (long *)(srcaddress + (yidx_int*srcrowstride));            
                            dst = (long *)(dstaddress + (i*dstrowstride));
                            
                            --dst;
                            --src;
                            if (quickswap) {
                                for(j=0;j<dstwidth;j++) {   
                                    FAST_INC(src);
                                    FAST_INC(dst);
                                    ((char *)dst)[0] = ((char *)src)[3];
                                    ((char *)dst)[1] = ((char *)src)[2];
                                    ((char *)dst)[2] = ((char *)src)[1];
                                    ((char *)dst)[3] = ((char *)src)[0];
                                }
                            } else {
                                for(j=0;j<dstwidth;j++)
                                {   
                                    *++dst=*++src;
                                }
                            }
                            yidx+=yinc;
                        }
                    } else {
                        for(i=0;i<dstheight;i++)                
                        {
                            yidx_int = FixedToInt(yidx);
                            CLIP(yidx_int,ymin,ymax);           
                            src = (long *)(srcaddress + (yidx_int*srcrowstride));            
                            dst = (long *)(dstaddress + (i*dstrowstride));
                                       
                            xidx = xfudge;
                                   
                            //should only need clipping at boundaries
                            xidx_int = FixedToInt(xidx);
                            CLIP(xidx_int,xmin,xmax);           
                            *dst=*(src + xidx_int);             
                            xidx+=xinc;
                            
                            if (quickswap)
                                *dst = SWAP32(*dst);
                            
                            dst++;

                            if (quickswap) {
                                long tmp;
                                for(j=2;j<dstwidth;j++)
                                {   
                                    tmp=*(src + FixedToInt(xidx));
                                    *dst++ = SWAP32(tmp);
                                    xidx+=xinc;
                                }
                            } else { 
                                for(j=2;j<dstwidth;j++)
                                {   
                                    *dst++=*(src + FixedToInt(xidx));
                                    xidx+=xinc;
                                }
                            }
                            if (dstwidth>1) {
                                xidx_int = FixedToInt(xidx);
                                CLIP(xidx_int,xmin,xmax);           
                                *dst=*(src + xidx_int);
                                if (quickswap)
                                    *dst = SWAP32(*dst);
                            }
                            
                            yidx+=yinc;
                        }
                    }
                } else {
                    uchar *src0,*src,*dst;
    
                    for(i=0;i<dstheight;i++)                
                    {
                        yidx_int = FixedToInt(yidx);
                        CLIP(yidx_int,ymin,ymax);           
                        src0 = (uchar *)(srcaddress + (yidx_int*srcrowstride));            
                        dst = (uchar *)(dstaddress + (i*dstrowstride));
                                    
                        xidx = xfudge;       
                        for(j=0;j<dstwidth;j++)
                        {   
                            xidx_int = FixedToInt(xidx);
                            CLIP(xidx_int,xmin,xmax);           
                            src = src0 + (xidx_int*4);
                            *(dst+pmap0)=*src;          
                            *(dst+pmap1)=*++src;            
                            *(dst+pmap2)=*++src;            
                            *(dst+pmap3)=*++src;            
                            xidx+=xinc;
                            dst+=dstcellstride;
                        }
                        yidx+=yinc;
                    }
                }
            }
        } else if (x->info.type==_jit_sym_long) {                                
            Fixed xidx=0,xinc=0,yidx=0,yinc=0;
            Fixed xfudge,yfudge;
    
            xfudge = DoubleToFixed((xdir>=0)?JIT_MATRIX_FUDGE:1.-JIT_MATRIX_FUDGE);
            yfudge = DoubleToFixed((ydir>=0)?JIT_MATRIX_FUDGE:1.-JIT_MATRIX_FUDGE);

            xinc = DoubleToFixed(dxinc);
            yinc = DoubleToFixed(dyinc);

            dstcellstride  /= 4;
            
            if (flags&JIT_MATRIX_CONVERT_INTERP) {
                uchar *src,*src2;
                long *dst,*x0,*x1,*x2,*x3;
                long xidx_int,xidx_int2,yidx_int,yidx_int2;
                Fixed c0,c1,c2,c3;
                Fixed xfrak,yfrak,xfrak_inv,yfrak_inv;
                
                for(i=0;i<dstheight;i++)                
                {
                    yidx_int = FixedToInt(yidx);
                    yidx_int2 = yidx_int+ydir;
                    CLIP(yidx_int2,ymin,ymax);
                    src = (uchar *)(srcaddress + (yidx_int * srcrowstride));    
                    src2 = (uchar *)(srcaddress + (yidx_int2 * srcrowstride)); //this should never be past the end            
                    dst = (long *)(dstaddress + (i * dstrowstride));
                 
                    xidx = 0;       
                    yfrak = FixedFraction(yidx);            
                    if (ydir<0&&yfrak!=0) yfrak = fixed1-yfrak;  //FixedFraction() always positive
                    yfrak_inv = fixed1-yfrak;
                    for(j=0;j<dstwidth;j++)
                    {   
                        xidx_int = FixedToInt(xidx);
                        xidx_int2 = xidx_int+xdir;
                        CLIP(xidx_int2,xmin,xmax);
                        xidx_int *= 4;
                        xidx_int2 *= 4;
                        xfrak = FixedFraction(xidx);
                        if (xdir<0&&xfrak!=0) xfrak = fixed1-xfrak; //FixedFraction() always positive
                        xfrak_inv = fixed1-xfrak;
                        x0 = (long *)(src + xidx_int);
                        x1 = (long *)(src + xidx_int2);
                        x2 = (long *)(src2 + xidx_int);
                        x3 = (long *)(src2 + xidx_int2);
                        c0 = FixMul(xfrak_inv,yfrak_inv);
                        c1 = FixMul(xfrak,yfrak_inv);
                        c2 = FixMul(xfrak_inv,yfrak);
                        c3 = FixMul(xfrak,yfrak);
                        *(dst+pmap0)=((long)(*x0)*c0 + (long)(*x1)*c1 + (long)(*x2)*c2 + (long)(*x3)*c3)>>16L; 
                        *(dst+pmap1)=((long)(*++x0)*c0 + (long)(*++x1)*c1 + (long)(*++x2)*c2 + (long)(*++x3)*c3)>>16L; 
                        *(dst+pmap2)=((long)(*++x0)*c0 + (long)(*++x1)*c1 + (long)(*++x2)*c2 + (long)(*++x3)*c3)>>16L; 
                        *(dst+pmap3)=((long)(*++x0)*c0 + (long)(*++x1)*c1 + (long)(*++x2)*c2 + (long)(*++x3)*c3)>>16L; 
                        xidx+=xinc;
                        dst+=dstcellstride;
                    }
                    yidx+=yinc;
                }       
            } else {
                long *dst;
                uchar *src0,*src;
                long xidx_int,yidx_int;
                
                yidx = yfudge;
                
                for(i=0;i<dstheight;i++)                
                {
                    yidx_int = FixedToInt(yidx);
                    CLIP(yidx_int,ymin,ymax);           
                    src0 = (uchar *)(srcaddress + (yidx_int*srcrowstride));            
                    dst = (long *)(dstaddress + (i*dstrowstride));
                                
                    xidx = xfudge;                         
                    for(j=0;j<dstwidth;j++)
                    {   
                        xidx_int = FixedToInt(xidx);
                        CLIP(xidx_int,xmin,xmax);           
                        src = src0 + (xidx_int*4);
                        *(dst+pmap0)=(long)(*src);          
                        *(dst+pmap1)=(long)(*++src);            
                        *(dst+pmap2)=(long)(*++src);            
                        *(dst+pmap3)=(long)(*++src);            
                        xidx+=xinc;
                        dst+=dstcellstride;
                    }
                    yidx+=yinc;
                }
            }
        } else if (x->info.type==_jit_sym_float32) { 
            dstcellstride  /= 4;
            
            if (flags&JIT_MATRIX_CONVERT_INTERP) {
                uchar *src,*src2;
                float *dst,*x0,*x1,*x2,*x3;
                long xidx_int,xidx_int2,yidx_int,yidx_int2;
                float c0,c1,c2,c3;
                float xfrak,yfrak,xfrak_inv,yfrak_inv;
                double xidx=0,xinc=0,yidx=0,yinc=0;

                xinc = dxinc;
                yinc = dyinc;
                            
                for(i=0;i<dstheight;i++)                
                {
                    yidx_int = (long)yidx;
                    yidx_int2 = yidx_int+ydir;
                    CLIP(yidx_int2,ymin,ymax);
                    src = (uchar *)(srcaddress + (yidx_int * srcrowstride));    
                    src2 = (uchar *)(srcaddress + (yidx_int2 * srcrowstride)); //this should never be past the end            
                    dst = (float *)(dstaddress + (i * dstrowstride));
                    
                    xidx = 0;       
                    yfrak = yidx-((long)yidx);            
                    if (ydir<0) yfrak = -yfrak; //float frak is neg
                    yfrak_inv = 1-yfrak;
                    for(j=0;j<dstwidth;j++)
                    {   
                        xidx_int = (long)xidx;
                        xidx_int2 = xidx_int+xdir;
                        CLIP(xidx_int2,xmin,xmax);
                        xfrak = xidx-xidx_int;
                        if (xdir<0) xfrak = -xfrak; //float frak is neg
                        xfrak_inv = 1-xfrak;
                        xidx_int *= 4;
                        xidx_int2 *= 4;
                        x0 = (float *)(src + xidx_int);
                        x1 = (float *)(src + xidx_int2);
                        x2 = (float *)(src2 + xidx_int);
                        x3 = (float *)(src2 + xidx_int2);
                        c0 = xfrak_inv*yfrak_inv;
                        c1 = xfrak*yfrak_inv;
                        c2 = xfrak_inv*yfrak;
                        c3 = xfrak*yfrak;
                        *(dst+pmap0)=((float)(*(x0))*c0 + (float)(*(x1))*c1 + (float)(*(x2))*c2 + (float)(*(x3))*c3)*(1./255.); 
                        *(dst+pmap1)=((float)(*(++x0))*c0 + (float)(*(++x1))*c1 + (float)(*(++x2))*c2 + (float)(*(++x3))*c3)*(1./255.); 
                        *(dst+pmap2)=((float)(*(++x0))*c0 + (float)(*(++x1))*c1 + (float)(*(++x2))*c2 + (float)(*(++x3))*c3)*(1./255.); 
                        *(dst+pmap3)=((float)(*(++x0))*c0 + (float)(*(++x1))*c1 + (float)(*(++x2))*c2 + (float)(*(++x3))*c3)*(1./255.); 
                        xidx+=xinc;
                        dst+=dstcellstride;
                    }
                    yidx+=yinc;
                }       
            } else {
                float *dst;
                uchar *src0,*src;
                Fixed xidx=0,xinc=0,yidx=0,yinc=0;
                Fixed xfudge,yfudge;
                long xidx_int,yidx_int;
        
                xfudge = DoubleToFixed((xdir>=0)?JIT_MATRIX_FUDGE:1.-JIT_MATRIX_FUDGE);
                yfudge = DoubleToFixed((ydir>=0)?JIT_MATRIX_FUDGE:1.-JIT_MATRIX_FUDGE);

                xinc = DoubleToFixed(dxinc);
                yinc = DoubleToFixed(dyinc);
                
                yidx = yfudge;
                            
                for(i=0;i<dstheight;i++)                
                {
                    yidx_int = FixedToInt(yidx);
                    CLIP(yidx_int,ymin,ymax);           
                    src0 = (uchar *)(srcaddress + (yidx_int*srcrowstride));            
                    dst = (float *)(dstaddress + (i*dstrowstride));
                              
                    xidx = xfudge;
                    for(j=0;j<dstwidth;j++)
                    {   
                        xidx_int = FixedToInt(xidx);
                        CLIP(xidx_int,xmin,xmax);           
                        src = src0 + (xidx_int*4);
                        *(dst+pmap0)=(float)(*src)*(1./255.);           
                        *(dst+pmap1)=(float)(*++src)*(1./255.);             
                        *(dst+pmap2)=(float)(*++src)*(1./255.);             
                        *(dst+pmap3)=(float)(*++src)*(1./255.);             
                        xidx+=xinc;
                        dst+=dstcellstride;
                    }
                    yidx+=yinc;
                }
            }
        } else if (x->info.type==_jit_sym_float64) { 
            dstcellstride  /= 8;
            
            if (flags&JIT_MATRIX_CONVERT_INTERP) {
                uchar *src,*src2;
                double *dst,*x0,*x1,*x2,*x3;
                long xidx_int,xidx_int2,yidx_int,yidx_int2;
                double c0,c1,c2,c3;
                double xfrak,yfrak,xfrak_inv,yfrak_inv;
                double xidx=0,xinc=0,yidx=0,yinc=0;
                
                xinc = dxinc;
                yinc = dyinc;
                                
                for(i=0;i<dstheight;i++)                
                {
                    yidx_int = (long)yidx;
                    yidx_int2 = yidx_int+ydir;
                    CLIP(yidx_int2,ymin,ymax);
                    src = (uchar *)(srcaddress + (yidx_int * srcrowstride));    
                    src2 = (uchar *)(srcaddress + (yidx_int2 * srcrowstride)); //this should never be past the end            
                    dst = (double *)(dstaddress + (i * dstrowstride));

                    xidx = 0;       
                    yfrak = yidx-((long)yidx);            
                    if (ydir<0) yfrak = -yfrak; //float frak is neg
                    yfrak_inv = 1-yfrak;
                    for(j=0;j<dstwidth;j++)
                    {   
                        xidx_int = (long)xidx;
                        xidx_int2 = xidx_int+xdir;
                        CLIP(xidx_int2,xmin,xmax);
                        xfrak = xidx-xidx_int;
                        if (xdir<0) xfrak = -xfrak; //float frak is neg
                        xfrak_inv = 1-xfrak;
                        xidx_int *= 4;
                        xidx_int2 *= 4;
                        x0 = (double *)(src + xidx_int);
                        x1 = (double *)(src + xidx_int2);
                        x2 = (double *)(src2 + xidx_int);
                        x3 = (double *)(src2 + xidx_int2);
                        c0 = xfrak_inv*yfrak_inv;
                        c1 = xfrak*yfrak_inv;
                        c2 = xfrak_inv*yfrak;
                        c3 = xfrak*yfrak;
                        *(dst+pmap0)=((double)(*(x0))*c0 + (double)(*(x1))*c1 + (double)(*(x2))*c2 + (double)(*(x3))*c3)*(1./255.); 
                        *(dst+pmap1)=((double)(*(++x0))*c0 + (double)(*(++x1))*c1 + (double)(*(++x2))*c2 + (double)(*(++x3))*c3)*(1./255.); 
                        *(dst+pmap2)=((double)(*(++x0))*c0 + (double)(*(++x1))*c1 + (double)(*(++x2))*c2 + (double)(*(++x3))*c3)*(1./255.); 
                        *(dst+pmap3)=((double)(*(++x0))*c0 + (double)(*(++x1))*c1 + (double)(*(++x2))*c2 + (double)(*(++x3))*c3)*(1./255.); 
                        xidx+=xinc;
                        dst+=dstcellstride;
                    }
                    yidx+=yinc;
                }       
            } else {
                double *dst;
                uchar *src0,*src;
                Fixed xidx=0,xinc=0,yidx=0,yinc=0;
                Fixed xfudge,yfudge;
                long xidx_int,yidx_int;
        
                xfudge = DoubleToFixed((xdir>=0)?JIT_MATRIX_FUDGE:1.-JIT_MATRIX_FUDGE);
                yfudge = DoubleToFixed((ydir>=0)?JIT_MATRIX_FUDGE:1.-JIT_MATRIX_FUDGE);

                xinc = DoubleToFixed(dxinc);
                yinc = DoubleToFixed(dyinc);
                
                yidx = yfudge;
                
                for(i=0;i<dstheight;i++)                
                {
                    yidx_int = FixedToInt(yidx);
                    CLIP(yidx_int,ymin,ymax);           
                    src0 = (uchar *)(srcaddress + (yidx_int*srcrowstride));            
                    dst = (double *)(dstaddress + (i*dstrowstride));
                                
                    xidx = xfudge;
                    for(j=0;j<dstwidth;j++)
                    {   
                        xidx_int = FixedToInt(xidx);
                        CLIP(xidx_int,xmin,xmax);           
                        src = src0 + (xidx_int*4);
                        *(dst+pmap0)=(double)(*src)*(1./255.);          
                        *(dst+pmap1)=(double)(*++src)*(1./255.);            
                        *(dst+pmap2)=(double)(*++src)*(1./255.);            
                        *(dst+pmap3)=(double)(*++src)*(1./255.);            
                        xidx+=xinc;
                        dst+=dstcellstride;
                    }
                    yidx+=yinc;
                }
            }
        }
        
        UnlockPixels(pmh); 
        jit_matrix_lock(x,savelock);
        return JIT_ERR_NONE;
    } else {
        return JIT_ERR_INVALID_PTR;
    }

pakka:
    return JIT_ERR_GENERIC; 
}

/**
 * Copies Jitter matrix data from another matrix. 
 * 
 * @ingroup matrixmod
 *
 * @param   dst_matrix  destination t_jit_matrix object pointer
 * @param   src_matrix  destination t_jit_matrix object pointer
 * @param   mcinfo      conversion information 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_matrix.
 */
t_jit_err jit_matrix_frommatrix(t_jit_matrix *dst_matrix, t_jit_matrix *src_matrix, t_matrix_conv_info *mcinfo)
{
    t_jit_matrix_info dst_minfo,src_minfo;
    long dimsize[JIT_MATRIX_MAX_DIMCOUNT];
    long i,dst_savelock,src_savelock;
    char *dst_data=NULL,*src_data=NULL;
    t_jit_err err=JIT_ERR_GENERIC;
    long dimcount;

    if (dst_matrix&&src_matrix) {
        dst_savelock = (long)jit_object_method(dst_matrix,_jit_sym_lock,1);
        src_savelock = (long)jit_object_method(src_matrix,_jit_sym_lock,1);
        jit_object_method(dst_matrix,_jit_sym_getinfo,&dst_minfo);
        jit_object_method(src_matrix,_jit_sym_getinfo,&src_minfo);
        jit_object_method(dst_matrix,_jit_sym_getdata,&dst_data);
        jit_object_method(src_matrix,_jit_sym_getdata,&src_data);
        if (!dst_data) goto out;
        if (!src_data) goto out;
        if (mcinfo) { //make sure these values are in bounds
            if (mcinfo->flags&JIT_MATRIX_CONVERT_DSTDIM) {
                for (i=0;i<JIT_MATRIX_MAX_DIMCOUNT;i++) {
                    if (mcinfo->dstdimstart[i]<0) mcinfo->dstdimstart[i] = 0;
                    else if (mcinfo->dstdimstart[i]>=dst_minfo.dim[i]) mcinfo->dstdimstart[i] = dst_minfo.dim[i]-1;
                    if (mcinfo->dstdimend[i]<0) mcinfo->dstdimend[i] = 0;
                    else if (mcinfo->dstdimend[i]>=dst_minfo.dim[i]) mcinfo->dstdimend[i] = dst_minfo.dim[i]-1;
                }
            }
            if (mcinfo->flags&JIT_MATRIX_CONVERT_SRCDIM) {
                for (i=0;i<JIT_MATRIX_MAX_DIMCOUNT;i++) {
                    if (mcinfo->srcdimstart[i]<0) mcinfo->srcdimstart[i] = 0;
                    else if (mcinfo->srcdimstart[i]>=src_minfo.dim[i]) mcinfo->srcdimstart[i] = src_minfo.dim[i]-1;
                    if (mcinfo->srcdimend[i]<0) mcinfo->srcdimend[i] = 0;
                    else if (mcinfo->srcdimend[i]>=src_minfo.dim[i]) mcinfo->srcdimend[i] = src_minfo.dim[i]-1;
                }
            }
        }
        if (jit_matrix_canfastcopy(mcinfo, &dst_minfo, &src_minfo)) {
            jit_matrix_fastcopy(dst_minfo.size, dst_data, src_data);
        } else {
            dimcount = MAX(dst_minfo.dimcount,src_minfo.dimcount);
            jit_matrix_frommatrix_calculate_ndim(dimcount, mcinfo, &dst_minfo, dst_data, 
                &src_minfo, src_data);
        }
        jit_object_method(src_matrix,_jit_sym_lock,src_savelock);
        jit_object_method(dst_matrix,_jit_sym_lock,dst_savelock);
        return JIT_ERR_NONE;    
    } else {
        return JIT_ERR_INVALID_PTR;
    }
out: 
    return err;
}

t_jit_err jit_matrix_frommatrix_trunc(t_jit_matrix *dst_matrix, t_jit_matrix *src_matrix)
{
    t_jit_matrix_info dst_minfo,src_minfo;
    t_matrix_conv_info mcinfo;
    long i;
    
    if (dst_matrix&&src_matrix) {
        //no need to lock since we are only grabbing info structs, not data pointer
        jit_object_method(dst_matrix,_jit_sym_getinfo,&dst_minfo);
        jit_object_method(src_matrix,_jit_sym_getinfo,&src_minfo);

        mcinfo.flags = JIT_MATRIX_CONVERT_DSTDIM | JIT_MATRIX_CONVERT_SRCDIM;
        
        for (i=0;i<JIT_MATRIX_MAX_DIMCOUNT;i++) {
            mcinfo.srcdimstart[i] = mcinfo.dstdimstart[i] = 0;
            mcinfo.srcdimend[i] = mcinfo.dstdimend[i] = 0;
        }
        
        for (i=0;i<JIT_MATRIX_MAX_PLANECOUNT;i++) {
            mcinfo.planemap[i] = i;
        }
        
        //use minimum dimensions for both srcrect + dstrect
        for (i=0;i<dst_minfo.dimcount;i++) {
            mcinfo.srcdimend[i] = mcinfo.dstdimend[i] = MIN(src_minfo.dim[i],src_minfo.dim[i])-1;
        }
        
        return (t_jit_err) jit_object_method(dst_matrix,_jit_sym_frommatrix,src_matrix,&mcinfo);    
    } else {
        return JIT_ERR_INVALID_PTR;
    }
    return JIT_ERR_GENERIC;
}

void jit_matrix_frommatrix_calculate_ndim(long dim, t_matrix_conv_info *mcinfo, t_jit_matrix_info *dst_minfo, char *dst_bp, 
    t_jit_matrix_info *src_minfo, char *src_bp)
{
    long i,j,typesize;
    long dst_dimsize,src_dimsize;
    char *dst_p,*src_p;
    double src_inc;
        
    if (dim<1) return; //safety
    
    switch(dim) {
    case 1:
        //do we need to do anything special here?
        dst_minfo->dim[1] = 1;
    case 2:
        if (dst_minfo->type==_jit_sym_char)
            jit_matrix_frommatrix_2d_char(mcinfo,dst_minfo,dst_bp,src_minfo,src_bp);
        else if (dst_minfo->type==_jit_sym_long)
            jit_matrix_frommatrix_2d_long(mcinfo,dst_minfo,dst_bp,src_minfo,src_bp);
        else if (dst_minfo->type==_jit_sym_float32)
            jit_matrix_frommatrix_2d_float32(mcinfo,dst_minfo,dst_bp,src_minfo,src_bp);
        else if (dst_minfo->type==_jit_sym_float64)
            jit_matrix_frommatrix_2d_float64(mcinfo,dst_minfo,dst_bp,src_minfo,src_bp);     
        break;
    default:
        i = dim-1;
        dst_dimsize = dst_minfo->dim[i];
        src_dimsize = src_minfo->dim[i];
        if (mcinfo) {
            //start/end points for this dimension
            if (mcinfo->flags&JIT_MATRIX_CONVERT_DSTDIM) {
                dst_dimsize = ABS(mcinfo->dstdimend[i] - mcinfo->dstdimstart[i]) + 1;
                dst_bp += (dst_minfo->dimstride[i]*MIN(mcinfo->dstdimstart[i],mcinfo->dstdimend[i]));
            }
            if (mcinfo->flags&JIT_MATRIX_CONVERT_SRCDIM) {
                src_dimsize = (mcinfo->srcdimend[i] - mcinfo->srcdimstart[i]);
                if (src_dimsize>=0) src_dimsize++; else src_dimsize--;
                src_bp += (src_minfo->dimstride[i]*mcinfo->srcdimstart[i]);
            }
        }
        if (src_dimsize&&dst_dimsize) 
            src_inc = ((double)src_dimsize)/((double)dst_dimsize);
        else 
            src_inc = 0;
        //no interpolation for dimensions > 2.              
        for (j=0;j<dst_dimsize;j++) {
            dst_p = dst_bp + j * dst_minfo->dimstride[i];
            src_p = src_bp + (long)((double)j*src_inc) * src_minfo->dimstride[i];
            jit_matrix_frommatrix_calculate_ndim(dim-1,mcinfo,dst_minfo,dst_p,src_minfo,src_p);
        }
    }
}

long jit_matrix_info_typesize(t_jit_matrix_info *minfo) 
{
    if (minfo->type==_jit_sym_char) return 1;
    if (minfo->type==_jit_sym_float64) return 8;
    else return 4;
}

void jit_matrix_frommatrix_2d_char(t_matrix_conv_info *mcinfo, t_jit_matrix_info *dst_minfo, char *dst_bp, 
    t_jit_matrix_info *src_minfo, char *src_bp) 
{   
    long quickswap = FALSE; 
    FM_PREAMBLE();
    
    if ((planecount==4) && (src_minfo->planecount==4) &&
        (planemap[0]==3) &&
        (planemap[1]==2) &&
        (planemap[2]==1) &&
        (planemap[3]==0) &&
        (dst_cellstride==4) &&
        (src_cellstride==4))
    {
        quickswap = TRUE;
    }
    
    if (src_minfo->type==_jit_sym_char) {                                    
        if (bigmatrix||interp) 
        {
            if (unity) {
                FM_COPY_UNITY_ALL(uchar,uchar,FM_CONVFN_CHAR);
            } else if (interp) {
                if (bigmatrix) {
                    FM_COPY_INTERP_ALL_DOUBLE(uchar,uchar,FM_MULFN_DOUBLE,FM_CONVFN_CHAR);
                } else {
                    FM_COPY_INTERP_ALL_FIXED(uchar,uchar,FM_MULFN_LONG,FM_CONVFN_CHARFIXTOCHAR);            
                }
            } else {
                if (bigmatrix) {
                    FM_COPY_ALL_DOUBLE(uchar,uchar,FM_CONVFN_CHAR);
                } else {
                    FM_COPY_ALL_FIXED(uchar,uchar,FM_CONVFN_CHAR);          
                }
            }
        } else { //leaving optimized cases for char for the time being, could revisit
            Fixed xidx=0,xinc=0,yidx=0,yinc=0;
            Fixed xfudge,yfudge;
            
            xfudge = DoubleToFixed((xdir>=0)?JIT_MATRIX_FUDGE:1.-JIT_MATRIX_FUDGE);
            yfudge = DoubleToFixed((ydir>=0)?JIT_MATRIX_FUDGE:1.-JIT_MATRIX_FUDGE);
            
            xinc = DoubleToFixed(dxinc);
            yinc = DoubleToFixed(dyinc);
            
            yidx = yfudge;
            
            if (quickswap||((planecount==4)&&(src_minfo->planecount==4)&&
                (planemap[0]==0)&&(planemap[1]==1)&&(planemap[2]==2)&&(planemap[3]==3))) 
            { 
                long *src,*dst,tmp;
                long xidx_int,yidx_int;
                long quad=dst_width/4;
                long rem=dst_width%4;
                                
                if ((dst_cellstride==4)&&(src_cellstride==4)) {
                    //optimized cases
                    if (xinc==fixed1) {
                        for(i=0;i<dst_height;i++) {
                            yidx_int = FixedToInt(yidx);
                            CLIP(yidx_int,ymin,ymax);
                            src = (long *)(src_bp + (yidx_int*src_rowstride));            
                            dst = (long *)(dst_bp + (i*dst_rowstride));                

                            if (quickswap) {
#ifdef JIT_LITTLE_ENDIAN
                                for(j=0;j<quad;j++) {   
                                    __asm {
                                        // load pointers
                                        MOV esi,ASM_DWORD_PTR src
                                        MOV edi,ASM_DWORD_PTR dst
                                        // move + swap one 32bit word, increment ptrs
                                        MOV eax,[esi]
                                        BSWAP eax
                                        MOV [edi],eax
                                        ADD esi,4
                                        ADD edi,4
                                        // move + swap one 32bit word, increment ptrs
                                        MOV eax,[esi]
                                        BSWAP eax
                                        MOV [edi],eax
                                        ADD esi,4
                                        ADD edi,4
                                        // move + swap one 32bit word, increment ptrs
                                        MOV eax,[esi]
                                        BSWAP eax
                                        MOV [edi],eax
                                        ADD esi,4
                                        ADD edi,4
                                        // move + swap one 32bit word, increment ptrs
                                        MOV eax,[esi]
                                        BSWAP eax
                                        MOV [edi],eax
                                        ADD esi,4
                                        ADD edi,4
                                        // write pointers
                                        MOV ASM_DWORD_PTR src,esi
                                        MOV ASM_DWORD_PTR dst,edi
                                    }
                                }

                                for(j=0;j<rem;j++) {    
                                    __asm {
                                        // load pointers
                                        MOV esi,ASM_DWORD_PTR src
                                        MOV edi,ASM_DWORD_PTR dst
                                        // move + swap one 32bit word, increment ptrs
                                        MOV eax,[esi]
                                        BSWAP eax
                                        MOV [edi],eax
                                        ADD esi,4
                                        ADD edi,4
                                        // write pointers
                                        MOV ASM_DWORD_PTR src,esi
                                        MOV ASM_DWORD_PTR dst,edi
                                    }
                                }
#else
                                --dst;    
                                --src;
                                for(j=0;j<quad;j++) {   
                                    FAST_INC(src);
                                    FAST_INC(dst);
                                    ((char *)dst)[0] = ((char *)src)[3];
                                    ((char *)dst)[1] = ((char *)src)[2];
                                    ((char *)dst)[2] = ((char *)src)[1];
                                    ((char *)dst)[3] = ((char *)src)[0];
                                    FAST_INC(src);
                                    FAST_INC(dst);
                                    ((char *)dst)[0] = ((char *)src)[3];
                                    ((char *)dst)[1] = ((char *)src)[2];
                                    ((char *)dst)[2] = ((char *)src)[1];
                                    ((char *)dst)[3] = ((char *)src)[0];
                                    FAST_INC(src);
                                    FAST_INC(dst);
                                    ((char *)dst)[0] = ((char *)src)[3];
                                    ((char *)dst)[1] = ((char *)src)[2];
                                    ((char *)dst)[2] = ((char *)src)[1];
                                    ((char *)dst)[3] = ((char *)src)[0];
                                    FAST_INC(src);
                                    FAST_INC(dst);
                                    ((char *)dst)[0] = ((char *)src)[3];
                                    ((char *)dst)[1] = ((char *)src)[2];
                                    ((char *)dst)[2] = ((char *)src)[1];
                                    ((char *)dst)[3] = ((char *)src)[0];
                                }
                                for(j=0;j<rem;j++) {    
                                    FAST_INC(src);
                                    FAST_INC(dst);
                                    ((char *)dst)[0] = ((char *)src)[3];
                                    ((char *)dst)[1] = ((char *)src)[2];
                                    ((char *)dst)[2] = ((char *)src)[1];
                                    ((char *)dst)[3] = ((char *)src)[0];
                                }
#endif
                            } else {
                                FAST_INC_SETUP(src);
                                FAST_INC_SETUP(dst);
                                for(j=0;j<quad;j++) {   
                                    FAST_INC_DEREF(dst)=FAST_INC_DEREF(src);
                                    FAST_INC_DEREF(dst)=FAST_INC_DEREF(src);
                                    FAST_INC_DEREF(dst)=FAST_INC_DEREF(src);
                                    FAST_INC_DEREF(dst)=FAST_INC_DEREF(src);
                                }
                                for(j=0;j<rem;j++) {    
                                    FAST_INC_DEREF(dst)=FAST_INC_DEREF(src);
                                }
                            }
                            yidx+=yinc;
                        }
                    } else {
                        for(i=0;i<dst_height;i++) {
                            yidx_int = FixedToInt(yidx);
                            CLIP(yidx_int,ymin,ymax);
                            src = (long *)(src_bp + (yidx_int*src_rowstride));            
                            dst = (long *)(dst_bp + (i*dst_rowstride));
                            
                            xidx = xfudge;

                            //should only need clipping at boundaries
                            xidx_int = FixedToInt(xidx);
                            CLIP(xidx_int,xmin,xmax);           
                            *dst=*(src + xidx_int);             
                            xidx+=xinc;

                            if (quickswap)
                                *dst = SWAP32(*dst);
                            
                            dst++;

                            if (quickswap) {
                                long tmp;
                                for(j=2;j<dst_width;j++)
                                {   
                                    tmp=*(src + FixedToInt(xidx));
                                    *dst++ = SWAP32(tmp);
                                    xidx+=xinc;
                                }
                            } else { 
                                for(j=2;j<dst_width;j++)
                                {   
                                    *dst++=*(src + FixedToInt(xidx));
                                    xidx+=xinc;
                                }
                            }

                            if (dst_width>1) {
                                xidx_int = FixedToInt(xidx);
                                CLIP(xidx_int,xmin,xmax);           
                                *dst=*(src + xidx_int);             
                                if (quickswap)
                                    *dst = SWAP32(*dst);
                            }
                                
                            yidx+=yinc;
                        }
                    }
                } else {
                    dst_cellstride/=4;
                    src_cellstride/=4;
                    if (xinc==fixed1) {
                        for(i=0;i<dst_height;i++) {
                            yidx_int = FixedToInt(yidx);
                            CLIP(yidx_int,ymin,ymax);
                            src = (long *)(src_bp + (yidx_int*src_rowstride));            
                            dst = (long *)(dst_bp + (i*dst_rowstride));                
                            for(j=0;j<dst_width;j++) {  
                                *dst=*src;
                                dst+=dst_cellstride;
                                src+=src_cellstride;
                            }
                            yidx+=yinc;
                        }
                    } else {
                        for(i=0;i<dst_height;i++) {
                            yidx_int = FixedToInt(yidx);
                            CLIP(yidx_int,ymin,ymax);
                            src = (long *)(src_bp + (yidx_int*src_rowstride));            
                            dst = (long *)(dst_bp + (i*dst_rowstride));
                            xidx = xfudge;
                            for(j=0;j<dst_width;j++) {
                                xidx_int = FixedToInt(xidx);
                                CLIP(xidx_int,xmin,xmax);
                                *dst=*(src + xidx_int*src_cellstride);
                                dst+=dst_cellstride;
                                xidx+=xinc;
                            }
                            yidx+=yinc;
                        }
                    }
                }
            } else {
                if (unity) {
                    FM_COPY_UNITY_ALL(uchar,uchar,FM_CONVFN_CHAR);
                } else {
                    FM_COPY_ALL_FIXED(uchar,uchar,FM_CONVFN_CHAR);          
                }
            }
        }
    } else if (src_minfo->type==_jit_sym_long) {                                 
        if (unity) {
            FM_COPY_UNITY_ALL(long,uchar,FM_CONVFN_CHAR);
        } else if (interp) {
            FM_COPY_INTERP_ALL_DOUBLE(long,uchar,FM_MULFN_DOUBLE,FM_CONVFN_LONGTOCHAR);
        } else {
            if (bigmatrix) {
                FM_COPY_ALL_DOUBLE(long,uchar,FM_CONVFN_LONGTOCHAR);
            } else {
                FM_COPY_ALL_FIXED(long,uchar,FM_CONVFN_LONGTOCHAR);         
            }
        }
    } else if (src_minfo->type==_jit_sym_float32) { 
        if (unity) {
            FM_COPY_UNITY_ALL(float,uchar,FM_CONVFN_FLOATTOCHAR);
        } else if (interp) {
            FM_COPY_INTERP_ALL_DOUBLE(float,uchar,FM_MULFN_DOUBLE,FM_CONVFN_FLOATTOCHAR);
        } else {
            if (bigmatrix) {
                FM_COPY_ALL_DOUBLE(float,uchar,FM_CONVFN_FLOATTOCHAR);
            } else {
                FM_COPY_ALL_FIXED(float,uchar,FM_CONVFN_FLOATTOCHAR);           
            }
        }
    } else if (src_minfo->type==_jit_sym_float64) { 
        if (unity) {
            FM_COPY_UNITY_ALL(double,uchar,FM_CONVFN_DOUBLETOCHAR);
        } else if (interp) {
            FM_COPY_INTERP_ALL_DOUBLE(double,uchar,FM_MULFN_DOUBLE,FM_CONVFN_DOUBLETOCHAR);
        } else {
            if (bigmatrix) {
                FM_COPY_ALL_DOUBLE(double,uchar,FM_CONVFN_DOUBLETOCHAR);
            } else {
                FM_COPY_ALL_FIXED(double,uchar,FM_CONVFN_DOUBLETOCHAR);         
            }
        }
    }
}

void jit_matrix_frommatrix_2d_long(t_matrix_conv_info *mcinfo, t_jit_matrix_info *dst_minfo, char *dst_bp, 
    t_jit_matrix_info *src_minfo, char *src_bp) 
{   
    FM_PREAMBLE();
    
    if (src_minfo->type==_jit_sym_char) {
        if (unity) {
            FM_COPY_UNITY_ALL(uchar,long,FM_CONVFN_LONG);
        } else if (interp) {
            if (bigmatrix) {
                FM_COPY_INTERP_ALL_DOUBLE(uchar,long,FM_MULFN_DOUBLE,FM_CONVFN_LONG);
            } else {
                FM_COPY_INTERP_ALL_FIXED(uchar,long,FM_MULFN_LONG,FM_CONVFN_CHARFIXTOLONG);         
            }
        } else {
            if (bigmatrix) {
                FM_COPY_ALL_DOUBLE(uchar,long,FM_CONVFN_LONG);
            } else {
                FM_COPY_ALL_FIXED(uchar,long,FM_CONVFN_LONG);           
            }
        }
    } else if (src_minfo->type==_jit_sym_long) {                                 
        if (unity) {
            FM_COPY_UNITY_ALL(long,long,FM_CONVFN_LONG);
        } else if (interp) {
            FM_COPY_INTERP_ALL_DOUBLE(long,long,FM_MULFN_DOUBLE,FM_CONVFN_LONG);
        } else {
            if (bigmatrix) {
                FM_COPY_ALL_DOUBLE(long,long,FM_CONVFN_LONG);
            } else {
                FM_COPY_ALL_FIXED(long,long,FM_CONVFN_LONG);            
            }
        }
    } else if (src_minfo->type==_jit_sym_float32) { 
        if (unity) {
            FM_COPY_UNITY_ALL(float,long,FM_CONVFN_LONG);
        } else if (interp) {
            FM_COPY_INTERP_ALL_DOUBLE(float,long,FM_MULFN_DOUBLE,FM_CONVFN_LONG);
        } else {
            if (bigmatrix) {
                FM_COPY_ALL_DOUBLE(float,long,FM_CONVFN_LONG);
            } else {
                FM_COPY_ALL_FIXED(float,long,FM_CONVFN_LONG);           
            }
        }
    } else if (src_minfo->type==_jit_sym_float64) { 
        if (unity) {
            FM_COPY_UNITY_ALL(double,long,FM_CONVFN_LONG);
        } else if (interp) {
            FM_COPY_INTERP_ALL_DOUBLE(double,long,FM_MULFN_DOUBLE,FM_CONVFN_LONG);
        } else {
            if (bigmatrix) {
                FM_COPY_ALL_DOUBLE(double,long,FM_CONVFN_LONG);
            } else {
                FM_COPY_ALL_FIXED(double,long,FM_CONVFN_LONG);          
            }
        }
    }
}

void jit_matrix_frommatrix_2d_float32(t_matrix_conv_info *mcinfo, t_jit_matrix_info *dst_minfo, char *dst_bp, 
    t_jit_matrix_info *src_minfo, char *src_bp) 
{   
    FM_PREAMBLE();
    
    if (src_minfo->type==_jit_sym_char) {
        if (unity) {
            FM_COPY_UNITY_ALL(uchar,float,FM_CONVFN_CHARTOFLOAT);
        } else if (interp) {
            if (bigmatrix) {
                FM_COPY_INTERP_ALL_DOUBLE(uchar,float,FM_MULFN_DOUBLE,(double)FM_CONVFN_CHARTOFLOAT);
            } else {
                FM_COPY_INTERP_ALL_FIXED(uchar,float,FM_MULFN_LONG,FM_CONVFN_CHARFIXTOFLOAT);           
            }
        } else {
            if (bigmatrix) {
                FM_COPY_ALL_DOUBLE(uchar,float,FM_CONVFN_CHARTOFLOAT);
            } else {
                FM_COPY_ALL_FIXED(uchar,float,FM_CONVFN_CHARTOFLOAT);           
            }
        }
    } else if (src_minfo->type==_jit_sym_long) {                                 
        if (unity) {
            FM_COPY_UNITY_ALL(long,float,FM_CONVFN_FLOAT);
        } else if (interp) {
            FM_COPY_INTERP_ALL_DOUBLE(long,float,FM_MULFN_DOUBLE,FM_CONVFN_FLOAT);
        } else {
            if (bigmatrix) {
                FM_COPY_ALL_DOUBLE(long,float,FM_CONVFN_FLOAT);
            } else {
                FM_COPY_ALL_FIXED(long,float,FM_CONVFN_FLOAT);          
            }
        }
    } else if (src_minfo->type==_jit_sym_float32) { 
        if (unity) {
            FM_COPY_UNITY_ALL(float,float,FM_CONVFN_FLOAT);
        } else if (interp) {
            FM_COPY_INTERP_ALL_DOUBLE(float,float,FM_MULFN_DOUBLE,FM_CONVFN_FLOAT);
        } else {
            if (bigmatrix) {
                FM_COPY_ALL_DOUBLE(float,float,FM_CONVFN_FLOAT);
            } else {
                FM_COPY_ALL_FIXED(float,float,FM_CONVFN_FLOAT);         
            }
        }
    } else if (src_minfo->type==_jit_sym_float64) { 
        if (unity) {
            FM_COPY_UNITY_ALL(double,float,FM_CONVFN_FLOAT);
        } else if (interp) {
            FM_COPY_INTERP_ALL_DOUBLE(double,float,FM_MULFN_DOUBLE,FM_CONVFN_FLOAT);
        } else {
            if (bigmatrix) {
                FM_COPY_ALL_DOUBLE(double,float,FM_CONVFN_FLOAT);
            } else {
                FM_COPY_ALL_FIXED(double,float,FM_CONVFN_FLOAT);            
            }
        }
    }
}

void jit_matrix_frommatrix_2d_float64(t_matrix_conv_info *mcinfo, t_jit_matrix_info *dst_minfo, char *dst_bp, 
    t_jit_matrix_info *src_minfo, char *src_bp) 
{   
    FM_PREAMBLE();
    
    if (src_minfo->type==_jit_sym_char) {
        if (unity) {
            FM_COPY_UNITY_ALL(uchar,double,FM_CONVFN_CHARTODOUBLE);
        } else if (interp) {
            if (bigmatrix) {
                FM_COPY_INTERP_ALL_DOUBLE(uchar,double,FM_MULFN_DOUBLE,FM_CONVFN_CHARTODOUBLE);
            } else {
                FM_COPY_INTERP_ALL_FIXED(uchar,double,FM_MULFN_LONG,FM_CONVFN_CHARFIXTODOUBLE);         
            }
        } else {
            if (bigmatrix) {
                FM_COPY_ALL_DOUBLE(uchar,double,FM_CONVFN_CHARTODOUBLE);
            } else {
                FM_COPY_ALL_FIXED(uchar,double,FM_CONVFN_CHARTODOUBLE);         
            }
        }
    } else if (src_minfo->type==_jit_sym_long) {                                 
        if (unity) {
            FM_COPY_UNITY_ALL(long,double,FM_CONVFN_DOUBLE);
        } else if (interp) {
            FM_COPY_INTERP_ALL_DOUBLE(long,double,FM_MULFN_DOUBLE,FM_CONVFN_DOUBLE);
        } else {
            if (bigmatrix) {
                FM_COPY_ALL_DOUBLE(long,double,FM_CONVFN_DOUBLE);
            } else {
                FM_COPY_ALL_FIXED(long,double,FM_CONVFN_DOUBLE);            
            }
        }
    } else if (src_minfo->type==_jit_sym_float32) { 
        if (unity) {
            FM_COPY_UNITY_ALL(float,double,FM_CONVFN_DOUBLE);
        } else if (interp) {
            FM_COPY_INTERP_ALL_DOUBLE(float,double,FM_MULFN_DOUBLE,FM_CONVFN_DOUBLE);
        } else {
            if (bigmatrix) {
                FM_COPY_ALL_DOUBLE(float,double,FM_CONVFN_DOUBLE);
            } else {
                FM_COPY_ALL_FIXED(float,double,FM_CONVFN_DOUBLE);           
            }
        }
    } else if (src_minfo->type==_jit_sym_float64) { 
        if (unity) {
            FM_COPY_UNITY_ALL(double,double,FM_CONVFN_DOUBLE);
        } else if (interp) {
            FM_COPY_INTERP_ALL_DOUBLE(double,double,FM_MULFN_DOUBLE,FM_CONVFN_DOUBLE);
        } else {
            if (bigmatrix) {
                FM_COPY_ALL_DOUBLE(double,double,FM_CONVFN_DOUBLE);
            } else {
                FM_COPY_ALL_FIXED(double,double,FM_CONVFN_DOUBLE);          
            }
        }
    }
}

long jit_matrix_canfastcopy(t_matrix_conv_info *mcinfo, t_jit_matrix_info *dst_minfo, t_jit_matrix_info *src_minfo)
{   
    long i;
    //should also check word/vector alignment
    
    if (dst_minfo->size!=src_minfo->size) return FALSE;
    if (dst_minfo->type!=src_minfo->type) return FALSE;
    if (dst_minfo->planecount!=src_minfo->planecount) return FALSE;
    if (dst_minfo->dimcount!=src_minfo->dimcount) return FALSE;
    for (i=0;i<dst_minfo->dimcount;i++) {
        if (dst_minfo->dim[i]!=src_minfo->dim[i]) return FALSE;
        if (dst_minfo->dimstride[i]!=src_minfo->dimstride[i]) return FALSE;
    }
    if (mcinfo) {
        if (mcinfo->flags&JIT_MATRIX_CONVERT_SRCDIM) {
            for (i=0;i<src_minfo->dimcount;i++) {
                if (mcinfo->srcdimstart[i]!=0) return FALSE;
                if (mcinfo->srcdimend[i]!=src_minfo->dim[i]) return FALSE;
            }
        }
        if (mcinfo->flags&JIT_MATRIX_CONVERT_DSTDIM) {
            for (i=0;i<dst_minfo->dimcount;i++) {
                if (mcinfo->dstdimstart[i]!=0) return FALSE;
                if (mcinfo->dstdimend[i]!=dst_minfo->dim[i]) return FALSE;
            }
        }
        for (i=0;i<dst_minfo->planecount;i++) {
            if (mcinfo->planemap[i]!=i) return FALSE;
        }       
    }
    return TRUE;
}

//this could be a problem for sub matrices of larger matrices...beware.
t_jit_err jit_matrix_fastcopy(long size, void *dst, void *src)
{
    if (dst==src) return JIT_ERR_NONE; //same pointer
    BlockMoveData(src,dst,size); //BlockMoveData appears to be ~15% faster than my code
    return JIT_ERR_NONE;
/*
    long n;
    double *dst_lp,*src_lp;
    char *dst_cp,*src_cp;
    
    if (dst==src) return JIT_ERR_NONE; //same pointer
    
    if (_jit_altivec&&(!(((long)dst)%16))&&(!(((long)src)%16))&&(size>=256)) {
        jit_matrix_fastcopy_altivec(size, dst, src);        
    } else {
        if (dst&&src) { 
            n = (size/32)+1;
            dst_lp = (double *)(dst);
            src_lp = (double *)(src);
            while (--n) {
                dst_lp[0]=src_lp[0];            
                dst_lp[1]=src_lp[1];            
                dst_lp[2]=src_lp[2];            
                dst_lp[3]=src_lp[3];            
                dst_lp+=4;src_lp+=4;    
            }
            n = (size%32)+1;
            dst_cp = ((char *)dst_lp)-1;
            src_cp = ((char *)src_lp)-1;
            while (--n) *++dst_cp=*++src_cp;
                        
            return JIT_ERR_NONE;
        } else {
            return JIT_ERR_INVALID_PTR;
        }
    }
*/
}

#if JIT_CAN_ALTIVEC
//only call with vector aligned memory
t_jit_err jit_matrix_fastcopy_altivec(long size, void *dst, void *src)
{
    long m,n;
    vector unsigned char *dst_lp;
    vector unsigned char *src_lp;
    char *dst_cp,*src_cp;
    
    if (dst&&src) { 
        m = (((long)dst)%64)/16; //ensure that we only call __dcbz() on 64 byte boundaries
        size -= m*16;
        n = (size/64)+1;
        dst_lp = (vector unsigned char *)(dst);
        src_lp = (vector unsigned char *)(src);
        while (m--) {
            dst_lp[0]=src_lp[0];            
            dst_lp++;src_lp++;  
        }
        while (--n) {
            __dcbz( dst_lp, 0 );
            __dcbz( dst_lp, 32 );

            dst_lp[0]=src_lp[0];            
            dst_lp[1]=src_lp[1];            
            dst_lp[2]=src_lp[2];            
            dst_lp[3]=src_lp[3];            
            dst_lp+=4;src_lp+=4;    
        }
        n = (size%64)+1;
        dst_cp = ((char *)dst_lp)-1;
        src_cp = ((char *)src_lp)-1;
        while (--n) *++dst_cp=*++src_cp;
                    
        return JIT_ERR_NONE;
    } else {
        return JIT_ERR_INVALID_PTR;
    }
}
#endif // JIT_CAN_ALTIVEC

long jit_matrix_lock(t_jit_matrix *x, long lock)
{
    long rv=0;
    
    if (x) {
        if (x->info.flags&JIT_MATRIX_DATA_HANDLE) {
            rv = jit_handle_lock(x->hdata,lock);
            if (lock) x->data = *(x->hdata);
            else x->data = NULL;
        } 
    }
    return rv;
}

// with 1 arguments <op> 
// with 2 arguments <op> <matrix/val(list)>
// with 3 arguments <op> <matrix> <matrix/val(list)>

/**
 * Applies unary or binary operator to matrix
 * See Jitter user documentation for more information.
 * 
 * @ingroup matrixmod
 *
 * @param   x       t_jit_matrix object pointer
 * @param   s       message symbol pointer
 * @param   argc    argument count
 * @param   argv    argument vector
 *
 * @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_matrix.
 */
t_jit_err jit_matrix_op(t_jit_matrix *x, t_symbol *s, long argc, t_atom *argv)
{
    t_jit_err err=JIT_ERR_GENERIC;
    t_symbol *opsym=_jit_sym_nothing;
    t_jit_object *o;
    t_jit_linklist *list;
    t_jit_matrix *m1=NULL,*m2=NULL;
    t_jit_matrix_info info;
    long useval=0,i;
    t_jit_op_fn_object *fnobj;
    long unary=0;
    
    opsym=jit_atom_getsym(argv);
    o = (t_jit_object *)jit_object_new(ps_jit_op);
    list = jit_linklist_new();
    if (o&&list) {
        jit_attr_setsym(o,ps_op,opsym);
        if (fnobj=jit_op_fn_lookup(opsym)) {
            unary = (fnobj->argcount==1);
        } else {
            jit_object_error((t_object *)x,"jit_op: no operator %s",opsym->s_name);
        }

        // determine behavior based on arguments
        if (argc==1) {
            // no args, use target as both operands and output
            m1 = x;
            m2 = x;
        } else {
            // look for numerical "value" args and create a temproary matrix for if present
            for (i=1;i<argc;i++) {
                if ((argv[i].a_type==A_FLOAT)||(argv[i].a_type==A_LONG)) {
                    useval = i; 
                    break;
                }
            }
            if (useval&&useval<=2) { // values are always righthand operand
                if (useval==2) {
                    // extra matrix arg, use as one operand
                    if (argv[1].a_type==A_SYM) {
                        m1 = jit_object_findregistered(jit_atom_getsym(argv+1));
                    } else if (argv[1].a_type==A_OBJ) {
                        m1 = (t_jit_matrix *)argv[1].a_w.w_obj;
                    }
                }
                if (unary) {
                    jit_matrix_getinfo(x,&info);
                    m1 = jit_matrix_new(&info);
                    jit_matrix_setall(m1,NULL,argc-useval,argv+useval);
                    m2 = x;
                } else {
                    if (!m1) {
                        // no extra matrix arg, use target as one operand and output
                        m1 = x;
                    }               
                    jit_matrix_getinfo(m1,&info);
                    m2 = jit_matrix_new(&info);
                    jit_matrix_setall(m2,NULL,argc-useval,argv+useval);
                }
            } else {
                useval = 0;
                if (argc==2) {
                    // one extra matrix arg use target as one operand and output
                    m1 = x;
                    if (argv[1].a_type==A_SYM) {
                        m2 = jit_object_findregistered(jit_atom_getsym(argv+1));
                    } else if (argv[1].a_type==A_OBJ) {
                        m2 = (t_jit_matrix *)argv[1].a_w.w_obj;
                    }
                    if (unary) {
                        m1 = m2;
                        m2 = x;
                    }
                }
                if (argc>=3) {
                    // two extra matrix args, use each arg as one operand and target as output
                    if (argv[1].a_type==A_SYM) {
                        m1 = jit_object_findregistered(jit_atom_getsym(argv+1));
                    } else if (argv[1].a_type==A_OBJ) {
                        m1 = (t_jit_matrix *)argv[1].a_w.w_obj;
                    }
                    if (argv[2].a_type==A_SYM) {
                        m2 = jit_object_findregistered(jit_atom_getsym(argv+2));
                    } else if (argv[2].a_type==A_OBJ) {
                        m2 = (t_jit_matrix *)argv[2].a_w.w_obj;
                    }
                }
            }
            // avoid errors if NULL object passed in (instead use zero matrix?)         
            if (m1==NULL)
                m1 = x;
            if (m2==NULL)
                m2 = x;             
        }
        if (m1&&m2&&jit_object_method(m1,_jit_sym_class_jit_matrix)&&
            jit_object_method(m2,_jit_sym_class_jit_matrix)) 
        {
            // do we want to deal with resampling/type conversion somehow?
            //could use additional temproary matrices if desired
            jit_linklist_append(list,m1);
            jit_linklist_append(list,m2);
            err = (t_jit_err)jit_object_method(o,_jit_sym_matrix_calc,list,x);
        }
        jit_object_free(o);     
        jit_linklist_chuck(list);       
        if (useval) {
            if (unary)
                jit_object_free(m1);
            else
                jit_object_free(m2);
        }
        //if (m3&&(m3!=x))  
        //  jit_object_free(m3);
    }
    return err;
}

/**
 * Fills cells according to the jit.expr expression provided.
 * See Jitter user documentation for more information.
 * 
 * @ingroup matrixmod
 *
 * @param   x       t_jit_matrix object pointer
 * @param   s       message symbol pointer
 * @param   argc    argument count
 * @param   argv    argument vector
 *
 * @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_matrix.
 */
t_jit_err jit_matrix_exprfill(t_jit_matrix *x, t_symbol *s, long argc, t_atom *argv)
{
    t_jit_err err=JIT_ERR_GENERIC;
    t_symbol *exprsym=_jit_sym_nothing;
    t_jit_object *o;
    t_jit_matrix *m=NULL;
    t_jit_matrix_info info;
    t_matrix_conv_info convinfo;
    long i,plane;
    
    if (!argc||!argv)
        return JIT_ERR_GENERIC;

    convinfo.flags = 0;
    if (argv->a_type!=A_SYM) {
        plane = jit_atom_getlong(argv);
        for (i=0;i<JIT_MATRIX_MAX_PLANECOUNT;i++)
            convinfo.planemap[i]= plane==i?0:-1;
        argv++;argc--;
    } else {
        for (i=0;i<JIT_MATRIX_MAX_PLANECOUNT;i++)
            convinfo.planemap[i]=0;
    }
    if ((argc>0)&&argv) {
        exprsym=jit_atom_getsym(argv);
        o = (t_jit_object *)jit_object_new(ps_jit_expr);
        if (o) {
            jit_attr_setsym(o,ps_expr,exprsym);
            jit_matrix_getinfo(x,&info);
            info.type = _jit_sym_float32;
            info.planecount = 1;
            m = jit_matrix_new(&info);
            if (m) {
                err = (t_jit_err)jit_object_method(o,_jit_sym_matrix_calc,x,m);
                jit_object_method(x,_jit_sym_frommatrix,m,&convinfo);
                jit_object_free(m);     
            }
            jit_object_free(o);     
        }
    }
    return err;
}

/**
 * Copies texture information to matrix.
 * See Jitter user documentation for more information.
 * 
 * @ingroup matrixmod
 *
 * @param   x       t_jit_matrix object pointer
 * @param   s       message symbol pointer
 * @param   argc    argument count
 * @param   argv    argument vector
 *
 * @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_matrix.
 */
t_jit_err jit_matrix_jit_gl_texture(t_jit_matrix *x, t_symbol *s, long argc, t_atom *argv)
{
    t_jit_err err=JIT_ERR_GENERIC;
    t_symbol *texturesym=_jit_sym_nothing;
    t_jit_object *o;
    t_atom a;
    
    if (!argc||!argv)
        return JIT_ERR_GENERIC;

    texturesym=jit_atom_getsym(argv);
    if(o=jit_object_findregistered(texturesym))
    {
        jit_atom_setobj(&a,x);
        err = (t_jit_err)jit_object_method(o,ps_tomatrix,ps_tomatrix,1,&a);
    }
    
    return err;
}

Copyright © 2008, Cycling '74