Max 5 API Reference

jit.javamatrix.c

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

static t_symbol *ps_getmatrix,*ps_getcell,*ps_setall,*ps_setcell,*ps_setcell3d,*ps_val,*ps_plane;
//JNI


t_atom jit_java_jitmatrix_getcell_helper(JNIEnv *env, jobject obj, jobject array);
jobject JNICALL jit_java_jitmatrix_getcell_int(JNIEnv *env, jobject obj, jobject array);
jobject JNICALL jit_java_jitmatrix_getcell_float(JNIEnv *env, jobject obj, jobject array);
jobject JNICALL jit_java_jitmatrix_getcell_double(JNIEnv *env, jobject obj, jobject array);
t_atom jit_java_jitmatrix_getcell3d_helper(JNIEnv *env, jobject obj, jint x, jint y, jint z);
jobject JNICALL jit_java_jitmatrix_getcell3d_atom(JNIEnv *env, jobject obj, jint x, jint y, jint z);
jobject JNICALL jit_java_jitmatrix_getcell3d_int(JNIEnv *env, jobject obj, jint x, jint y, jint z);
jobject JNICALL jit_java_jitmatrix_getcell3d_float(JNIEnv *env, jobject obj, jint x, jint y, jint z);
jobject JNICALL jit_java_jitmatrix_getcell3d_double(JNIEnv *env, jobject obj, jint x, jint y, jint z);
void JNICALL jit_java_jitmatrix_setall_double(JNIEnv *env, jobject obj, jdouble val);
void JNICALL jit_java_jitmatrix_setcell_int(JNIEnv *env, jobject obj, jobject pos_array, jobject val_array);
void JNICALL jit_java_jitmatrix_setcell_float(JNIEnv *env, jobject obj, jobject pos_array, jobject val_array);
void JNICALL jit_java_jitmatrix_setcell_double(JNIEnv *env, jobject obj, jobject pos_array, jobject val_array);
void JNICALL jit_java_jitmatrix_setcell_plane_int(JNIEnv *env, jobject obj, jobject pos_array, jint plane, jint val);
void JNICALL jit_java_jitmatrix_setcell_plane_float(JNIEnv *env, jobject obj, jobject pos_array, jint plane, jfloat val);
void JNICALL jit_java_jitmatrix_setcell_plane_double(JNIEnv *env, jobject obj, jobject pos_array, jint plane, jdouble val);
void JNICALL jit_java_jitmatrix_setcell3d_int(JNIEnv *env, jobject obj, jint x, jint y, jint z, jobject val_array);
void JNICALL jit_java_jitmatrix_setcell3d_float(JNIEnv *env, jobject obj, jint x, jint y, jint z, jobject val_array);
void JNICALL jit_java_jitmatrix_setcell3d_double(JNIEnv *env, jobject obj, jint x, jint y, jint z, jobject val_array);


void jit_java_jitmatrix_register_natives(JNIEnv *env, jclass clazz);

//internal
t_object *get_jit_java_jitobj(JNIEnv *env, jobject obj);
jobject JNICALL jit_java_jitobj_returnvalue(JNIEnv *env, t_atom a);
void jit_java_jitter_register_natives(JNIEnv*, jclass);

t_atom jit_java_jitmatrix_getcell_helper(JNIEnv *env, jobject obj, jobject array)
{
    long i,ac=0;
    t_atom av[JIT_MATRIX_MAX_DIMCOUNT];
    t_atom arv;
    t_max_err res;
    t_object *o;
    jint *elements;         
    jboolean is_copy; 

    arv.a_type = A_NOTHING;
    
    o = get_jit_java_jitobj(env,obj);
    if(!o)
        return arv;
    
    if (array) {
        ac = JIT_JAVA_JNI_CALL(env,GetArrayLength)(env,array);
        if (ac>JIT_MATRIX_MAX_DIMCOUNT)
            ac = JIT_MATRIX_MAX_DIMCOUNT;
            
        elements = JIT_JAVA_JNI_CALL(env, GetIntArrayElements)(env,(jintArray)array,&is_copy);
        checkException(env); // inefficient?

        for(i=0;i<ac;i++)   
            atom_setlong(av+i,elements[i]);
        if (is_copy)
        {
            JIT_JAVA_JNI_CALL(env, ReleaseIntArrayElements)(env,(jintArray)array,elements,0);
            checkException(env);
        }

    }
    
    res = object_method_typed(o,ps_getcell,ac,av,&arv);
    
    return arv;
}

jobject JNICALL jit_java_jitmatrix_getcell_int(JNIEnv *env, jobject obj, jobject array)
{
    t_atom arv;
    
    arv = jit_java_jitmatrix_getcell_helper(env,obj,array);
    return jit_java_jitobj_returnvalue_intarray(env,arv);
}

jobject JNICALL jit_java_jitmatrix_getcell_float(JNIEnv *env, jobject obj, jobject array)
{
    t_atom arv;
    
    arv = jit_java_jitmatrix_getcell_helper(env,obj,array);
    return jit_java_jitobj_returnvalue_floatarray(env,arv);
}

jobject JNICALL jit_java_jitmatrix_getcell_double(JNIEnv *env, jobject obj, jobject array)
{
    t_atom arv;
    
    arv = jit_java_jitmatrix_getcell_helper(env,obj,array);
    return jit_java_jitobj_returnvalue_doublearray(env,arv);
}

t_atom jit_java_jitmatrix_getcell3d_helper(JNIEnv *env, jobject obj, jint x, jint y, jint z)
{
    t_atom a[3];
    t_atom arv;
    t_max_err res;
    t_object *o;
    
    arv.a_type = A_NOTHING;

    o = get_jit_java_jitobj(env,obj);
    if(!o)
        return arv;
    
    atom_setlong(a,x);
    atom_setlong(a+1,y);
    atom_setlong(a+2,z);
    res = object_method_typed(o,ps_getcell,3,a,&arv);
    
    return arv;
}

jobject JNICALL jit_java_jitmatrix_getcell3d_atom(JNIEnv *env, jobject obj, jint x, jint y, jint z)
{
    t_atom arv;
    
    arv = jit_java_jitmatrix_getcell3d_helper(env,obj,x,y,z);
    return jit_java_jitobj_returnvalue(env,arv);
}


jobject JNICALL jit_java_jitmatrix_getcell3d_int(JNIEnv *env, jobject obj, jint x, jint y, jint z)
{
    t_atom arv;
    
    arv = jit_java_jitmatrix_getcell3d_helper(env,obj,x,y,z);
    return jit_java_jitobj_returnvalue_intarray(env,arv);
}

jobject JNICALL jit_java_jitmatrix_getcell3d_float(JNIEnv *env, jobject obj, jint x, jint y, jint z)
{
    t_atom arv;
    
    arv = jit_java_jitmatrix_getcell3d_helper(env,obj,x,y,z);
    return jit_java_jitobj_returnvalue_floatarray(env,arv);
}

jobject JNICALL jit_java_jitmatrix_getcell3d_double(JNIEnv *env, jobject obj, jint x, jint y, jint z)
{
    t_atom arv;
    
    arv = jit_java_jitmatrix_getcell3d_helper(env,obj,x,y,z);
    return jit_java_jitobj_returnvalue_doublearray(env,arv);
}

void JNICALL jit_java_jitmatrix_setall_double(JNIEnv *env, jobject obj, jdouble val)
{
    t_atom a;
    t_atom arv;
    t_max_err res;
    t_object *o;

    // later on this function should use special double precision methods for setting with doubles
            
    o = get_jit_java_jitobj(env,obj);
    if(!o)//would be weird
        return;
    
    atom_setfloat(&a,val);
    res = object_method_typed(o,ps_setall,1,&a,&arv);
}


void JNICALL jit_java_jitmatrix_setcell_int(JNIEnv *env, jobject obj, jobject pos_array, jobject val_array)
{
    long ac=0;
    t_atom av[JIT_MATRIX_MAX_DIMCOUNT+JIT_MATRIX_MAX_PLANECOUNT+1];
    t_atom arv;
    t_max_err res;
    t_object *o;

    arv.a_type = A_NOTHING;
    
    o = get_jit_java_jitobj(env,obj);
    if(!o)
        return;
    
    if (pos_array) {
        // copy position array as as atoms
        ac = jit_java_atomsfromintarray(env,pos_array,JIT_MATRIX_MAX_DIMCOUNT,av);
    }
    
    if (val_array) {
        // set value symbol 
        atom_setsym(av+ac,ps_val);
        ac++;
        // copy value array as as atoms
        ac += jit_java_atomsfromintarray(env,val_array,JIT_MATRIX_MAX_PLANECOUNT,av+ac);        
    }
    
    res = object_method_typed(o,ps_setcell,ac,av,&arv);
}

void JNICALL jit_java_jitmatrix_setcell_float(JNIEnv *env, jobject obj, jobject pos_array, jobject val_array)
{
    long ac=0;
    t_atom av[JIT_MATRIX_MAX_DIMCOUNT+JIT_MATRIX_MAX_PLANECOUNT+1];
    t_atom arv;
    t_max_err res;
    t_object *o;

    arv.a_type = A_NOTHING;
    
    o = get_jit_java_jitobj(env,obj);
    if(!o)
        return;
        
    if (pos_array) {
        // copy position array as as atoms
        ac = jit_java_atomsfromintarray(env,pos_array,JIT_MATRIX_MAX_DIMCOUNT,av);
    }
    
    if (val_array) {
        // set value symbol 
        atom_setsym(av+ac,ps_val);
        ac++;
        // copy value array as as atoms
        ac += jit_java_atomsfromfloatarray(env,val_array,JIT_MATRIX_MAX_PLANECOUNT,av+ac);      
    }
    
    res = object_method_typed(o,ps_setcell,ac,av,&arv);
}

void JNICALL jit_java_jitmatrix_setcell_double(JNIEnv *env, jobject obj, jobject pos_array, jobject val_array)
{
    long ac=0;
    t_atom av[JIT_MATRIX_MAX_DIMCOUNT+JIT_MATRIX_MAX_PLANECOUNT+1];
    t_atom arv;
    t_max_err res;
    t_object *o;

    // later on this function should use special double precision methods for setting with doubles
    arv.a_type = A_NOTHING;
    
    o = get_jit_java_jitobj(env,obj);
    if(!o)
        return;
    
    if (pos_array) {
        // copy position array as as atoms
        ac = jit_java_atomsfromintarray(env,pos_array,JIT_MATRIX_MAX_DIMCOUNT,av);
    }
    
    if (val_array) {
        // set value symbol 
        atom_setsym(av+ac,ps_val);
        ac++;
        // copy value array as as atoms
        ac += jit_java_atomsfromdoublearray(env,val_array,JIT_MATRIX_MAX_PLANECOUNT,av+ac);     
    }
    
    res = object_method_typed(o,ps_setcell,ac,av,&arv);
}

void JNICALL jit_java_jitmatrix_setcell_plane_int(JNIEnv *env, jobject obj, jobject pos_array, jint plane, jint val)
{
    long ac=0;
    t_atom av[JIT_MATRIX_MAX_DIMCOUNT+JIT_MATRIX_MAX_PLANECOUNT+1];
    t_atom arv;
    t_max_err res;
    t_object *o;

    arv.a_type = A_NOTHING;
    
    o = get_jit_java_jitobj(env,obj);
    if(!o)
        return;
    
    if (pos_array) {
        // copy position array as as atoms
        ac = jit_java_atomsfromintarray(env,pos_array,JIT_MATRIX_MAX_DIMCOUNT,av);
    }
    
    // set plane 
    atom_setsym(av+ac,ps_plane); ac++;
    atom_setlong(av+ac,plane); ac++;
    // set value 
    atom_setsym(av+ac,ps_val); ac++;
    atom_setlong(av+ac,val); ac++;

    res = object_method_typed(o,ps_setcell,ac,av,&arv);
}

void JNICALL jit_java_jitmatrix_setcell_plane_float(JNIEnv *env, jobject obj, jobject pos_array, jint plane, jfloat val)
{
    long ac=0;
    t_atom av[JIT_MATRIX_MAX_DIMCOUNT+JIT_MATRIX_MAX_PLANECOUNT+1];
    t_atom arv;
    t_max_err res;
    t_object *o;

    arv.a_type = A_NOTHING;
    
    o = get_jit_java_jitobj(env,obj);
    if(!o)
        return;
    
    if (pos_array) {
        // copy position array as as atoms
        ac = jit_java_atomsfromintarray(env,pos_array,JIT_MATRIX_MAX_DIMCOUNT,av);
    }
    
    // set plane 
    atom_setsym(av+ac,ps_plane); ac++;
    atom_setlong(av+ac,plane); ac++;
    // set value 
    atom_setsym(av+ac,ps_val); ac++;
    atom_setfloat(av+ac,val); ac++;

    res = object_method_typed(o,ps_setcell,ac,av,&arv);
}

void JNICALL jit_java_jitmatrix_setcell_plane_double(JNIEnv *env, jobject obj, jobject pos_array, jint plane, jdouble val)
{
    long ac=0;
    t_atom av[JIT_MATRIX_MAX_DIMCOUNT+JIT_MATRIX_MAX_PLANECOUNT+1];
    t_atom arv;
    t_max_err res;
    t_object *o;

    arv.a_type = A_NOTHING;
    
    o = get_jit_java_jitobj(env,obj);
    if(!o)
        return;
    
    if (pos_array) {
        // copy position array as as atoms
        ac = jit_java_atomsfromintarray(env,pos_array,JIT_MATRIX_MAX_DIMCOUNT,av);
    }
    
    // set plane 
    atom_setsym(av+ac,ps_plane); ac++;
    atom_setlong(av+ac,plane); ac++;
    // set value 
    atom_setsym(av+ac,ps_val); ac++;
    atom_setfloat(av+ac,val); ac++;

    res = object_method_typed(o,ps_setcell,ac,av,&arv);
}

void JNICALL jit_java_jitmatrix_setcell3d_int(JNIEnv *env, jobject obj, jint x, jint y, jint z, jobject val_array)
{
    long ac=0;
    t_atom av[JIT_MATRIX_MAX_DIMCOUNT+JIT_MATRIX_MAX_PLANECOUNT+1];
    t_atom arv;
    t_max_err res;
    t_object *o;

    arv.a_type = A_NOTHING;
    
    o = get_jit_java_jitobj(env,obj);
    if(!o)
        return;
    
    atom_setlong(av+ac,x); ac++;
    atom_setlong(av+ac,y); ac++;
    atom_setlong(av+ac,z); ac++;
    
    if (val_array) {
        // copy value array as as atoms
        ac += jit_java_atomsfromintarray(env,val_array,JIT_MATRIX_MAX_PLANECOUNT,av+ac);        
    }
    
    res = object_method_typed(o,ps_setcell3d,ac,av,&arv);
}

void JNICALL jit_java_jitmatrix_setcell3d_float(JNIEnv *env, jobject obj, jint x, jint y, jint z, jobject val_array)
{
    long ac=0;
    t_atom av[JIT_MATRIX_MAX_DIMCOUNT+JIT_MATRIX_MAX_PLANECOUNT+1];
    t_atom arv;
    t_max_err res;
    t_object *o;

    arv.a_type = A_NOTHING;
    
    o = get_jit_java_jitobj(env,obj);
    if(!o)
        return;
    
    atom_setlong(av+ac,x); ac++;
    atom_setlong(av+ac,y); ac++;
    atom_setlong(av+ac,z); ac++;
    
    if (val_array) {
        // copy value array as as atoms
        ac += jit_java_atomsfromfloatarray(env,val_array,JIT_MATRIX_MAX_PLANECOUNT,av+ac);      
    }
    
    res = object_method_typed(o,ps_setcell3d,ac,av,&arv);
}

void JNICALL jit_java_jitmatrix_setcell3d_double(JNIEnv *env, jobject obj, jint x, jint y, jint z, jobject val_array)
{
    long ac=0;
    t_atom av[JIT_MATRIX_MAX_DIMCOUNT+JIT_MATRIX_MAX_PLANECOUNT+1];
    t_atom arv;
    t_max_err res;
    t_object *o;

    arv.a_type = A_NOTHING;
    
    o = get_jit_java_jitobj(env,obj);
    if(!o)
        return;
    
    atom_setlong(av+ac,x); ac++;
    atom_setlong(av+ac,y); ac++;
    atom_setlong(av+ac,z); ac++;
    
    if (val_array) {
        // copy value array as as atoms
        ac += jit_java_atomsfromdoublearray(env,val_array,JIT_MATRIX_MAX_PLANECOUNT,av+ac);     
    }
    
    res = object_method_typed(o,ps_setcell3d,ac,av,&arv);
}

uchar *jit_java_jitmatrix_copyvectorsetup(JNIEnv *env, t_object *o, jint *dim, jobject dimoffset, jobject array, jint *count, jint *arrayoffset,
                                t_jit_matrix_info *minfo, jint *doa, jint *arraylen, long planar)
{
    long i,maxcount,offset_count;
    jint *offset_elements;
    uchar *bp=NULL;
    jboolean is_copy; 

    // get array length
    *arraylen = JIT_JAVA_JNI_CALL(env,GetArrayLength)(env,array);
    CLIP(*arrayoffset,0,*arraylen-1);
    *arraylen -= *arrayoffset;
    if (*count<=0)
        *count = *arraylen;         

    // limit dim and count
    CLIP(*dim,0,JIT_MATRIX_MAX_DIMCOUNT-1);
    CLIP(*count,0,*arraylen);

    // get pointer and matrix info
    jit_object_method(o,_jit_sym_getinfo,minfo);
    jit_object_method(o,_jit_sym_getdata,&bp);
    if (!bp)
        return NULL;
    
    // get offset array count (if it exists)
    i=0;
    if (dimoffset)
    {
        offset_count = JIT_JAVA_JNI_CALL(env,GetArrayLength)(env,dimoffset);
        offset_elements = JIT_JAVA_JNI_CALL(env, GetIntArrayElements)(env,(jintArray)dimoffset,&is_copy);
        // offset pointer
        for (i=0;i<offset_count;i++)  {
            doa[i] = CLAMP(offset_elements[i],0,MAX(minfo->dim[i]-1,0)); 
            bp += doa[i] * minfo->dimstride[i];
        }
        // release offset array
        if (is_copy) {
            JIT_JAVA_JNI_CALL(env, ReleaseIntArrayElements)(env,(jintArray)dimoffset,offset_elements,0);
        }
    }
    for (;i<JIT_MATRIX_MAX_DIMCOUNT;i++) {
        doa[i] = 0;
    }   
    
    //limit count based on matrix info and offset across dimension of interest
    maxcount = minfo->dim[*dim]-doa[*dim];
    if (!planar)
        maxcount *= minfo->planecount;
    if ((*count)>maxcount)
        *count = maxcount;
        
    return bp;  
}

jint JNICALL jit_java_jitmatrix_copyvectortoarray_int(JNIEnv *env, jobject obj, jint dim, jobject dimoffset, jobject array, jint count, jint arrayoffset);
jint JNICALL jit_java_jitmatrix_copyvectortoarray_int(JNIEnv *env, jobject obj, jint dim, jobject dimoffset, jobject array, jint count, jint arrayoffset)
{
    t_object *o,*mat;
    t_jit_matrix_info minfo;
    jint doa[JIT_MATRIX_MAX_DIMCOUNT];
    jint arraylen;
    jint *elements;
    jboolean is_copy; 
    uchar *bp=NULL;
    long i,j,k;
    long stride,planecount,cellcount;
    long tmp;
    
    o = get_jit_java_jitobj(env,obj);
    if(!o||!array)
        return 0;
    
    mat = jit_object_method(o,ps_getmatrix);
    if(!mat)
        return 0;
        
    // setup all our info, common to all copyvector methods
    bp = jit_java_jitmatrix_copyvectorsetup(env,mat,&dim,dimoffset,array,&count,&arrayoffset,&minfo,doa,&arraylen,0);
    if (!bp)
        return 0;
        
    // allocate temp memory for array
    elements = jit_getbytes(count*sizeof(jint));
    
    stride = minfo.dimstride[dim];
    planecount = minfo.planecount;
    cellcount = count/planecount;
    if (minfo.type==_jit_sym_char) {
        if (planecount==4) {
            for (i=0,j=0,k=0;i<cellcount;i++) {
                elements[j++] = bp[k++]; 
                elements[j++] = bp[k++]; 
                elements[j++] = bp[k++]; 
                elements[j++] = bp[k++]; 
            }
        } else {        
            for (i=0,k=0;i<cellcount;i++) {
                for (j=0;j<planecount;j++) {
                    elements[k++] = bp[j]; 
                }
                bp += stride;
            }
        }       
    } else if (minfo.type==_jit_sym_long) {
        for (i=0,k=0;i<cellcount;i++) {
            for (j=0;j<planecount;j++) {
                elements[k++] = ((long *)bp)[j];
            }
            bp += stride;
        }       
    } else if (minfo.type==_jit_sym_float32) {
        for (i=0,k=0;i<cellcount;i++) {
            for (j=0;j<planecount;j++) {
                elements[k++] = (long)((float *)bp)[j];
            }
            bp += stride;
        }       
    } else if (minfo.type==_jit_sym_float64) {
        for (i=0,k=0;i<cellcount;i++) {
            for (j=0;j<planecount;j++) {
                elements[k++] = (long) ((double *)bp)[j];
            }
            bp += stride;
        }       
    }   
    
    JIT_JAVA_JNI_CALL(env,SetIntArrayRegion)(env,(jintArray)array,arrayoffset,count,elements); 

    // free temp memory for array
    jit_freebytes(elements,count*sizeof(jint));
    
    return count;       
}

jint JNICALL jit_java_jitmatrix_copyvectortoarrayplanar_int(JNIEnv *env, jobject obj, jint plane, jint dim, jobject dimoffset, jobject array, jint count, jint arrayoffset);
jint JNICALL jit_java_jitmatrix_copyvectortoarrayplanar_int(JNIEnv *env, jobject obj, jint plane, jint dim, jobject dimoffset, jobject array, jint count, jint arrayoffset)
{
    t_object *o,*mat;
    t_jit_matrix_info minfo;
    jint doa[JIT_MATRIX_MAX_DIMCOUNT];
    jint arraylen;
    jint *elements;
    jboolean is_copy; 
    uchar *bp=NULL;
    long i,j,k;
    long stride,planecount,cellcount;
    long tmp;
    
    o = get_jit_java_jitobj(env,obj);
    if(!o||!array)
        return 0;
    
    mat = jit_object_method(o,ps_getmatrix);
    if(!mat)
        return 0;
        
    // setup all our info, common to all copyvector methods
    bp = jit_java_jitmatrix_copyvectorsetup(env,mat,&dim,dimoffset,array,&count,&arrayoffset,&minfo,doa,&arraylen,1);
    if (!bp)
        return 0;
        
    // get array
    elements = JIT_JAVA_JNI_CALL(env, GetIntArrayElements)(env,(jintArray)array,&is_copy);
    //checkException(env); //inefficient?
    
    stride = minfo.dimstride[dim];
    planecount = minfo.planecount;
    cellcount = count;
    bp += (plane%planecount)*jit_matrix_info_typesize(&minfo);
    if (minfo.type==_jit_sym_char) {
        for (i=0,k=arrayoffset;i<cellcount;i++) {
            elements[k++] = (*bp); 
            bp += stride;
        }       
    } else if (minfo.type==_jit_sym_long) {
        for (i=0,k=arrayoffset;i<cellcount;i++) {
            elements[k++] = *((long *)bp);
            bp += stride;
        }       
    } else if (minfo.type==_jit_sym_float32) {
        for (i=0,k=arrayoffset;i<cellcount;i++) {
            elements[k++] = (long) *((float *)bp);
            bp += stride;
        }       
    } else if (minfo.type==_jit_sym_float64) {
        for (i=0,k=arrayoffset;i<cellcount;i++) {
            elements[k++] = (long) *((double *)bp);
            bp += stride;
        }       
    }   
    
    JIT_JAVA_JNI_CALL(env,SetIntArrayRegion)(env,(jintArray)array,arrayoffset,count,elements+arrayoffset); 

    // release array
    if (is_copy) {
        JIT_JAVA_JNI_CALL(env, ReleaseIntArrayElements)(env,(jintArray)array,elements,0);
        checkException(env);
    }
    
    return count;       
}

jint JNICALL jit_java_jitmatrix_copyvectortoarray_float(JNIEnv *env, jobject obj, jint dim, jobject dimoffset, jobject array, jint count, jint arrayoffset);
jint JNICALL jit_java_jitmatrix_copyvectortoarray_float(JNIEnv *env, jobject obj, jint dim, jobject dimoffset, jobject array, jint count, jint arrayoffset)
{
    t_object *o,*mat;
    t_jit_matrix_info minfo;
    jint doa[JIT_MATRIX_MAX_DIMCOUNT];
    jint arraylen;
    jfloat *elements;
    jboolean is_copy; 
    uchar *bp=NULL;
    long i,j,k;
    long stride,planecount,cellcount;
    long tmp;
    
    o = get_jit_java_jitobj(env,obj);
    if(!o||!array)
        return 0;
    
    mat = jit_object_method(o,ps_getmatrix);
    if(!mat)
        return 0;
        
    // setup all our info, common to all copyvector methods
    bp = jit_java_jitmatrix_copyvectorsetup(env,mat,&dim,dimoffset,array,&count,&arrayoffset,&minfo,doa,&arraylen,0);
    if (!bp)
        return 0;
        
    // get array
    elements = JIT_JAVA_JNI_CALL(env, GetFloatArrayElements)(env,(jfloatArray)array,&is_copy);
    //checkException(env); //inefficient?
    
    stride = minfo.dimstride[dim];
    planecount = minfo.planecount;
    cellcount = count/planecount;
    if (minfo.type==_jit_sym_char) {
        if (planecount==4) {
            for (i=0,j=0,k=0;i<cellcount;i++) {
                elements[j++] = bp[k++]*(1./255.); 
                elements[j++] = bp[k++]*(1./255.); 
                elements[j++] = bp[k++]*(1./255.); 
                elements[j++] = bp[k++]*(1./255.); 
            }
        } else {        
            for (i=0,k=arrayoffset;i<cellcount;i++) {
                for (j=0;j<planecount;j++) {
                    elements[k++] = bp[j]*(1./255.); 
                }
                bp += stride;
            }
        }       
    } else if (minfo.type==_jit_sym_long) {
        for (i=0,k=arrayoffset;i<cellcount;i++) {
            for (j=0;j<planecount;j++) {
                elements[k++] = (float) ((long *)bp)[j];
            }
            bp += stride;
        }       
    } else if (minfo.type==_jit_sym_float32) {
        for (i=0,k=arrayoffset;i<cellcount;i++) {
            for (j=0;j<planecount;j++) {
                elements[k++] = ((float *)bp)[j];
            }
            bp += stride;
        }       
    } else if (minfo.type==_jit_sym_float64) {
        for (i=0,k=arrayoffset;i<cellcount;i++) {
            for (j=0;j<planecount;j++) {
                elements[k++] = (double) ((double *)bp)[j];
            }
            bp += stride;
        }       
    }   
    
    JIT_JAVA_JNI_CALL(env,SetFloatArrayRegion)(env,(jfloatArray)array,arrayoffset,count,elements+arrayoffset); 

    // release array
    if (is_copy) {
        JIT_JAVA_JNI_CALL(env, ReleaseFloatArrayElements)(env,(jfloatArray)array,elements,0);
        checkException(env);
    }
    
    return count;       
}

jint JNICALL jit_java_jitmatrix_copyvectortoarrayplanar_float(JNIEnv *env, jobject obj, jint plane, jint dim, jobject dimoffset, jobject array, jint count, jint arrayoffset);
jint JNICALL jit_java_jitmatrix_copyvectortoarrayplanar_float(JNIEnv *env, jobject obj, jint plane, jint dim, jobject dimoffset, jobject array, jint count, jint arrayoffset)
{
    t_object *o,*mat;
    t_jit_matrix_info minfo;
    jint doa[JIT_MATRIX_MAX_DIMCOUNT];
    jint arraylen;
    jfloat *elements;
    jboolean is_copy; 
    uchar *bp=NULL;
    long i,j,k;
    long stride,planecount,cellcount;
    long tmp;
    
    o = get_jit_java_jitobj(env,obj);
    if(!o||!array)
        return 0;
    
    mat = jit_object_method(o,ps_getmatrix);
    if(!mat)
        return 0;
        
    // setup all our info, common to all copyvector methods
    bp = jit_java_jitmatrix_copyvectorsetup(env,mat,&dim,dimoffset,array,&count,&arrayoffset,&minfo,doa,&arraylen,1);
    if (!bp)
        return 0;
        
    // get array
    elements = JIT_JAVA_JNI_CALL(env, GetFloatArrayElements)(env,(jfloatArray)array,&is_copy);
    //checkException(env); //inefficient?
    
    stride = minfo.dimstride[dim];
    planecount = minfo.planecount;
    cellcount = count;
    bp += (plane%planecount)*jit_matrix_info_typesize(&minfo);
    if (minfo.type==_jit_sym_char) {
        for (i=0,k=arrayoffset;i<cellcount;i++) {
            elements[k++] = (*bp)*(1./255.); 
            bp += stride;
        }       
    } else if (minfo.type==_jit_sym_long) {
        for (i=0,k=arrayoffset;i<cellcount;i++) {
            elements[k++] = (float) *((long *)bp);
            bp += stride;
        }       
    } else if (minfo.type==_jit_sym_float32) {
        for (i=0,k=arrayoffset;i<cellcount;i++) {
            elements[k++] = *((float *)bp);
            bp += stride;
        }       
    } else if (minfo.type==_jit_sym_float64) {
        for (i=0,k=arrayoffset;i<cellcount;i++) {
            elements[k++] = (float) *((double *)bp);
            bp += stride;
        }       
    }   
    
    JIT_JAVA_JNI_CALL(env,SetFloatArrayRegion)(env,(jfloatArray)array,arrayoffset,count,elements+arrayoffset); 

    // release array
    if (is_copy) {
        JIT_JAVA_JNI_CALL(env, ReleaseFloatArrayElements)(env,(jfloatArray)array,elements,0);
        checkException(env);
    }
    
    return count;       
}

jint JNICALL jit_java_jitmatrix_copyvectortoarray_double(JNIEnv *env, jobject obj, jint dim, jobject dimoffset, jobject array, jint count, jint arrayoffset);
jint JNICALL jit_java_jitmatrix_copyvectortoarray_double(JNIEnv *env, jobject obj, jint dim, jobject dimoffset, jobject array, jint count, jint arrayoffset)
{
    t_object *o,*mat;
    t_jit_matrix_info minfo;
    jint doa[JIT_MATRIX_MAX_DIMCOUNT];
    jint arraylen;
    jdouble *elements;
    jboolean is_copy; 
    uchar *bp=NULL;
    long i,j,k;
    long stride,planecount,cellcount;
    long tmp;
    
    o = get_jit_java_jitobj(env,obj);
    if(!o||!array)
        return 0;
    
    mat = jit_object_method(o,ps_getmatrix);
    if(!mat)
        return 0;
        
    // setup all our info, common to all copyvector methods
    bp = jit_java_jitmatrix_copyvectorsetup(env,mat,&dim,dimoffset,array,&count,&arrayoffset,&minfo,doa,&arraylen,0);
    if (!bp)
        return 0;
        
    // get array
    elements = JIT_JAVA_JNI_CALL(env, GetDoubleArrayElements)(env,(jdoubleArray)array,&is_copy);
    //checkException(env); //inefficient?
    
    stride = minfo.dimstride[dim];
    planecount = minfo.planecount;
    cellcount = count/planecount;
    if (minfo.type==_jit_sym_char) {
        for (i=0,k=arrayoffset;i<cellcount;i++) {
            for (j=0;j<planecount;j++) {
                elements[k++] = bp[j]*(1./255.); 
            }
            bp += stride;
        }       
    } else if (minfo.type==_jit_sym_long) {
        for (i=0,k=arrayoffset;i<cellcount;i++) {
            for (j=0;j<planecount;j++) {
                elements[k++] = (double) ((long *)bp)[j];
            }
            bp += stride;
        }       
    } else if (minfo.type==_jit_sym_float32) {
        for (i=0,k=arrayoffset;i<cellcount;i++) {
            for (j=0;j<planecount;j++) {
                elements[k++] = (double) ((float *)bp)[j];
            }
            bp += stride;
        }       
    } else if (minfo.type==_jit_sym_float64) {
        for (i=0,k=arrayoffset;i<cellcount;i++) {
            for (j=0;j<planecount;j++) {
                elements[k++] = ((double *)bp)[j];
            }
            bp += stride;
        }       
    }   
    
    JIT_JAVA_JNI_CALL(env,SetDoubleArrayRegion)(env,(jdoubleArray)array,arrayoffset,count,elements+arrayoffset); 

    // release array
    if (is_copy) {
        JIT_JAVA_JNI_CALL(env, ReleaseDoubleArrayElements)(env,(jdoubleArray)array,elements,0);
        checkException(env);
    }
    
    return count;       
}

jint JNICALL jit_java_jitmatrix_copyvectortoarrayplanar_double(JNIEnv *env, jobject obj, jint plane, jint dim, jobject dimoffset, jobject array, jint count, jint arrayoffset);
jint JNICALL jit_java_jitmatrix_copyvectortoarrayplanar_double(JNIEnv *env, jobject obj, jint plane, jint dim, jobject dimoffset, jobject array, jint count, jint arrayoffset)
{
    t_object *o,*mat;
    t_jit_matrix_info minfo;
    jint doa[JIT_MATRIX_MAX_DIMCOUNT];
    jint arraylen;
    jdouble *elements;
    jboolean is_copy; 
    uchar *bp=NULL;
    long i,j,k;
    long stride,planecount,cellcount;
    long tmp;
    
    o = get_jit_java_jitobj(env,obj);
    if(!o||!array)
        return 0;
    
    mat = jit_object_method(o,ps_getmatrix);
    if(!mat)
        return 0;
        
    // setup all our info, common to all copyvector methods
    bp = jit_java_jitmatrix_copyvectorsetup(env,mat,&dim,dimoffset,array,&count,&arrayoffset,&minfo,doa,&arraylen,1);
    if (!bp)
        return 0;
        
    // get array
    elements = JIT_JAVA_JNI_CALL(env, GetDoubleArrayElements)(env,(jdoubleArray)array,&is_copy);
    //checkException(env); //inefficient?
    
    stride = minfo.dimstride[dim];
    planecount = minfo.planecount;
    cellcount = count;
    bp += (plane%planecount)*jit_matrix_info_typesize(&minfo);
    if (minfo.type==_jit_sym_char) {
        for (i=0,k=arrayoffset;i<cellcount;i++) {
            elements[k++] = *bp *(1./255.); 
            bp += stride;
        }       
    } else if (minfo.type==_jit_sym_long) {
        for (i=0,k=arrayoffset;i<cellcount;i++) {
            elements[k++] = (double)(*((long *)bp));
            bp += stride;
        }       
    } else if (minfo.type==_jit_sym_float32) {
        for (i=0,k=arrayoffset;i<cellcount;i++) {
            elements[k++] = (double)(*(float *)bp);
            bp += stride;
        }       
    } else if (minfo.type==_jit_sym_float64) {
        for (i=0,k=arrayoffset;i<cellcount;i++) {
            elements[k++] = (*(double *)bp);
            bp += stride;
        }       
    }   
    
    JIT_JAVA_JNI_CALL(env,SetDoubleArrayRegion)(env,(jdoubleArray)array,arrayoffset,count,elements+arrayoffset); 

    // release array
    if (is_copy) {
        JIT_JAVA_JNI_CALL(env, ReleaseDoubleArrayElements)(env,(jdoubleArray)array,elements,0);
        checkException(env);
    }
    
    return count;       
}

jint JNICALL jit_java_jitmatrix_copyarraytovector_int(JNIEnv *env, jobject obj, jint dim, jobject dimoffset, jobject array, jint count, jint arrayoffset);
jint JNICALL jit_java_jitmatrix_copyarraytovector_int(JNIEnv *env, jobject obj, jint dim, jobject dimoffset, jobject array, jint count, jint arrayoffset)
{
    t_object *o,*mat;
    t_jit_matrix_info minfo;
    jint doa[JIT_MATRIX_MAX_DIMCOUNT];
    jint arraylen;
    jint *elements;
    jboolean is_copy; 
    uchar *bp=NULL;
    long i,j,k;
    long stride,planecount,cellcount;
    long tmp;
    
    o = get_jit_java_jitobj(env,obj);
    if(!o||!array)
        return 0;
    
    mat = jit_object_method(o,ps_getmatrix);
    if(!mat)
        return 0;
        
    // setup all our info, common to all copyvector methods
    bp = jit_java_jitmatrix_copyvectorsetup(env,mat,&dim,dimoffset,array,&count,&arrayoffset,&minfo,doa,&arraylen,0);
    if (!bp)
        return 0;
        
    // get array
    elements = JIT_JAVA_JNI_CALL(env, GetIntArrayElements)(env,(jintArray)array,&is_copy);
    //checkException(env); //inefficient?
    
    stride = minfo.dimstride[dim];
    planecount = minfo.planecount;
    cellcount = count/planecount;
    if (minfo.type==_jit_sym_char) {
        if (planecount==4) {
            for (i=0,j=0,k=arrayoffset;i<cellcount;i++) {
                tmp = elements[k++];
                bp[j++] = CLAMP(tmp,0,255); 
                tmp = elements[k++];
                bp[j++] = CLAMP(tmp,0,255); 
                tmp = elements[k++];
                bp[j++] = CLAMP(tmp,0,255); 
                tmp = elements[k++];
                bp[j++] = CLAMP(tmp,0,255); 
            }   
        } else {        
            for (i=0,k=arrayoffset;i<cellcount;i++) {
                for (j=0;j<planecount;j++) {
                    tmp = elements[k++];
                    bp[j] = CLAMP(tmp,0,255); 
                }
                bp += stride;
            }
        }       
    } else if (minfo.type==_jit_sym_long) {
        for (i=0,k=arrayoffset;i<cellcount;i++) {
            for (j=0;j<planecount;j++) {
                ((long *)bp)[j] = elements[k++];
            }
            bp += stride;
        }       
    } else if (minfo.type==_jit_sym_float32) {
        for (i=0,k=arrayoffset;i<cellcount;i++) {
            for (j=0;j<planecount;j++) {
                ((float *)bp)[j] = (float) elements[k++];
            }
            bp += stride;
        }       
    } else if (minfo.type==_jit_sym_float64) {
        for (i=0,k=arrayoffset;i<cellcount;i++) {
            for (j=0;j<planecount;j++) {
                ((double *)bp)[j] = (double) elements[k++];
            }
            bp += stride;
        }       
    }   
            
    // release array
    if (is_copy) {
        JIT_JAVA_JNI_CALL(env, ReleaseIntArrayElements)(env,(jintArray)array,elements,0);
        checkException(env);
    }
    
    return count;       
}

jint JNICALL jit_java_jitmatrix_copyarraytovectorplanar_int(JNIEnv *env, jobject obj, jint plane, jint dim, jobject dimoffset, jobject array, jint count, jint arrayoffset);
jint JNICALL jit_java_jitmatrix_copyarraytovectorplanar_int(JNIEnv *env, jobject obj, jint plane, jint dim, jobject dimoffset, jobject array, jint count, jint arrayoffset)
{
    t_object *o,*mat;
    t_jit_matrix_info minfo;
    jint doa[JIT_MATRIX_MAX_DIMCOUNT];
    jint arraylen;
    jint *elements;
    jboolean is_copy; 
    uchar *bp=NULL;
    long i,j,k;
    long stride,planecount,cellcount;
    long tmp;
    
    o = get_jit_java_jitobj(env,obj);
    if(!o||!array)
        return 0;
    
    mat = jit_object_method(o,ps_getmatrix);
    if(!mat)
        return 0;
        
    // setup all our info, common to all copyvector methods
    bp = jit_java_jitmatrix_copyvectorsetup(env,mat,&dim,dimoffset,array,&count,&arrayoffset,&minfo,doa,&arraylen,1);
    if (!bp)
        return 0;
        
    // get array
    elements = JIT_JAVA_JNI_CALL(env, GetIntArrayElements)(env,(jintArray)array,&is_copy);
    //checkException(env); //inefficient?
    
    stride = minfo.dimstride[dim];
    planecount = minfo.planecount;
    cellcount = count;
    bp += (plane%planecount)*jit_matrix_info_typesize(&minfo);
    if (minfo.type==_jit_sym_char) {
        for (i=0,k=arrayoffset;i<cellcount;i++) {
            tmp = elements[k++];
            *bp = CLAMP(tmp,0,255); 
            bp += stride;
        }       
    } else if (minfo.type==_jit_sym_long) {
        for (i=0,k=arrayoffset;i<cellcount;i++) {
            *((long *)bp) = elements[k++];
            bp += stride;
        }       
    } else if (minfo.type==_jit_sym_float32) {
        for (i=0,k=arrayoffset;i<cellcount;i++) {
            *((float *)bp) = (float) elements[k++];
            bp += stride;
        }       
    } else if (minfo.type==_jit_sym_float64) {
        for (i=0,k=arrayoffset;i<cellcount;i++) {
            *((double *)bp) = (double) elements[k++];
            bp += stride;
        }       
    }   
    
    // release array
    if (is_copy) {
        JIT_JAVA_JNI_CALL(env, ReleaseIntArrayElements)(env,(jintArray)array,elements,0);
        checkException(env);
    }
    
    return count;       
}

jint JNICALL jit_java_jitmatrix_copyarraytovector_float(JNIEnv *env, jobject obj, jint dim, jobject dimoffset, jobject array, jint count, jint arrayoffset);
jint JNICALL jit_java_jitmatrix_copyarraytovector_float(JNIEnv *env, jobject obj, jint dim, jobject dimoffset, jobject array, jint count, jint arrayoffset)
{
    t_object *o,*mat;
    t_jit_matrix_info minfo;
    jint doa[JIT_MATRIX_MAX_DIMCOUNT];
    jint arraylen;
    jfloat *elements;
    jboolean is_copy; 
    uchar *bp=NULL;
    long i,j,k;
    long stride,planecount,cellcount;
    long tmp;
    
    o = get_jit_java_jitobj(env,obj);
    if(!o||!array)
        return 0;
    
    mat = jit_object_method(o,ps_getmatrix);
    if(!mat)
        return 0;
        
    // setup all our info, common to all copyvector methods
    bp = jit_java_jitmatrix_copyvectorsetup(env,mat,&dim,dimoffset,array,&count,&arrayoffset,&minfo,doa,&arraylen,0);
    if (!bp)
        return 0;
        
    // get array
    elements = JIT_JAVA_JNI_CALL(env, GetFloatArrayElements)(env,(jfloatArray)array,&is_copy);
    //checkException(env); //inefficient?
    
    stride = minfo.dimstride[dim];
    planecount = minfo.planecount;
    cellcount = count/planecount;
    if (minfo.type==_jit_sym_char) {
        if (planecount==4) {
            for (i=0,j=0,k=0;i<cellcount;i++) {
                tmp = elements[k++]*255.;
                bp[j++] = CLAMP(tmp,0,255); 
                tmp = elements[k++]*255.;
                bp[j++] = CLAMP(tmp,0,255); 
                tmp = elements[k++]*255.;
                bp[j++] = CLAMP(tmp,0,255); 
                tmp = elements[k++]*255.;
                bp[j++] = CLAMP(tmp,0,255); 
            }
        } else {        
            for (i=0,k=arrayoffset;i<cellcount;i++) {
                for (j=0;j<planecount;j++) {
                    tmp = elements[k++]*255.;
                    bp[j] = CLAMP(tmp,0,255); 
                }
                bp += stride;
            }
        }       
    } else if (minfo.type==_jit_sym_long) {
        for (i=0,k=arrayoffset;i<cellcount;i++) {
            for (j=0;j<planecount;j++) {
                ((long *)bp)[j] = (long) elements[k++];
            }
            bp += stride;
        }       
    } else if (minfo.type==_jit_sym_float32) {
        for (i=0,k=arrayoffset;i<cellcount;i++) {
            for (j=0;j<planecount;j++) {
                ((float *)bp)[j] = (float) elements[k++];
            }
            bp += stride;
        }       
    } else if (minfo.type==_jit_sym_float64) {
        for (i=0,k=arrayoffset;i<cellcount;i++) {
            for (j=0;j<planecount;j++) {
                ((double *)bp)[j] = (double) elements[k++];
            }
            bp += stride;
        }       
    }   
    
    // release array
    if (is_copy) {
        JIT_JAVA_JNI_CALL(env, ReleaseFloatArrayElements)(env,(jfloatArray)array,elements,0);
        checkException(env);
    }
    
    return count;       
}

jint JNICALL jit_java_jitmatrix_copyarraytovectorplanar_float(JNIEnv *env, jobject obj, jint plane, jint dim, jobject dimoffset, jobject array, jint count, jint arrayoffset);
jint JNICALL jit_java_jitmatrix_copyarraytovectorplanar_float(JNIEnv *env, jobject obj, jint plane, jint dim, jobject dimoffset, jobject array, jint count, jint arrayoffset)
{
    t_object *o,*mat;
    t_jit_matrix_info minfo;
    jint doa[JIT_MATRIX_MAX_DIMCOUNT];
    jint arraylen;
    jfloat *elements;
    jboolean is_copy; 
    uchar *bp=NULL;
    long i,j,k;
    long stride,planecount,cellcount;
    long tmp;
    
    o = get_jit_java_jitobj(env,obj);
    if(!o||!array)
        return 0;
    
    mat = jit_object_method(o,ps_getmatrix);
    if(!mat)
        return 0;
        
    // setup all our info, common to all copyvector methods
    bp = jit_java_jitmatrix_copyvectorsetup(env,mat,&dim,dimoffset,array,&count,&arrayoffset,&minfo,doa,&arraylen,1);
    if (!bp)
        return 0;
        
    // get array
    elements = JIT_JAVA_JNI_CALL(env, GetFloatArrayElements)(env,(jfloatArray)array,&is_copy);
    //checkException(env); //inefficient?
    
    stride = minfo.dimstride[dim];
    planecount = minfo.planecount;
    cellcount = count;
    bp += (plane%planecount)*jit_matrix_info_typesize(&minfo);
    if (minfo.type==_jit_sym_char) {
        for (i=0,k=arrayoffset;i<cellcount;i++) {
            tmp = elements[k++]*255.;
            *bp = CLAMP(tmp,0,255); 
            bp += stride;
        }       
    } else if (minfo.type==_jit_sym_long) {
        for (i=0,k=arrayoffset;i<cellcount;i++) {
            *((long *)bp) = (long) elements[k++];
            bp += stride;
        }       
    } else if (minfo.type==_jit_sym_float32) {
        for (i=0,k=arrayoffset;i<cellcount;i++) {
            *((float *)bp) = (float) elements[k++];
            bp += stride;
        }       
    } else if (minfo.type==_jit_sym_float64) {
        for (i=0,k=arrayoffset;i<cellcount;i++) {
            *((double *)bp) = (double) elements[k++];
            bp += stride;
        }       
    }   
    
    // release array
    if (is_copy) {
        JIT_JAVA_JNI_CALL(env, ReleaseFloatArrayElements)(env,(jfloatArray)array,elements,0);
        checkException(env);
    }
    
    return count;       
}

jint JNICALL jit_java_jitmatrix_copyarraytovector_double(JNIEnv *env, jobject obj, jint dim, jobject dimoffset, jobject array, jint count, jint arrayoffset);
jint JNICALL jit_java_jitmatrix_copyarraytovector_double(JNIEnv *env, jobject obj, jint dim, jobject dimoffset, jobject array, jint count, jint arrayoffset)
{
    t_object *o,*mat;
    t_jit_matrix_info minfo;
    jint doa[JIT_MATRIX_MAX_DIMCOUNT];
    jint arraylen;
    jdouble *elements;
    jboolean is_copy; 
    uchar *bp=NULL;
    long i,j,k;
    long stride,planecount,cellcount;
    long tmp;
    
    o = get_jit_java_jitobj(env,obj);
    if(!o||!array)
        return 0;
    
    mat = jit_object_method(o,ps_getmatrix);
    if(!mat)
        return 0;
        
    // setup all our info, common to all copyvector methods
    bp = jit_java_jitmatrix_copyvectorsetup(env,mat,&dim,dimoffset,array,&count,&arrayoffset,&minfo,doa,&arraylen,0);
    if (!bp)
        return 0;
        
    // get array
    elements = JIT_JAVA_JNI_CALL(env, GetDoubleArrayElements)(env,(jdoubleArray)array,&is_copy);
    //checkException(env); //inefficient?
    
    stride = minfo.dimstride[dim];
    planecount = minfo.planecount;
    cellcount = count/planecount;
    if (minfo.type==_jit_sym_char) {
        for (i=0,k=arrayoffset;i<cellcount;i++) {
            for (j=0;j<planecount;j++) {
                tmp = elements[k++]*255.;
                bp[j] = CLAMP(tmp,0,255); 
            }
            bp += stride;
        }       
    } else if (minfo.type==_jit_sym_long) {
        for (i=0,k=arrayoffset;i<cellcount;i++) {
            for (j=0;j<planecount;j++) {
                ((long *)bp)[j] = (long) elements[k++];
            }
            bp += stride;
        }       
    } else if (minfo.type==_jit_sym_float32) {
        for (i=0,k=arrayoffset;i<cellcount;i++) {
            for (j=0;j<planecount;j++) {
                ((float *)bp)[j] = (float) elements[k++];
            }
            bp += stride;
        }       
    } else if (minfo.type==_jit_sym_float64) {
        for (i=0,k=arrayoffset;i<cellcount;i++) {
            for (j=0;j<planecount;j++) {
                ((double *)bp)[j] = (double) elements[k++];
            }
            bp += stride;
        }       
    }   
    
    // release array
    if (is_copy) {
        JIT_JAVA_JNI_CALL(env, ReleaseDoubleArrayElements)(env,(jdoubleArray)array,elements,0);
        checkException(env);
    }
    
    return count;       
}

jint JNICALL jit_java_jitmatrix_copyarraytovectorplanar_double(JNIEnv *env, jobject obj, jint plane, jint dim, jobject dimoffset, jobject array, jint count, jint arrayoffset);
jint JNICALL jit_java_jitmatrix_copyarraytovectorplanar_double(JNIEnv *env, jobject obj, jint plane, jint dim, jobject dimoffset, jobject array, jint count, jint arrayoffset)
{
    t_object *o,*mat;
    t_jit_matrix_info minfo;
    jint doa[JIT_MATRIX_MAX_DIMCOUNT];
    jint arraylen;
    jdouble *elements;
    jboolean is_copy; 
    uchar *bp=NULL;
    long i,j,k;
    long stride,planecount,cellcount;
    long tmp;
    
    o = get_jit_java_jitobj(env,obj);
    if(!o||!array)
        return 0;
    
    mat = jit_object_method(o,ps_getmatrix);
    if(!mat)
        return 0;
        
    // setup all our info, common to all copyvector methods
    bp = jit_java_jitmatrix_copyvectorsetup(env,mat,&dim,dimoffset,array,&count,&arrayoffset,&minfo,doa,&arraylen,1);
    if (!bp)
        return 0;
        
    // get array
    elements = JIT_JAVA_JNI_CALL(env, GetDoubleArrayElements)(env,(jdoubleArray)array,&is_copy);
    //checkException(env); //inefficient?
    
    stride = minfo.dimstride[dim];
    planecount = minfo.planecount;
    cellcount = count;
    bp += (plane%planecount)*jit_matrix_info_typesize(&minfo);
    if (minfo.type==_jit_sym_char) {
        for (i=0,k=arrayoffset;i<cellcount;i++) {
            tmp = elements[k++]*255.;
            *bp = CLAMP(tmp,0,255); 
            bp += stride;
        }       
    } else if (minfo.type==_jit_sym_long) {
        for (i=0,k=arrayoffset;i<cellcount;i++) {
            *((long *)bp) = (long) elements[k++];
            bp += stride;
        }       
    } else if (minfo.type==_jit_sym_float32) {
        for (i=0,k=arrayoffset;i<cellcount;i++) {
            *((float *)bp) = (float) elements[k++];
            bp += stride;
        }       
    } else if (minfo.type==_jit_sym_float64) {
        for (i=0,k=arrayoffset;i<cellcount;i++) {
            *((double *)bp) = (double) elements[k++];
            bp += stride;
        }       
    }   
    
    // release array
    if (is_copy) {
        JIT_JAVA_JNI_CALL(env, ReleaseDoubleArrayElements)(env,(jdoubleArray)array,elements,0);
        checkException(env);
    }
    
    return count;       
}

void jit_java_jitmatrix_copypackedintarraytomatrix_ndim(uchar *bp, jint *data, long *dim, long dimcount, long *dimstride, long *current, long intarraylen);
jint JNICALL jit_java_jitmatrix_copypackedintarraytomatrix(JNIEnv *env, jobject obj, jobject intarray);
jint JNICALL jit_java_jitmatrix_copypackedintarraytomatrix(JNIEnv *env, jobject obj, jobject intarray)
{
    t_object *o,*mat;
    t_jit_matrix_info minfo;
    uchar *bp = NULL;
    long intarraylen,current,i,dimcount[JIT_MATRIX_MAX_DIMCOUNT];
    jint *data;
    jboolean is_copy;
    
    o = get_jit_java_jitobj(env,obj);
    if(!o||!intarray)
        return 0;
    
    mat = jit_object_method(o,ps_getmatrix);
    if(!mat)
        return 0;

    // get pointer and matrix info
    jit_object_method(mat,_jit_sym_getinfo,&minfo);
    jit_object_method(mat,_jit_sym_getdata,&bp);
    if (!bp)
        return 0;
    if ((minfo.type != _jit_sym_char)||(minfo.planecount != 4))
        return 0;
        
    intarraylen = JIT_JAVA_JNI_CALL(env,GetArrayLength)(env,intarray);
    data = JIT_JAVA_JNI_CALL(env, GetIntArrayElements)(env,(jintArray)intarray,&is_copy);
    
    current = 0;
    
    jit_java_jitmatrix_copypackedintarraytomatrix_ndim(bp, data, minfo.dim, minfo.dimcount, minfo.dimstride, &current, intarraylen);

    if (is_copy) {
        JIT_JAVA_JNI_CALL(env, ReleaseIntArrayElements)(env,(jintArray)intarray,data,0);

        checkException(env);
    }

    
    return current;
}

void jit_java_jitmatrix_copypackedintarraytomatrix_ndim( uchar *bp, jint *data, long *dim, long dimcount, long *dimstride, long *current, long intarraylen  )
{
    long i,j;
    uchar *bp2;
    switch (dimcount)
    {
        case 1: 
            dim[1] = 1;
        case 2:
            for (j=0; (j<dim[1])&&(*current < intarraylen); j++)
                for (i=0; (i<dim[0])&&(*current < intarraylen); i++)
                {
                    long temp = data[(*current)++];
                    *((jint *)(bp + dimstride[0]*i + dimstride[1]*j)) = BE_I32(temp);
                }
            
            break;
        default:
            for (i=0;(i<dim[dimcount-1])&&(*current < intarraylen);i++) 
            {
                bp2 = bp + i*dimstride[dimcount-1];
                jit_java_jitmatrix_copypackedintarraytomatrix_ndim(bp2, data, dim, dimcount-1, dimstride, current, intarraylen);            
            }
            break;
    }   
}


////////////////////////////////////////////////////

////
/// full matrix copies

////////////////////////////////////////////////


jint JNICALL jit_java_jitmatrix_copymatrixtoarray(JNIEnv *env, jobject obj, jobject jarray, t_symbol *type);

jint JNICALL jit_java_jitmatrix_copymatrixtoarray_int(JNIEnv *env, jobject obj, jobject jarray);
jint JNICALL jit_java_jitmatrix_copymatrixtoarray_int(JNIEnv *env, jobject obj, jobject jarray)
{
    return jit_java_jitmatrix_copymatrixtoarray(env, obj, jarray, _jit_sym_long);
}
jint JNICALL jit_java_jitmatrix_copymatrixtoarray_float(JNIEnv *env, jobject obj, jobject jarray);
jint JNICALL jit_java_jitmatrix_copymatrixtoarray_float(JNIEnv *env, jobject obj, jobject jarray)
{
    return jit_java_jitmatrix_copymatrixtoarray(env, obj, jarray, _jit_sym_float32);
}
jint JNICALL jit_java_jitmatrix_copymatrixtoarray_double(JNIEnv *env, jobject obj, jobject jarray);
jint JNICALL jit_java_jitmatrix_copymatrixtoarray_double(JNIEnv *env, jobject obj, jobject jarray)
{
    return jit_java_jitmatrix_copymatrixtoarray(env, obj, jarray, _jit_sym_float64);
}

void jit_java_jitmatrix_copymatrixtoarray_ndim( uchar *bp, void *data, long *dim, long dimcount, long *dimstride, long planecount,
                                               long *current, long jarraylen, t_symbol *matrixtype, t_symbol *jarraytype  );

jint JNICALL jit_java_jitmatrix_copymatrixtoarray(JNIEnv *env, jobject obj, jobject jarray, t_symbol *type)
{
    t_object *o,*mat;
    t_jit_matrix_info minfo;
    uchar *bp = NULL;
    long matrixlen,jarraylen,current,i,dimcount[JIT_MATRIX_MAX_DIMCOUNT];
    void *jdata;
    jboolean is_copy;
    
    o = get_jit_java_jitobj(env,obj);
    if(!o||!jarray)
        return 0;
    
    mat = jit_object_method(o,ps_getmatrix);
    if(!mat)
        return 0;

    // get pointer and matrix info
    jit_object_method(mat,_jit_sym_getinfo,&minfo);
    jit_object_method(mat,_jit_sym_getdata,&bp);
    if (!bp)
        return 0;

    //get length and data pointer to array passed in by Java
    jarraylen = JIT_JAVA_JNI_CALL(env,GetArrayLength)(env,jarray);
    
    current = 0;
    
    matrixlen = minfo.planecount;
    for (i=0;i<minfo.dimcount;i++)
        matrixlen *= minfo.dim[i];
        
    // support larger, but not smaller arrays -jkc
    if (jarraylen < matrixlen)
        return 0;

    // had to move this after our test and return, since if is_copy==TRUE and 
    // the arraylen isn't the right size, we have a memory leak. -jkc
    if (type == _jit_sym_long)
        jdata = JIT_JAVA_JNI_CALL(env, GetIntArrayElements)(env,(jintArray)jarray,&is_copy);
    else if (type == _jit_sym_float32)
        jdata = JIT_JAVA_JNI_CALL(env, GetFloatArrayElements)(env, (jfloatArray)jarray,&is_copy);
    else if (type == _jit_sym_float64)
        jdata = JIT_JAVA_JNI_CALL(env, GetDoubleArrayElements)(env, (jdoubleArray)jarray,&is_copy);


    jit_java_jitmatrix_copymatrixtoarray_ndim(bp, jdata, minfo.dim, minfo.dimcount, minfo.dimstride, minfo.planecount, 
                                                &current, jarraylen, minfo.type, type);

    if (type == _jit_sym_long)
        JIT_JAVA_JNI_CALL(env,SetIntArrayRegion)(env,(jintArray)jarray,0,jarraylen,jdata);
    else if (type == _jit_sym_float32)
        JIT_JAVA_JNI_CALL(env,SetFloatArrayRegion)(env,(jfloatArray)jarray,0,jarraylen,jdata);
    else if (type == _jit_sym_float64)
        JIT_JAVA_JNI_CALL(env,SetDoubleArrayRegion)(env,(jdoubleArray)jarray,0,jarraylen,jdata);

    if (is_copy) {
        if (type == _jit_sym_long)
            JIT_JAVA_JNI_CALL(env, ReleaseIntArrayElements)(env,(jintArray)jarray,jdata,0);
        else if (type == _jit_sym_float32)
            JIT_JAVA_JNI_CALL(env, ReleaseFloatArrayElements)(env,(jfloatArray)jarray,jdata,0);
        else if (type == _jit_sym_float64)
            JIT_JAVA_JNI_CALL(env, ReleaseDoubleArrayElements)(env,(jdoubleArray)jarray,jdata,0);

        checkException(env);
    }
    
    return current;
}


void jit_java_jitmatrix_copymatrixtoarray_ndim( uchar *bp, void *data, long *dim, long dimcount, long *dimstride, long planecount,
                                               long *current, long jarraylen, t_symbol *matrixtype, t_symbol *jarraytype  )
{
    long i,j,p;
    uchar *bp2;
    long *ldata = data;
    float *fdata = data;
    double *ddata = data;
    switch (dimcount)
    {
        case 1: 
            dim[1] = 1;
        case 2:

            for (j=0; j<dim[1]; j++)
                for (i=0; i<dim[0]; i++)
                    for (p=0;p<planecount;p++)
                    {
                        //this code would traditionally be considered slow, but hooray for branch prediction!!

                        if      ((matrixtype == _jit_sym_char) && (jarraytype == _jit_sym_long))
                            *(ldata + (*current)++) = (long)(*(uchar *)(bp + p + dimstride[0]*i + dimstride[1]*j));
                        else if ((matrixtype == _jit_sym_char) && (jarraytype == _jit_sym_float32))
                            *(fdata + (*current)++) = (float)(*(uchar *)(bp + p + dimstride[0]*i + dimstride[1]*j));
                        else if ((matrixtype == _jit_sym_char) && (jarraytype == _jit_sym_float64))
                            *(ddata + (*current)++) = (double)(*(uchar *)(bp + p + dimstride[0]*i + dimstride[1]*j));
                        else if ((matrixtype == _jit_sym_long) && (jarraytype == _jit_sym_long))
                            *(ldata + (*current)++) = *(long *)(bp + p*sizeof(long) + dimstride[0]*i + dimstride[1]*j);
                        else if ((matrixtype == _jit_sym_long) && (jarraytype == _jit_sym_float32))
                            *(fdata + (*current)++) = (float)(*(long *)(bp + p*sizeof(long) + dimstride[0]*i + dimstride[1]*j));
                        else if ((matrixtype == _jit_sym_long) && (jarraytype == _jit_sym_float64))
                            *(ddata + (*current)++) = (double)(*(long *)(bp + p*sizeof(long) + dimstride[0]*i + dimstride[1]*j));
                        else if ((matrixtype == _jit_sym_float32) && (jarraytype == _jit_sym_long))
                            *(ldata + (*current)++) = (long)(*(float *)(bp + p*sizeof(float) + dimstride[0]*i + dimstride[1]*j));
                        else if ((matrixtype == _jit_sym_float32) && (jarraytype == _jit_sym_float32))
                            *(fdata + (*current)++) = *(float *)(bp + p*sizeof(float) + dimstride[0]*i + dimstride[1]*j);
                        else if ((matrixtype == _jit_sym_float32) && (jarraytype == _jit_sym_float64))
                            *(ddata + (*current)++) = (double)(*(float *)(bp + p*sizeof(float) + dimstride[0]*i + dimstride[1]*j));
                        else if ((matrixtype == _jit_sym_float64) && (jarraytype == _jit_sym_long))
                            *(ldata + (*current)++) = (long)(*(double *)(bp + p*sizeof(double) + dimstride[0]*i + dimstride[1]*j));
                        else if ((matrixtype == _jit_sym_float64) && (jarraytype == _jit_sym_float32))
                            *(fdata + (*current)++) = (float)(*(double *)(bp + p*sizeof(float) + dimstride[0]*i + dimstride[1]*j));
                        else if ((matrixtype == _jit_sym_float64) && (jarraytype == _jit_sym_float64))
                            *(ddata + (*current)++) = *(double *)(bp + p*sizeof(float) + dimstride[0]*i + dimstride[1]*j);
                    }
            
            break;
        default:
            for (i=0;(i<dim[dimcount-1])&&(*current < jarraylen);i++) 
            {
                bp2 = bp + i*dimstride[dimcount-1];
                jit_java_jitmatrix_copymatrixtoarray_ndim(bp2, data, dim, dimcount-1, dimstride, planecount,
                                                            current, jarraylen, matrixtype, jarraytype);            
            }
            break;
    }
}



jint JNICALL jit_java_jitmatrix_copyarraytomatrix(JNIEnv *env, jobject obj, jobject jarray, t_symbol *type);

jint JNICALL jit_java_jitmatrix_copyarraytomatrix_int(JNIEnv *env, jobject obj, jobject jarray);
jint JNICALL jit_java_jitmatrix_copyarraytomatrix_int(JNIEnv *env, jobject obj, jobject jarray)
{
    return jit_java_jitmatrix_copyarraytomatrix(env, obj, jarray, _jit_sym_long);
}
jint JNICALL jit_java_jitmatrix_copyarraytomatrix_float(JNIEnv *env, jobject obj, jobject jarray);
jint JNICALL jit_java_jitmatrix_copyarraytomatrix_float(JNIEnv *env, jobject obj, jobject jarray)
{
    return jit_java_jitmatrix_copyarraytomatrix(env, obj, jarray, _jit_sym_float32);
}
jint JNICALL jit_java_jitmatrix_copyarraytomatrix_double(JNIEnv *env, jobject obj, jobject jarray);
jint JNICALL jit_java_jitmatrix_copyarraytomatrix_double(JNIEnv *env, jobject obj, jobject jarray)
{
    return jit_java_jitmatrix_copyarraytomatrix(env, obj, jarray, _jit_sym_float64);
}

void jit_java_jitmatrix_copyarraytomatrix_ndim( void *bp, void *data, long *dim, long dimcount, long *dimstride, long planecount,
                                               long *current, long jarraylen, t_symbol *matrixtype, t_symbol *jarraytype  );

jint JNICALL jit_java_jitmatrix_copyarraytomatrix(JNIEnv *env, jobject obj, jobject jarray, t_symbol *type)
{
    t_object *o,*mat;
    t_jit_matrix_info minfo;
    uchar *bp = NULL;
    long matrixlen,jarraylen,current,i,dimcount[JIT_MATRIX_MAX_DIMCOUNT];
    void *jdata;
    jboolean is_copy;
    
    o = get_jit_java_jitobj(env,obj);
    if(!o||!jarray)
        return 0;
    
    mat = jit_object_method(o,ps_getmatrix);
    if(!mat)
        return 0;

    // get pointer and matrix info
    jit_object_method(mat,_jit_sym_getinfo,&minfo);
    jit_object_method(mat,_jit_sym_getdata,&bp);
    if (!bp)
        return 0;

    //get length and data pointer to array passed in by Java
    jarraylen = JIT_JAVA_JNI_CALL(env,GetArrayLength)(env,jarray);  
    current = 0;
    
    matrixlen = minfo.planecount;
    for (i=0;i<minfo.dimcount;i++)
        matrixlen *= minfo.dim[i];
    if (jarraylen != matrixlen)
        return 0;

    if (type == _jit_sym_long)
        jdata = JIT_JAVA_JNI_CALL(env, GetIntArrayElements)(env,(jintArray)jarray,&is_copy);
    else if (type == _jit_sym_float32)
        jdata = JIT_JAVA_JNI_CALL(env, GetFloatArrayElements)(env, (jfloatArray)jarray,&is_copy);
    else if (type == _jit_sym_float64)
        jdata = JIT_JAVA_JNI_CALL(env, GetDoubleArrayElements)(env, (jdoubleArray)jarray,&is_copy);

    jit_java_jitmatrix_copyarraytomatrix_ndim(bp, jdata, minfo.dim, minfo.dimcount, minfo.dimstride, minfo.planecount, 
                                                &current, jarraylen, minfo.type, type);

    if (is_copy) {
        if (type == _jit_sym_long)
            JIT_JAVA_JNI_CALL(env, ReleaseIntArrayElements)(env,(jintArray)jarray,jdata,0);
        else if (type == _jit_sym_float32)
            JIT_JAVA_JNI_CALL(env, ReleaseFloatArrayElements)(env,(jfloatArray)jarray,jdata,0);
        else if (type == _jit_sym_float64)
            JIT_JAVA_JNI_CALL(env, ReleaseDoubleArrayElements)(env,(jdoubleArray)jarray,jdata,0);

        checkException(env);
    }
    
    return current;
}


void jit_java_jitmatrix_copyarraytomatrix_ndim( void *bp, void *data, long *dim, long dimcount, long *dimstride, long planecount,
                                               long *current, long jarraylen, t_symbol *matrixtype, t_symbol *jarraytype  )
{
    long i,j,p;
    uchar *bp2;
    long *ldata = data;
    float *fdata = data;
    double *ddata = data;
    uchar *cbp = bp;
    long *lbp = bp;
    float *fbp = bp;
    double *dbp = bp;
    switch (dimcount)
    {
        case 1: 
            dim[1] = 1;
        case 2:

            for (j=0; j<dim[1]; j++)
                for (i=0; i<dim[0]; i++)
                    for (p=0;p<planecount;p++)
                    {
                        //this code would traditionally be considered slow, but hooray for branch prediction!!

                        if  ((matrixtype == _jit_sym_char) && (jarraytype == _jit_sym_long))
                            *(cbp + p + dimstride[0]*i + dimstride[1]*j) = *(ldata + (*current)++);
                        else if ((matrixtype == _jit_sym_char) && (jarraytype == _jit_sym_float32))
                            *(cbp + p + dimstride[0]*i + dimstride[1]*j) = *(fdata + (*current)++);
                        else if ((matrixtype == _jit_sym_char) && (jarraytype == _jit_sym_float64))
                            *(cbp + p + dimstride[0]*i + dimstride[1]*j) = *(ddata + (*current)++);
                        else if ((matrixtype == _jit_sym_long) && (jarraytype == _jit_sym_long))
                            *(lbp + p + dimstride[0]*i/sizeof(long) + dimstride[1]/sizeof(long)*j) = *(ldata + (*current)++);
                        else if ((matrixtype == _jit_sym_long) && (jarraytype == _jit_sym_float32))
                            *(lbp + p + dimstride[0]*i/sizeof(long) + dimstride[1]/sizeof(long)*j) = *(fdata + (*current)++);
                        else if ((matrixtype == _jit_sym_long) && (jarraytype == _jit_sym_float64))
                            *(lbp + p + dimstride[0]*i/sizeof(long) + dimstride[1]/sizeof(long)*j) = *(ddata + (*current)++);
                        else if ((matrixtype == _jit_sym_float32) && (jarraytype == _jit_sym_long))
                            *(fbp + p + dimstride[0]*i/sizeof(float) + dimstride[1]/sizeof(float)*j) = *(ldata + (*current)++);
                        else if ((matrixtype == _jit_sym_float32) && (jarraytype == _jit_sym_float32))
                            *(fbp + p + dimstride[0]*i/sizeof(float) + dimstride[1]/sizeof(float)*j) = *(fdata + (*current)++);
                        else if ((matrixtype == _jit_sym_float32) && (jarraytype == _jit_sym_float64))
                            *(fbp + p + dimstride[0]*i/sizeof(float) + dimstride[1]/sizeof(float)*j) = *(ddata + (*current)++);
                        else if ((matrixtype == _jit_sym_float64) && (jarraytype == _jit_sym_long))
                            *(dbp + p + dimstride[0]*i/sizeof(double) + dimstride[1]/sizeof(double)*j) = *(ldata + (*current)++);
                        else if ((matrixtype == _jit_sym_float64) && (jarraytype == _jit_sym_float32))
                            *(dbp + p + dimstride[0]*i/sizeof(double) + dimstride[1]/sizeof(double)*j) = *(fdata + (*current)++);
                        else if ((matrixtype == _jit_sym_float64) && (jarraytype == _jit_sym_float64))
                            *(dbp + p + dimstride[0]*i/sizeof(double) + dimstride[1]/sizeof(double)*j) = *(ddata + (*current)++);
                    }
            
            break;
        default:
            for (i=0;(i<dim[dimcount-1])&&(*current < jarraylen);i++) 
            {
                bp2 = (void *)((char *)(bp) + i*dimstride[dimcount-1]);
                jit_java_jitmatrix_copyarraytomatrix_ndim(bp2, data, dim, dimcount-1, dimstride, planecount,
                                                            current, jarraylen, matrixtype, jarraytype);            
            }
            break;
    }
}




t_jit_err jit_java_jitmatrix_init(void)
{
    JNIEnv *env=NULL;
    t_jit_err err = JIT_ERR_GENERIC;
    THREADENV(env);
    
    ps_getmatrix    = gensym("getmatrix");
    ps_getcell      = gensym("getcell");
    ps_setall       = gensym("setall");
    ps_setcell      = gensym("setcell");
    ps_setcell3d    = gensym("setcell3d");
    ps_val          = gensym("val");
    ps_plane        = gensym("plane");

    JIT_JAVA_JNI_CALL(env,PushLocalFrame)(env,JIT_JAVA_FRAME_SIZE);

    g_jit_java_jitmatrix_clazz =  jit_java_getclassbyname(env, JIT_JAVA_JITMATRIX_CLASSNAME);
    checkException(env);
    jit_java_jitmatrix_register_natives(env,g_jit_java_jitmatrix_clazz);
    checkException(env);

    err = JIT_ERR_NONE;
    JIT_JAVA_JNI_CALL(env,PopLocalFrame)(env,NULL);
    return err;
}

void jit_java_jitmatrix_register_natives(JNIEnv *env, jclass clazz)
{
    int i,count=0;
    JNINativeMethod methods[] = 
    {
        
        // getcell methods
        //public native Atom[] getcell3d(int x, int y, int z);          
        { "getcell3d","(III)[Lcom/cycling74/max/Atom;",jit_java_jitmatrix_getcell3d_atom },
        //public native int[] getcellInt(int[] position);
        { "getcellInt","([I)[I",jit_java_jitmatrix_getcell_int },
        //public native int[] getcell3dInt(int x, int y, int z);            
        { "getcell3dInt","(III)[I",jit_java_jitmatrix_getcell3d_int },
        //public native float[] getcellFloat(int[] position);
        { "getcellFloat","([I)[F",jit_java_jitmatrix_getcell_float },
        //public native float[] getcell3dFloat(int x, int y, int z);            
        { "getcell3dFloat","(III)[F",jit_java_jitmatrix_getcell3d_float },
        //public native double[] getcellDouble(int[] position);
        { "getcellDouble","([I)[D",jit_java_jitmatrix_getcell_double },
        //public native double[] getcell3dDouble(int x, int y, int z);          
        { "getcell3dDouble","(III)[D",jit_java_jitmatrix_getcell3d_double },
        
        // setcell methods
        //public native void setall(double[] vals);
        { "setall","([D)V",jit_java_jitmatrix_setall_double },
        //public native void setcell(int[] position, int[] vals);
        { "setcell","([I[I)V",jit_java_jitmatrix_setcell_int },
        //public native void setcell(int[] position, float[] vals);
        { "setcell","([I[F)V",jit_java_jitmatrix_setcell_float },
        //public native void setcell(int[] position, double[] vals);
        { "setcell","([I[D)V",jit_java_jitmatrix_setcell_double },
        //public native void setcell(int[] position, int plane, int val);
        { "setcell","([III)V",jit_java_jitmatrix_setcell_plane_int },
        //public native void setcell(int[] position, int plane, float val);
        { "setcell","([IIF)V",jit_java_jitmatrix_setcell_plane_float },
        //public native void setcell(int[] position, int plane, double val);
        { "setcell","([IID)V",jit_java_jitmatrix_setcell_plane_double },        
        //public native void setcell3d(int x, int y, int z, int[] vals);
        { "setcell3d","(III[I)V",jit_java_jitmatrix_setcell3d_int },
        //public native void setcell3d(int x, int y, int z, float[] vals);
        { "setcell3d","(III[F)V",jit_java_jitmatrix_setcell3d_float },
        //public native void setcell3d(int x, int y, int z, double[] vals);
        { "setcell3d","(III[D)V",jit_java_jitmatrix_setcell3d_double },

        // vector copy methods
        //public native int copyVectorToArray(int dim, int[] offset, int[] array, int count, int arrayoffset);  
        { "copyVectorToArray","(I[I[III)I",jit_java_jitmatrix_copyvectortoarray_int },
        //public native int copyVectorToArray(int dim, int[] offset, float[] array, int count, int arrayoffset);    
        { "copyVectorToArray","(I[I[FII)I",jit_java_jitmatrix_copyvectortoarray_float },
        //public native int copyVectorToArray(int dim, int[] offset, double[] array, int count, int arrayoffset);   
        { "copyVectorToArray","(I[I[DII)I",jit_java_jitmatrix_copyvectortoarray_double },
        //public native int copyVectorToArrayPlanar(int plane, int dim, int[] offset, int[] array, int count, int arrayoffset); 
        { "copyVectorToArrayPlanar","(II[I[III)I",jit_java_jitmatrix_copyvectortoarrayplanar_int },
        //public native int copyVectorToArrayPlanar(int plane, int dim, int[] offset, float[] array, int count, int arrayoffset);   
        { "copyVectorToArrayPlanar","(II[I[FII)I",jit_java_jitmatrix_copyvectortoarrayplanar_float },
        //public native int copyVectorToArrayPlanar(int plane, int dim, int[] offset, double[] array, int count, int arrayoffset);  
        { "copyVectorToArrayPlanar","(II[I[DII)I",jit_java_jitmatrix_copyvectortoarrayplanar_double },
        //public native int copyArrayToVector(int dim, int[] offset, int[] array, int count, int arrayoffset);  
        { "copyArrayToVector","(I[I[III)I",jit_java_jitmatrix_copyarraytovector_int },
        //public native int copyArrayToVector(int dim, int[] offset, float[] array, int count, int arrayoffset);    
        { "copyArrayToVector","(I[I[FII)I",jit_java_jitmatrix_copyarraytovector_float },
        //public native int copyArrayToVector(int dim, int[] offset, double[] array, int count, int arrayoffset);   
        { "copyArrayToVector","(I[I[DII)I",jit_java_jitmatrix_copyarraytovector_double },
        //public native int copyArrayToVectorPlanar(int plane, int dim, int[] offset, int[] array, int count, int arrayoffset); 
        { "copyArrayToVectorPlanar","(II[I[III)I",jit_java_jitmatrix_copyarraytovectorplanar_int },
        //public native int copyArrayToVectorPlanar(int plane, int dim, int[] offset, float[] array, int count, int arrayoffset);   
        { "copyArrayToVectorPlanar","(II[I[FII)I",jit_java_jitmatrix_copyarraytovectorplanar_float },
        //public native int copyArrayToVectorPlanar(int plane, int dim, int[] offset, double[] array, int count, int arrayoffset);  
        { "copyArrayToVectorPlanar","(II[I[DII)I",jit_java_jitmatrix_copyarraytovectorplanar_double },
        
        {"copyPackedIntArrayToMatrix","([I)I",jit_java_jitmatrix_copypackedintarraytomatrix },

        { "copyMatrixToArray", "([I)I", jit_java_jitmatrix_copymatrixtoarray_int },
        { "copyMatrixToArray", "([F)I", jit_java_jitmatrix_copymatrixtoarray_float },
        { "copyMatrixToArray", "([D)I", jit_java_jitmatrix_copymatrixtoarray_double },

        { "copyArrayToMatrix", "([I)I", jit_java_jitmatrix_copyarraytomatrix_int },
        { "copyArrayToMatrix", "([F)I", jit_java_jitmatrix_copyarraytomatrix_float },
        { "copyArrayToMatrix", "([D)I", jit_java_jitmatrix_copyarraytomatrix_double },

        // buffered image methods?
        // TODO
        
        // NIO methods?
        // TODO
        
        { NULL, NULL, NULL } 
    };
   
    if (!clazz)
        return;
    while (methods[count].name) count++; 
    JIT_JAVA_JNI_CALL(env,RegisterNatives)(env,clazz,methods,count);
    checkException(env);  
}

Copyright © 2008, Cycling '74