Max 5 API Reference

jit.javaob.c

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

extern long _cfm_in_ub;

JavaVM *g_jvm=NULL;
#if (JIT_JAVA_USE_CFM)
t_cfm_jni_env *g_jenv=NULL;
t_cfm_invoke_interface *g_jvm_invoke=NULL;
#endif

jfieldID  g_jit_java_p_jitobj_fid;
jclass g_jit_java_jitobj_clazz;
jclass g_jit_java_jitmatrix_clazz;
jclass g_atom_clazz;
jclass g_string_clazz;
jclass g_object_clazz;

// Method com.cycling74.max.Atom.newAtom(int)
jmethodID g_newIntAtom_MID;
// Method com.cycling74.max.Atom.newAtom(float)
jmethodID g_newFloatAtom_MID;
// Method com.cycling74.max.Atom.newAtom(String)
jmethodID g_newStringAtom_MID;
// Method com.cycling74.max.Atom.getType
jmethodID g_getAtomType_MID;
// Method com.cycling74.max.IntAtom.getInt
jmethodID g_getIntValue_MID;
// Method com.cycling74.max.FloatAtom.getFloat
jmethodID g_getFloatValue_MID;
// Method com.cycling74.max.StringAtom.getString
jmethodID g_getStringValue_MID;

static t_symbol *ps_bang,*ps_int,*ps_float,*ps_jitter,*ps_registeredname;
static t_symbol *ps_jit_matrix,*ps_jit_matrix_wrapper,*ps_getmatrix,*ps_matrix_calc,*ps_chuck,*ps_append;
static t_symbol *ps_jit_linklist,*ps_class_string,*ps_class_jitter_object,*ps_class_jitter_matrix;
static t_symbol *ps_global_jvm,*ps_global_cfm_env,*ps_global_invoke_interface;

//JNI
jlong JNICALL jit_java_jitobj_new(JNIEnv *env, jobject obj, jstring name, jobjectArray argv);
void JNICALL jit_java_jitobj_free(JNIEnv *env, jobject obj);

jobject JNICALL jit_java_jitobj_send(JNIEnv *env, jobject obj, jstring msg, jobjectArray argv);
jobject JNICALL jit_java_jitobj_send_msg_int(JNIEnv *env, jobject obj, jstring msg, jint val);
jobject JNICALL jit_java_jitobj_send_msg_intarray(JNIEnv *env, jobject obj, jstring msg, jintArray array);
jobject JNICALL jit_java_jitobj_send_msg_float(JNIEnv *env, jobject obj, jstring msg, jfloat val);
jobject JNICALL jit_java_jitobj_send_msg_floatarray(JNIEnv *env, jobject obj, jstring msg, jfloatArray array);
jobject JNICALL jit_java_jitobj_send_msg_string(JNIEnv *env, jobject obj, jstring msg, jstring val);
jobject JNICALL jit_java_jitobj_send_msg_stringarray(JNIEnv *env, jobject obj, jstring msg, jobject array);

jobject JNICALL jit_java_jitobj_bang(JNIEnv *env, jobject obj);
jobject JNICALL jit_java_jitobj_send_int(JNIEnv *env, jobject obj, jint n);
jobject JNICALL jit_java_jitobj_send_float(JNIEnv *env, jobject obj, jfloat f);
jstring JNICALL jit_java_jitobj_get_class(JNIEnv  *env, jobject obj);
jboolean JNICALL jit_java_jitobj_understands(JNIEnv *env, jobject obj, jstring msg);

jobject JNICALL jit_java_jitobj_getattr(JNIEnv *env, jobject obj, jstring name);
jint JNICALL jit_java_jitobj_getattr_int(JNIEnv *env, jobject obj, jstring name);
jobject JNICALL jit_java_jitobj_getattr_intarray(JNIEnv *env, jobject obj, jstring name);
jfloat JNICALL jit_java_jitobj_getattr_float(JNIEnv *env, jobject obj, jstring name);
jobject JNICALL jit_java_jitobj_getattr_floatarray(JNIEnv *env, jobject obj, jstring name);
jstring JNICALL jit_java_jitobj_getattr_string(JNIEnv *env, jobject obj, jstring name);
jobject JNICALL jit_java_jitobj_getattr_stringarray(JNIEnv *env, jobject obj, jstring name);

jboolean JNICALL jit_java_jitobj_setattr(JNIEnv *env, jobject obj, jstring name, jobjectArray argv);
jboolean JNICALL jit_java_jitobj_setattr_int(JNIEnv *env, jobject obj, jstring name, jint val);
jboolean JNICALL jit_java_jitobj_setattr_intarray(JNIEnv *env, jobject obj, jstring name, jintArray array);
jboolean JNICALL jit_java_jitobj_setattr_float(JNIEnv *env, jobject obj, jstring name, jfloat val);
jboolean JNICALL jit_java_jitobj_setattr_floatarray(JNIEnv *env, jobject obj, jstring name, jfloatArray array);
jboolean JNICALL jit_java_jitobj_setattr_string(JNIEnv *env, jobject obj, jstring name, jstring val);
jboolean JNICALL jit_java_jitobj_setattr_stringarray(JNIEnv *env, jobject obj, jstring name, jobject array);

jstring JNICALL jit_java_jitobj_getregisteredname(JNIEnv *env, jobject obj);

t_object *get_jit_java_jitobj(JNIEnv *env, jobject obj);
jobject JNICALL jit_java_jitobj_returnvalue(JNIEnv *env, t_atom a);
void jit_java_jitobj_register_natives(JNIEnv *env, jclass clazz);

//internal
void jit_java_jitter_register_natives(JNIEnv*, jclass);

t_object *get_jit_java_jitobj(JNIEnv *env, jobject obj)
{
  return (t_object *)(JIT_JAVA_JNI_CALL(env,GetLongField)(env, obj,g_jit_java_p_jitobj_fid));      
}

jlong JNICALL jit_java_jitobj_new(JNIEnv *env, jobject obj, jstring name, jobjectArray argv)
{
    char *s;
    short ac;
    t_atom *av;
    t_max_err res;
    t_object *o;
    t_symbol *classname;
    char tmp[256];
    long i,len;
    t_class *c;
    t_object *p=NULL;
    t_symbol *tmpsym;
    
    if(!name)
        return 0; //NULL pointer
            
    s = (char *)JIT_JAVA_JNI_CALL(env,GetStringUTFChars)(env,name,NULL);    
    classname = gensym(s);
    strcpy(tmp,s);
    len = strlen(tmp);
    for (i=0;i<len;i++) {
        //replace periods with underscores
        if (tmp[i]=='.')
            tmp[i] = '_';
    }   
    
    // match on jit.matrix/jit_matrix and use jit_matrix_wrapper class 
    // rather than raw jit_matrix class
    tmpsym = gensym(tmp);
    if (tmpsym==ps_jit_matrix) {
        tmpsym = ps_jit_matrix_wrapper;
        strcpy(tmp,tmpsym->s_name);
    }
    
    // lookup class
    c = class_findbyname(ps_jitter,tmpsym);
    if (!c) {
        // if not found, attempt to instantiate max object, loading from disk
        //jit_object_post((t_object *)x,"jit_java_jit_obj_new: could not find %s. calling newinstance()",tmp);
        if (p=newinstance(classname,0,NULL)) { 
            c = class_findbyname(ps_jitter,tmpsym);
            freeobject(p);
            p = NULL;
        }
        //else
        //  return 0;
    }
    
    if (argv != NULL)
    {   
        av = jit_java_newargv(env,argv,&ac);
        o = object_new_typed(ps_jitter,tmpsym,ac,av);
        if (av)
            jit_freebytes(av,ac * sizeof(t_atom));
    }
    else
        o = object_new_typed(ps_jitter,tmpsym,0,NULL);
    if (o)
    {
        if (!jit_java_regob_lookup(o)) {
            if (jit_java_regob_register(o,jit_symbol_unique()))
                error("jit_java_jitobj_new: error trying to register object");
        }
    }
    JIT_JAVA_JNI_CALL(env,ReleaseStringUTFChars)(env,name,s);
    JIT_JAVA_JNI_CALL(env,DeleteLocalRef)(env,name);
    return (jlong)o;
}

t_symbol *jit_java_regob_lookup(t_jit_object *x)
{   
    t_symbol *regsym=NULL;

    if (x) {
        regsym=jit_attr_getsym(x,ps_registeredname);
        if ((!regsym)||(regsym==_jit_sym_nothing))
            regsym=jit_object_findregisteredbyptr(x);   
        if (regsym==_jit_sym_nothing)
            regsym = NULL;  
    }
    return regsym;
}

t_jit_err jit_java_regob_register(t_jit_object *x, t_symbol *regname)
{   
    if (jit_object_findregistered(regname)||jit_object_findregisteredbyptr(x))
        return JIT_ERR_GENERIC;

    if (jit_object_attr_get(x,ps_registeredname))
        jit_attr_setsym(x,ps_registeredname,regname);
    else
        jit_object_register(x,regname);
        
    return JIT_ERR_NONE;
}

void JNICALL jit_java_jitobj_free(JNIEnv *env, jobject obj)
{
    long zero = 0;
    t_object *o = get_jit_java_jitobj(env,obj);
    if (o)
        freeobject(o);  
        
    JIT_JAVA_JNI_CALL(env,SetLongField)(env,obj,g_jit_java_p_jitobj_fid,zero);      
}

jobject JNICALL jit_java_jitobj_bang(JNIEnv *env, jobject obj)
{
    t_object *o = get_jit_java_jitobj(env,obj);
    t_atom arv;
    
    arv.a_type = A_NOTHING;     
    if(o)
    {
        object_method_typed(o,ps_bang,0,NULL,&arv);
    }
    return jit_java_jitobj_returnvalue(env,arv);
}

jobject JNICALL jit_java_jitobj_send_int(JNIEnv *env, jobject obj, jint n)
{
    t_object *o = get_jit_java_jitobj(env,obj);
    t_atom a;
    t_atom arv;
    
    arv.a_type = A_NOTHING; 
    if(o)
    {
        atom_setlong(&a,n);
        object_method_typed(o,ps_int,1,&a,&arv);
    }
    return jit_java_jitobj_returnvalue(env,arv);
}

jobject JNICALL jit_java_jitobj_send_float(JNIEnv *env, jobject obj,jfloat f)
{
    t_object *o = get_jit_java_jitobj(env,obj);
    t_atom a;
    t_atom arv;
    
    arv.a_type = A_NOTHING; 
    if(o)
    {
        atom_setfloat(&a,f);
        object_method_typed(o,ps_float,1,&a,&arv);
    }
    return jit_java_jitobj_returnvalue(env,arv);
}

jobject JNICALL jit_java_jitobj_send(JNIEnv *env, jobject obj, jstring msg, jobjectArray argv)
{
    char *s;
    short ac;
    t_atom *av;
    t_atom arv;
    t_max_err res;
    t_object *o;
    
    if(!msg)
        return NULL;
        
    o = get_jit_java_jitobj(env,obj);
    if(!o)
        return NULL;
    
    arv.a_type = A_NOTHING;
    s = (char *)JIT_JAVA_JNI_CALL(env,GetStringUTFChars)(env,msg,NULL);
    
    if(argv != NULL)
    {   
        av = jit_java_newargv(env,argv, &ac);
        res = object_method_typed(o,gensym(s),ac,av,&arv);
        if (av)
            jit_freebytes(av,ac * sizeof(t_atom));
    }
    else
        res = object_method_typed(o,gensym(s),0,NULL,&arv);
    JIT_JAVA_JNI_CALL(env,ReleaseStringUTFChars)(env,msg,s);
    
    return jit_java_jitobj_returnvalue(env,arv);
}

jobject JNICALL jit_java_jitobj_send_msg_int(JNIEnv *env, jobject obj, jstring msg, jint val)
{
    char *s;
    t_atom a;
    t_atom arv;
    t_max_err res;
    t_object *o;
    
    if(!msg)
        return NULL;
        
    o = get_jit_java_jitobj(env,obj);
    if(!o)
        return NULL;
    
    arv.a_type = A_NOTHING;
    s = (char *)JIT_JAVA_JNI_CALL(env,GetStringUTFChars)(env,msg,NULL);
    
    atom_setlong(&a,val);
    res = object_method_typed(o,gensym(s),1,&a,&arv);
    JIT_JAVA_JNI_CALL(env,ReleaseStringUTFChars)(env,msg,s);
    
    return jit_java_jitobj_returnvalue(env,arv);
}

jobject JNICALL jit_java_jitobj_send_msg_intarray(JNIEnv *env, jobject obj, jstring msg, jintArray array)
{
    char *s;
    long i,ac=0;
    t_atom *av=NULL;
    t_atom arv;
    t_max_err res;
    t_object *o;
    jint *elements;
    jboolean is_copy; 
    
    if(!msg)
        return JNI_FALSE;
        
    o = get_jit_java_jitobj(env,obj);
    if(!o)//would be weird
        return JNI_FALSE;
    
    arv.a_type = A_NOTHING;
    s = (char *)JIT_JAVA_JNI_CALL(env,GetStringUTFChars)(env,msg,NULL);
    
    if (array) {
        ac = JIT_JAVA_JNI_CALL(env,GetArrayLength)(env,array);
        av = (t_atom *)jit_getbytes(ac*sizeof(t_atom));
            
        elements = JIT_JAVA_JNI_CALL(env, GetIntArrayElements)(env,(jintArray)array,&is_copy);
        checkException(env);

        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,gensym(s),ac,av,&arv);
    if (av)
        jit_freebytes(av,ac*sizeof(t_atom));
    JIT_JAVA_JNI_CALL(env,ReleaseStringUTFChars)(env,msg,s);
    
    return jit_java_jitobj_returnvalue(env,arv);
}

jobject JNICALL jit_java_jitobj_send_msg_float(JNIEnv *env, jobject obj, jstring msg, jfloat val)
{
    char *s;
    t_atom a;
    t_atom arv;
    t_max_err res;
    t_object *o;
    
    if(!msg)
        return NULL;
        
    o = get_jit_java_jitobj(env,obj);
    if(!o)
        return NULL;
    
    arv.a_type = A_NOTHING;
    s = (char *)JIT_JAVA_JNI_CALL(env,GetStringUTFChars)(env,msg,NULL);
    
    atom_setfloat(&a,val);
    res = object_method_typed(o,gensym(s),1,&a,&arv);
    JIT_JAVA_JNI_CALL(env,ReleaseStringUTFChars)(env,msg,s);
    
    return jit_java_jitobj_returnvalue(env,arv);
}

jobject JNICALL jit_java_jitobj_send_msg_floatarray(JNIEnv *env, jobject obj, jstring msg, jfloatArray array)
{
    char *s;
    long i,ac=0;
    t_atom *av=NULL;
    t_atom arv;
    t_max_err res;
    t_object *o;
    jfloat *elements;
    jboolean is_copy; 
    
    if(!msg)
        return JNI_FALSE;
        
    o = get_jit_java_jitobj(env,obj);
    if(!o)//would be weird
        return JNI_FALSE;
    
    arv.a_type = A_NOTHING;
    s = (char *)JIT_JAVA_JNI_CALL(env,GetStringUTFChars)(env,msg,NULL);
    
    if (array) {
        ac = JIT_JAVA_JNI_CALL(env,GetArrayLength)(env,array);
        av = (t_atom *)jit_getbytes(ac*sizeof(t_atom));
            
        elements = JIT_JAVA_JNI_CALL(env, GetFloatArrayElements)(env,(jfloatArray)array,&is_copy);
        checkException(env);

        for(i=0;i<ac;i++)   
            atom_setfloat(av+i,elements[i]);
        if (is_copy)
        {
            JIT_JAVA_JNI_CALL(env, ReleaseFloatArrayElements)(env,(jfloatArray)array,elements,0);
            checkException(env);
        }

    }

    res = object_method_typed(o,gensym(s),ac,av,&arv);
    if (av)
        jit_freebytes(av,ac*sizeof(t_atom));
    JIT_JAVA_JNI_CALL(env,ReleaseStringUTFChars)(env,msg,s);
    
    return jit_java_jitobj_returnvalue(env,arv);
}

jobject JNICALL jit_java_jitobj_send_msg_string(JNIEnv *env, jobject obj, jstring msg, jstring val)
{
    char *s,*s2;
    t_atom a;
    t_atom arv;
    t_max_err res;
    t_object *o;
    
    if(!msg)
        return NULL;
        
    o = get_jit_java_jitobj(env,obj);
    if(!o)
        return NULL;
    
    arv.a_type = A_NOTHING;
    s = (char *)JIT_JAVA_JNI_CALL(env,GetStringUTFChars)(env,msg,NULL);
    s2 = (char *)JIT_JAVA_JNI_CALL(env,GetStringUTFChars)(env,val,NULL);
    
    atom_setsym(&a,gensym(s2));
    res = object_method_typed(o,gensym(s),1,&a,&arv);
    JIT_JAVA_JNI_CALL(env,ReleaseStringUTFChars)(env,msg,s);
    JIT_JAVA_JNI_CALL(env,ReleaseStringUTFChars)(env,val,s2);
    
    return jit_java_jitobj_returnvalue(env,arv);
}

jobject JNICALL jit_java_jitobj_send_msg_stringarray(JNIEnv *env, jobject obj, jstring msg, jobject array)
{
    char *s,*s2;
    long i,ac=0;
    t_atom *av=NULL;
    t_atom arv;
    t_max_err res;
    t_object *o;
    jstring js; 
    
    if(!msg)
        return JNI_FALSE;
        
    o = get_jit_java_jitobj(env,obj);
    if(!o)//would be weird
        return JNI_FALSE;
    
    arv.a_type = A_NOTHING;
    s = (char *)JIT_JAVA_JNI_CALL(env,GetStringUTFChars)(env,msg,NULL);
    
    if (array) {
        ac = JIT_JAVA_JNI_CALL(env,GetArrayLength)(env,array);
        av = (t_atom *)jit_getbytes(ac*sizeof(t_atom));
            
        for(i=0;i<ac;i++) {
            js = JIT_JAVA_JNI_CALL(env,GetObjectArrayElement)(env,array,i);
            checkException(env);
            s2 = (char *)JIT_JAVA_JNI_CALL(env,GetStringUTFChars)(env,js,NULL);
    
            atom_setsym(av+i,gensym(s2));
            JIT_JAVA_JNI_CALL(env,ReleaseStringUTFChars)(env,js,s2);    
        }
    }

    res = object_method_typed(o,gensym(s),ac,av,&arv);
    if (av)
        jit_freebytes(av,ac*sizeof(t_atom));
    JIT_JAVA_JNI_CALL(env,ReleaseStringUTFChars)(env,msg,s);
    
    return jit_java_jitobj_returnvalue(env,arv);
}

jobject JNICALL jit_java_jitobj_getattr(JNIEnv *env, jobject obj, jstring name)
{
    char *s;
    long ac=0;
    t_atom *av=NULL;
    t_max_err res;
    t_object *o;
    jobject jrv=NULL;
    
    if(!name)
        return NULL;
        
    o = get_jit_java_jitobj(env,obj);
    if(!o)
        return NULL;
    
    s = (char *)JIT_JAVA_JNI_CALL(env,GetStringUTFChars)(env,name,NULL);    
    res = object_attr_getvalueof(o,gensym(s),&ac,&av);
    JIT_JAVA_JNI_CALL(env,ReleaseStringUTFChars)(env,name,s);

    if (ac&&av) {
        jrv=jit_java_newatomarray(env,ac,av);
        freebytes(av,ac*sizeof(t_atom));
    }
    return jrv;
}

jint JNICALL jit_java_jitobj_getattr_int(JNIEnv *env, jobject obj, jstring name)
{
    char *s;
    long ac=0;
    t_atom *av=NULL;
    t_max_err res;
    t_object *o;
    jint jrv=0;
    
    if(!name)
        return 0;
        
    o = get_jit_java_jitobj(env,obj);
    if(!o)
        return 0;
    
    s = (char *)JIT_JAVA_JNI_CALL(env,GetStringUTFChars)(env,name,NULL);    
    res = object_attr_getvalueof(o,gensym(s),&ac,&av);
    JIT_JAVA_JNI_CALL(env,ReleaseStringUTFChars)(env,name,s);

    if (ac&&av) {
        jrv=(jint)atom_getlong(av);
        freebytes(av,ac*sizeof(t_atom));
    }
    return jrv;
}

jintArray JNICALL jit_java_jitobj_getattr_intarray(JNIEnv *env, jobject obj, jstring name)
{
    char *s;
    long i,ac=0;
    t_atom *av=NULL;
    t_max_err res;
    t_object *o;
    jint *vp;
    jintArray ja=0;
    
    if(!name)
        return NULL;
        
    o = get_jit_java_jitobj(env,obj);
    if(!o)
        return NULL;
    
    s = (char *)JIT_JAVA_JNI_CALL(env,GetStringUTFChars)(env,name,NULL);    
    res = object_attr_getvalueof(o,gensym(s),&ac,&av);
    JIT_JAVA_JNI_CALL(env,ReleaseStringUTFChars)(env,name,s);

    ja = jit_java_newintarray(env,ac,av);
    if (ac&&av) {
        freebytes(av,ac*sizeof(t_atom));
    }
    return ja;
}



jfloat JNICALL jit_java_jitobj_getattr_float(JNIEnv *env, jobject obj, jstring name)
{
    char *s;
    long ac=0;
    t_atom *av=NULL;
    t_max_err res;
    t_object *o;
    jfloat jrv=0.;
    
    if(!name)
        return (jfloat)0;
        
    o = get_jit_java_jitobj(env,obj);
    if(!o)
        return (jfloat)0;
    
    s = (char *)JIT_JAVA_JNI_CALL(env,GetStringUTFChars)(env,name,NULL);    
    res = object_attr_getvalueof(o,gensym(s),&ac,&av);
    JIT_JAVA_JNI_CALL(env,ReleaseStringUTFChars)(env,name,s);

    if (ac&&av) {
        jrv=(jfloat)atom_getfloat(av);
        freebytes(av,ac*sizeof(t_atom));
    }
    return jrv;
}

jobject JNICALL jit_java_jitobj_getattr_floatarray(JNIEnv *env, jobject obj, jstring name)
{
    char *s;
    long i,ac=0;
    t_atom *av=NULL;
    t_max_err res;
    t_object *o;
    jfloat *vp;
    jfloatArray ja=0;
    
    if(!name)
        return NULL;
        
    o = get_jit_java_jitobj(env,obj);
    if(!o)
        return NULL;
    
    s = (char *)JIT_JAVA_JNI_CALL(env,GetStringUTFChars)(env,name,NULL);    
    res = object_attr_getvalueof(o,gensym(s),&ac,&av);
    JIT_JAVA_JNI_CALL(env,ReleaseStringUTFChars)(env,name,s);

    ja = jit_java_newfloatarray(env,ac,av);
    if (ac&&av) {
        freebytes(av,ac*sizeof(t_atom));
    }
    return ja;
}

jstring JNICALL jit_java_jitobj_getattr_string(JNIEnv *env, jobject obj, jstring name)
{
    char *s;
    long ac=0;
    t_atom *av=NULL;
    t_max_err res;
    t_object *o;
    jstring jrv=NULL;
    
    if(!name)
        return NULL;
        
    o = get_jit_java_jitobj(env,obj);
    if(!o)
        return NULL;
    
    s = (char *)JIT_JAVA_JNI_CALL(env,GetStringUTFChars)(env,name,NULL);    
    res = object_attr_getvalueof(o,gensym(s),&ac,&av);
    JIT_JAVA_JNI_CALL(env,ReleaseStringUTFChars)(env,name,s);

    if (ac&&av) {
        jrv = JIT_JAVA_JNI_CALL(env,NewStringUTF)(env,atom_getsym(av)->s_name);
        freebytes(av,ac*sizeof(t_atom));
    }
    
    return jrv;
}

jobject JNICALL jit_java_jitobj_getattr_stringarray(JNIEnv *env, jobject obj, jstring name)
{
    char *s;
    long i,ac=0;
    t_atom *av=NULL;
    t_max_err res;
    t_object *o;
    jstring js;
    jfloatArray ja=0;
    
    if(!name)
        return NULL;
        
    o = get_jit_java_jitobj(env,obj);
    if(!o)
        return NULL;
    
    s = (char *)JIT_JAVA_JNI_CALL(env,GetStringUTFChars)(env,name,NULL);    
    res = object_attr_getvalueof(o,gensym(s),&ac,&av);
    JIT_JAVA_JNI_CALL(env,ReleaseStringUTFChars)(env,name,s);

    if (ac&&av) {
        ja  = (jarray)JIT_JAVA_JNI_CALL(env,NewObjectArray)(env,ac,g_string_clazz,NULL);
        checkException(env);
                        
        for(i=0;i<ac;i++)
        {
            js = JIT_JAVA_JNI_CALL(env,NewStringUTF)(env,atom_getsym(av+i)->s_name);
            JIT_JAVA_JNI_CALL(env,SetObjectArrayElement)(env,ja,i,js);      
        }
        checkException(env);
        freebytes(av,ac*sizeof(t_atom));
    }
    return ja;
}   

jboolean JNICALL jit_java_jitobj_setattr(JNIEnv *env, jobject obj, jstring name, jobjectArray argv)
{
    char *s;
    short ac;
    t_atom *av;
    t_max_err res;
    t_object *o;
    
    if(!name)
        return JNI_FALSE;
        
    o = get_jit_java_jitobj(env,obj);
    if(!o)//would be weird
        return JNI_FALSE;
    
    s = (char *)JIT_JAVA_JNI_CALL(env,GetStringUTFChars)(env,name,NULL);
    
    if(argv != NULL)
    {   
        av = jit_java_newargv(env,argv,&ac);
        res = object_attr_setvalueof(o,gensym(s),ac,av);
        jit_freebytes(av,ac * sizeof(t_atom));
    }
    else
        res = object_attr_setvalueof(o,gensym(s),0,NULL);
    JIT_JAVA_JNI_CALL(env,ReleaseStringUTFChars)(env,name,s);
    
    return (!res);
}

jboolean JNICALL jit_java_jitobj_setattr_int(JNIEnv *env, jobject obj, jstring name, jint val)
{
    char *s;
    t_atom a;
    t_max_err res;
    t_object *o;
    jboolean is_copy;   
    
    if(!name)
        return JNI_FALSE;
        
    o = get_jit_java_jitobj(env,obj);
    if(!o)//would be weird
        return JNI_FALSE;
    
    s = (char *)JIT_JAVA_JNI_CALL(env,GetStringUTFChars)(env,name,NULL);
    
    atom_setlong(&a,val);
    res = object_attr_setvalueof(o,gensym(s),1,&a);
    JIT_JAVA_JNI_CALL(env,ReleaseStringUTFChars)(env,name,s);
    
    return (!res);
}


jboolean JNICALL jit_java_jitobj_setattr_intarray(JNIEnv *env, jobject obj, jstring name, jintArray array)
{
    char *s;
    long i,ac=0;
    t_atom *av=NULL;
    t_max_err res;
    t_object *o;
    jint *elements;
    jboolean is_copy; 
    
    if(!name)
        return JNI_FALSE;
        
    o = get_jit_java_jitobj(env,obj);
    if(!o)//would be weird
        return JNI_FALSE;
    
    s = (char *)JIT_JAVA_JNI_CALL(env,GetStringUTFChars)(env,name,NULL);
    
    if (array) {
        ac = JIT_JAVA_JNI_CALL(env,GetArrayLength)(env,array);
        av = (t_atom *)jit_getbytes(ac*sizeof(t_atom));
            
        elements = JIT_JAVA_JNI_CALL(env, GetIntArrayElements)(env,(jintArray)array,&is_copy);
        checkException(env);

        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_attr_setvalueof(o,gensym(s),ac,av);
    if (av)
        jit_freebytes(av,ac*sizeof(t_atom));
    JIT_JAVA_JNI_CALL(env,ReleaseStringUTFChars)(env,name,s);
    
    return (!res);
}


jboolean JNICALL jit_java_jitobj_setattr_float(JNIEnv *env, jobject obj, jstring name, jfloat val)
{
    char *s;
    t_atom a;
    t_max_err res;
    t_object *o;
    
    if(!name)
        return JNI_FALSE;
        
    o = get_jit_java_jitobj(env,obj);
    if(!o)//would be weird
        return JNI_FALSE;
    
    s = (char *)JIT_JAVA_JNI_CALL(env,GetStringUTFChars)(env,name,NULL);
    
    atom_setfloat(&a,val);
    res = object_attr_setvalueof(o,gensym(s),1,&a);
    JIT_JAVA_JNI_CALL(env,ReleaseStringUTFChars)(env,name,s);
    
    return (!res);
}

jboolean JNICALL jit_java_jitobj_setattr_floatarray(JNIEnv *env, jobject obj, jstring name, jfloatArray array)
{
    char *s;
    long i,ac=0;
    t_atom *av=NULL;
    t_max_err res;
    t_object *o;
    jfloat *elements;
    jboolean is_copy; 
    
    if(!name)
        return JNI_FALSE;
        
    o = get_jit_java_jitobj(env,obj);
    if(!o)//would be weird
        return JNI_FALSE;
    
    s = (char *)JIT_JAVA_JNI_CALL(env,GetStringUTFChars)(env,name,NULL);
    
    if (array) {
        ac = JIT_JAVA_JNI_CALL(env,GetArrayLength)(env,array);
        av = (t_atom *)jit_getbytes(ac*sizeof(t_atom));
            
        elements = JIT_JAVA_JNI_CALL(env, GetFloatArrayElements)(env,(jfloatArray)array,&is_copy);
        checkException(env);

        for(i=0;i<ac;i++)   
            atom_setfloat(av+i,elements[i]);
        if (is_copy)
        {
            JIT_JAVA_JNI_CALL(env, ReleaseFloatArrayElements)(env,(jfloatArray)array,elements,0);
            checkException(env);
        }

    }

    res = object_attr_setvalueof(o,gensym(s),ac,av);
    if (av)
        jit_freebytes(av,ac*sizeof(t_atom));
    JIT_JAVA_JNI_CALL(env,ReleaseStringUTFChars)(env,name,s);
    
    return (!res);
}


jboolean JNICALL jit_java_jitobj_setattr_string(JNIEnv *env, jobject obj, jstring name, jstring val)
{
    char *s,*s2;
    t_atom a;
    t_max_err res;
    t_object *o;
    
    if(!name)
        return JNI_FALSE;
        
    o = get_jit_java_jitobj(env,obj);
    if(!o)//would be weird
        return JNI_FALSE;
    
    s = (char *)JIT_JAVA_JNI_CALL(env,GetStringUTFChars)(env,name,NULL);
    s2 = (char *)JIT_JAVA_JNI_CALL(env,GetStringUTFChars)(env,val,NULL);
    
    atom_setsym(&a,gensym(s2)); 
    res = object_attr_setvalueof(o,gensym(s),1,&a);
    JIT_JAVA_JNI_CALL(env,ReleaseStringUTFChars)(env,name,s);
    JIT_JAVA_JNI_CALL(env,ReleaseStringUTFChars)(env,val,s2);
    
    return (!res);
}

jboolean JNICALL jit_java_jitobj_setattr_stringarray(JNIEnv *env, jobject obj, jstring name, jobject array)
{
    char *s,*s2;
    long i,ac=0;
    t_atom *av=NULL;
    t_max_err res;
    t_object *o;
    jstring js; 
    
    if(!name)
        return JNI_FALSE;
        
    o = get_jit_java_jitobj(env,obj);
    if(!o)//would be weird
        return JNI_FALSE;
    
    s = (char *)JIT_JAVA_JNI_CALL(env,GetStringUTFChars)(env,name,NULL);
    
    if (array) {
        ac = JIT_JAVA_JNI_CALL(env,GetArrayLength)(env,array);
        av = (t_atom *)jit_getbytes(ac*sizeof(t_atom));
            
        for(i=0;i<ac;i++) {
            js = JIT_JAVA_JNI_CALL(env,GetObjectArrayElement)(env,array,i);
            checkException(env);
            s2 = (char *)JIT_JAVA_JNI_CALL(env,GetStringUTFChars)(env,js,NULL);
    
            atom_setsym(av+i,gensym(s2));
            JIT_JAVA_JNI_CALL(env,ReleaseStringUTFChars)(env,js,s2);    
        }
    }
    res = object_attr_setvalueof(o,gensym(s),ac,av);
    if (av)
        jit_freebytes(av,ac*sizeof(t_atom));
    JIT_JAVA_JNI_CALL(env,ReleaseStringUTFChars)(env,name,s);
    
    return (!res);
}

jstring JNICALL jit_java_jitobj_getregisteredname(JNIEnv *env, jobject obj)
{
    t_symbol *s;
    t_max_err res;
    t_object *o;
    jstring jrv=NULL;
    
    o = get_jit_java_jitobj(env,obj);
    if(!o)
        return NULL;
    
    if (s=jit_java_regob_lookup(o)) {
        jrv = JIT_JAVA_JNI_CALL(env,NewStringUTF)(env,s->s_name);
    }
    return jrv;
}

long jobject_getclassname(JNIEnv *env, jobject obj, char *classname);
long jobject_getclassname(JNIEnv *env, jobject obj, char *classname)
{
    jclass theclass;
    jstring jclassname;
    char *tmp;
    static jmethodID getName_MID=NULL;

    classname[0] = '\0';

    if(!obj)
        return -1;
    
    theclass = JIT_JAVA_JNI_CALL(env,GetObjectClass)(env,obj);
    checkException(env);
    if (!getName_MID) {
        jclass classclass;          
        classclass = JIT_JAVA_JNI_CALL(env,FindClass)(env,"java/lang/Class");
        checkException(env);
        getName_MID = JIT_JAVA_JNI_CALL(env,GetMethodID)(env,classclass,"getName","()Ljava/lang/String;");
        checkException(env);
        if (!getName_MID)
            return -1;
    }
    jclassname = JIT_JAVA_JNI_CALL(env,CallObjectMethod)(env,theclass,getName_MID);
    checkException(env);
    tmp = (char *)JIT_JAVA_JNI_CALL(env,GetStringUTFChars)(env,jclassname,NULL);
    strcpy(classname,tmp);
    JIT_JAVA_JNI_CALL(env,ReleaseStringUTFChars)(env,jclassname,tmp);
    return 0;
}       

t_object *jit_matrix_from_jobject_with_classname(JNIEnv *env, jobject obj, char *classname);
t_object *jit_matrix_from_jobject_with_classname(JNIEnv *env, jobject obj, char *classname)
{
    char *s;
    t_symbol *class_sym=gensym(classname);
    t_object *rv=NULL;
        
    if (class_sym==ps_class_string) {
        s = (char *)JIT_JAVA_JNI_CALL(env,GetStringUTFChars)(env,obj,NULL);
        rv = object_findregistered(ps_jitter,gensym(s));
        JIT_JAVA_JNI_CALL(env,ReleaseStringUTFChars)(env,obj,s);
    } else if ((class_sym==ps_class_jitter_matrix)||(class_sym==ps_class_jitter_object)) {
        rv = object_method(get_jit_java_jitobj(env,obj),ps_getmatrix);  // jit_matrix_wrapper class
        // eventually need to add check for JitterMatrix class
    } else {
        error("mxj: JitterObject.matrixcalc() argument is not String, or JitterMatrix: %s", class_sym->s_name);
    }
    
    return rv;
}

t_object *jit_matrix_from_jobject(JNIEnv *env, jobject obj);
t_object *jit_matrix_from_jobject(JNIEnv *env, jobject obj)
{
    char classname[256];
    t_object *rv=NULL;
    
    jobject_getclassname(env,obj,classname);
    return jit_matrix_from_jobject_with_classname(env,obj,classname);
    
    /* 
    the following attempt to optimize based on class pointer, seems somehow flawed
    could revisit if we deem the current classname approach flawed or inefficient

    static jclass stringclass=NULL;
    static jclass jitterobjectclass=NULL;
    static jclass jittermatrixclass=NULL; //not yet
    jclass theclass;
    char *s;
    t_object *rv=NULL;
    
    this doesn't seem to work 
    if (!stringclass) {
        stringclass = JIT_JAVA_JNI_CALL(env,FindClass)(env,"java/lang/String");
        jitterobjectclass = JIT_JAVA_JNI_CALL(env,FindClass)(env,"com/cycling74/jitter/JitterObject");
        //jittermatrixclass = JIT_JAVA_JNI_CALL(env,FindClass)(env,"com/cycling74/jitter/JitterMatrix");
        checkException(env);
        jit_object_post((t_object *)x,"stringclass %x",(long)stringclass);
        jit_object_post((t_object *)x,"jitterobjectclass %x",(long)jitterobjectclass);
    }
    theclass = JIT_JAVA_JNI_CALL(env,GetObjectClass)(env,obj);
    checkException(env);
    if (theclass==stringclass) {
        s = (char *)JIT_JAVA_JNI_CALL(env,GetStringUTFChars)(env,obj,NULL);
        rv = object_findregistered(ps_jitter,gensym(s));
        JIT_JAVA_JNI_CALL(env,ReleaseStringUTFChars)(env,obj,s);
    } else if (theclass==jitterobjectclass) {
        rv = object_method(get_jit_java_jitobj(env,obj),ps_getmatrix);  // jit_matrix_wrapper class
    } else {
        error("mxj: JitterObject.matrixcalc() argument is not String, or JitterMatrix");
        jit_object_post((t_object *)x,"theclass %x",(long)theclass);
    }
    return rv;
    */
}


t_object *matrixcalc_build_io_list(JNIEnv *env, jobject obj);
t_object *matrixcalc_build_io_list(JNIEnv *env, jobject obj)
{
    char classname[256];
    long i,len,isarray;
    jobject jo;
    t_object *matrix;
    t_object *list;
        
    list = object_new(ps_jitter,ps_jit_linklist);

    if (obj) {
        jobject_getclassname(env,obj,classname);
        isarray = (classname[0]=='[');
        if (isarray) {  
            // make sure it is an object array, not a primitive array 
            // to protect GetObjectArrayElement call (hack)
            if (classname[4]) {
                len = JIT_JAVA_JNI_CALL(env,GetArrayLength)(env,obj);
                //jit_object_post((t_object *)x,"building array of size %d",len);
                for (i=0;i<len;i++) {
                    jo = JIT_JAVA_JNI_CALL(env,GetObjectArrayElement)(env,obj,i);
                    matrix = jit_matrix_from_jobject(env,jo);
                    if (matrix)
                        object_method(list,ps_append,matrix);
                    //jit_object_post((t_object *)x,"iolist(multi): appending %x", matrix);
                }
            }
        } else {
            matrix = jit_matrix_from_jobject_with_classname(env,obj,classname);
            if (matrix)
                object_method(list,ps_append,matrix);
            //jit_object_post((t_object *)x,"iolist(single): appending %x", matrix);
        }
    }
    
    return list;    
}

jboolean JNICALL jit_java_jitobj_matrixcalc(JNIEnv *env, jobject obj, jobject in_obj, jobject out_obj);
jboolean JNICALL jit_java_jitobj_matrixcalc(JNIEnv *env, jobject obj, jobject in_obj, jobject out_obj)
{
    t_max_err err;
    t_object *o;
    t_object *input;
    t_object *output;
    
    o = get_jit_java_jitobj(env,obj);
    if(!o)
        return 0;

    // should return false if object doesn't have a ps_matrix_calc method
    
    input = matrixcalc_build_io_list(env,in_obj);
    output = matrixcalc_build_io_list(env,out_obj);
    
    err = (t_max_err) object_method(o,ps_matrix_calc,input,output);
    if (err) { 
        // could resolve error number to error string. and could return error in rval
        error("%d calling matrixcalc on %s",err,object_classname(o)->s_name); 
    }
    
    if (input) {
        object_method(input,ps_chuck);
    }
    if (output) {
        object_method(output,ps_chuck);
    }
    
    return (!err);
}


jobject JNICALL jit_java_jitobj_returnvalue(JNIEnv *env, t_atom a)
{
    jobject jrv=NULL;
    
    if (a.a_type==A_NOTHING) {
        jrv = NULL;
    } else if (a.a_type==A_OBJ) {
        long ac = 0;
        t_atom *av=NULL;
        t_object *o = (t_object *)a.a_w.w_obj;
    
        if (o) {
            object_getvalueof(o,&ac,&av);
            if (ac)
                jrv = jit_java_newatomarray(env, ac, av);
            else 
                jrv = NULL;
            freeobject(o);
            if (ac&&av)
                freebytes((char *)av,ac*sizeof(t_atom));
        } else { 
            jrv = NULL;
        }
    } else {
        jrv = jit_java_newatomarray(env, 1, &a);
    }
    
    return jrv;
}

jobject JNICALL jit_java_jitobj_returnvalue_intarray(JNIEnv *env, t_atom a)
{
    jobject jrv=NULL;
    
    if (a.a_type==A_NOTHING) {
        jrv = NULL;
    } else if (a.a_type==A_OBJ) {
        long ac = 0;
        t_atom *av=NULL;
        t_object *o = (t_object *)a.a_w.w_obj;
    
        if (o) {
            object_getvalueof(o,&ac,&av);
            if (ac)
                jrv = jit_java_newintarray(env, ac, av);
            else 
                jrv = NULL;
            freeobject(o);
            freebytes((char *)av,ac*sizeof(t_atom));
        } else { 
            jrv = NULL;
        }
    } else {
        jrv = jit_java_newintarray(env, 1, &a);
    }
    
    return jrv;
}

jobject JNICALL jit_java_jitobj_returnvalue_floatarray(JNIEnv *env, t_atom a)
{
    jobject jrv=NULL;
    
    if (a.a_type==A_NOTHING) {
        jrv = NULL;
    } else if (a.a_type==A_OBJ) {
        long ac = 0;
        t_atom *av=NULL;
        t_object *o = (t_object *)a.a_w.w_obj;
    
        if (o) {
            object_getvalueof(o,&ac,&av);
            if (ac)
                jrv = jit_java_newfloatarray(env, ac, av);
            else 
                jrv = NULL;
            freeobject(o);
            freebytes((char *)av,ac*sizeof(t_atom));
        } else { 
            jrv = NULL;
        }
    } else {
        jrv = jit_java_newfloatarray(env, 1, &a);
    }
    
    return jrv;
}

jobject JNICALL jit_java_jitobj_returnvalue_doublearray(JNIEnv *env, t_atom a)
{
    jobject jrv=NULL;
    
    if (a.a_type==A_NOTHING) {
        jrv = NULL;
    } else if (a.a_type==A_OBJ) {
        long ac = 0;
        t_atom *av=NULL;
        t_object *o = (t_object *)a.a_w.w_obj;
    
        if (o) {
            object_getvalueof(o,&ac,&av);
            if (ac)
                jrv = jit_java_newdoublearray(env, ac, av);
            else 
                jrv = NULL;
            freeobject(o);
            freebytes((char *)av,ac*sizeof(t_atom));
        } else { 
            jrv = NULL;
        }
    } else {
        jrv = jit_java_newdoublearray(env, 1, &a);
    }
    
    return jrv;
}

jstring JNICALL jit_java_jitobj_get_class(JNIEnv  *env, jobject obj)
{
    jstring ret;
    t_object *o = get_jit_java_jitobj(env,obj);
    
    if(o)
    {
        ret = JIT_JAVA_JNI_CALL(env,NewStringUTF)(env,ob_name(o));
        return ret;
    }
    return NULL;
}

jboolean JNICALL jit_java_jitobj_understands(JNIEnv *env, jobject obj, jstring msg)
{
    char *s;
    jboolean res;
    t_object *o = get_jit_java_jitobj(env,obj);

    if(o)
    {   
        //may want to revisit w/r/t typedwrapper -jkc 
        s = (char *)JIT_JAVA_JNI_CALL(env,GetStringUTFChars)(env,msg,NULL);
        res = zgetfn(o,gensym(s)) ? JNI_TRUE : JNI_FALSE;
        JIT_JAVA_JNI_CALL(env,ReleaseStringUTFChars)(env,msg,s);
        return res;
    }
    return JNI_FALSE;
}

//handle jitobj + other stuff
t_jit_err jit_java_init(void)
{
    JNIEnv *env=NULL;
    t_jit_err err = JIT_ERR_GENERIC;
    static int inited = 0;
    char filename[MAX_PATH_CHARS];
    short vol;
    long type;
    
    if (inited||_cfm_in_ub)
        return JIT_ERR_NONE;
        
    sprintf(filename,"jitter.jar");
    if (locatefile_extended(filename,&vol,&type,0L,0))
        return err;
        
    ps_global_jvm = gensym("_#MAX_JAVA_VM#_");
#if (JIT_JAVA_USE_CFM)
    ps_global_cfm_env = gensym("_#MAX_JAVA_CFM_ENV#_");
    ps_global_invoke_interface = gensym("_#MAX_JAVA_CFM_INVOKE#_");
#endif //JIT_JAVA_USE_CFM

    ps_bang = gensym("bang");
    ps_int  = gensym("int");
    ps_float = gensym("float");
    ps_jitter = gensym("jitter");
    ps_registeredname = gensym("registeredname");
    ps_jit_matrix = gensym("jit_matrix");
    ps_jit_matrix_wrapper = gensym("jit_matrix_wrapper");
    ps_matrix_calc = gensym("matrix_calc");
    ps_chuck = gensym("chuck");
    ps_append = gensym("append");
    ps_getmatrix = gensym("getmatrix");
    ps_jit_linklist = gensym("jit_linklist");
    ps_class_string = gensym("java.lang.String");
    ps_class_jitter_object = gensym("com.cycling74.jitter.JitterObject");
    ps_class_jitter_matrix = gensym("com.cycling74.jitter.JitterMatrix");

    if (!ps_global_jvm->s_thing) {
        t_object *p;
        t_atom a;
        jit_atom_setsym(&a,gensym("com.cycling74.jitter.JitterInstallUtility"));
        if (p=newinstance(gensym("mxj"),1,&a))
            freeobject(p);
        if (!ps_global_jvm->s_thing) {
            error("Jitter Java support: could not find jvm");
            return err;
        }
    }

    g_jvm = (JavaVM *) ps_global_jvm->s_thing;
#if (JIT_JAVA_USE_CFM)
    g_jenv = (t_cfm_jni_env *) ps_global_cfm_env->s_thing;
    g_jvm_invoke = (t_cfm_invoke_interface *) ps_global_invoke_interface->s_thing;
#endif //JIT_JAVA_USE_CFM
    THREADENV(env);
    
    JIT_JAVA_JNI_CALL(env,PushLocalFrame)(env,JIT_JAVA_FRAME_SIZE);

    g_jit_java_jitobj_clazz = jit_java_getclassbyname(env, JIT_JAVA_JITOBJ_CLASSNAME);
    checkException(env);
    if (!g_jit_java_jitobj_clazz) {
        error("could not find jitter.jar");
        goto out;
    }
    g_jit_java_p_jitobj_fid =  JIT_JAVA_JNI_CALL(env,GetFieldID)(env, g_jit_java_jitobj_clazz, JIT_JAVA_JITOBJ_PTR_FIELD, "J");
    checkException(env);
    jit_java_jitobj_register_natives(env,g_jit_java_jitobj_clazz);
    checkException(env);

    g_atom_clazz = jit_java_getclassbyname(env, "com/cycling74/max/Atom");
    checkException(env);
    g_string_clazz = jit_java_getclassbyname(env,"java/lang/String");
    checkException(env);
    g_object_clazz = jit_java_getclassbyname(env,"java/lang/Object");
    checkException(env);
    
    g_newIntAtom_MID = JIT_JAVA_JNI_CALL(env,GetStaticMethodID)(env, g_atom_clazz,NEW_INT_ATOM_MNAME, NEW_INT_ATOM_SIG);
    checkException(env);
    g_newFloatAtom_MID = JIT_JAVA_JNI_CALL(env,GetStaticMethodID)(env, g_atom_clazz, NEW_FLOAT_ATOM_MNAME, NEW_FLOAT_ATOM_SIG);
    checkException(env);
    g_newStringAtom_MID = JIT_JAVA_JNI_CALL(env,GetStaticMethodID)(env, g_atom_clazz, NEW_STRING_ATOM_MNAME, NEW_STRING_ATOM_SIG);
    checkException(env);                                                      
    g_getIntValue_MID = JIT_JAVA_JNI_CALL(env,GetMethodID)(env, g_atom_clazz,GET_INT_VALUE_MNAME, GET_INT_VALUE_SIG);
    checkException(env);
    g_getFloatValue_MID = JIT_JAVA_JNI_CALL(env,GetMethodID)(env, g_atom_clazz, GET_FLOAT_VALUE_MNAME, GET_FLOAT_VALUE_SIG);
    checkException(env);
    g_getStringValue_MID = JIT_JAVA_JNI_CALL(env,GetMethodID)(env, g_atom_clazz, GET_STRING_VALUE_MNAME, GET_STRING_VALUE_SIG);
    checkException(env);
    g_getAtomType_MID = JIT_JAVA_JNI_CALL(env,GetMethodID)(env, g_atom_clazz, GET_ATOM_TYPE_MNAME, GET_ATOM_TYPE_SIG);
    checkException(env);

    jit_java_jitmatrix_init();
    jit_java_jitlistener_init();
    if (g_jit_java_jitobj_clazz&&g_jit_java_jitmatrix_clazz)
        post("Jitter Java support installed");
    else {
        error("could not install Jitter Java support.");
        post("check to make sure jitter.jar is in the mxj classpath");
    }
    inited = 1;
    err = JIT_ERR_NONE;
out:
    JIT_JAVA_JNI_CALL(env,PopLocalFrame)(env,NULL);
    return err;
}

void jit_java_jitobj_register_natives(JNIEnv *env, jclass clazz)
{
    int i,count=0;
    JNINativeMethod methods[] = 
    {
        { "_new","(Ljava/lang/String;[Lcom/cycling74/max/Atom;)J",jit_java_jitobj_new},
        { "_free","()V", jit_java_jitobj_free  },
        { "freePeer","()V", jit_java_jitobj_free  },
        { "bang","()[Lcom/cycling74/max/Atom;",jit_java_jitobj_bang},
        { "send","(I)[Lcom/cycling74/max/Atom;",jit_java_jitobj_send_int },
        { "send","(F)[Lcom/cycling74/max/Atom;",jit_java_jitobj_send_float },

        { "send","(Ljava/lang/String;[Lcom/cycling74/max/Atom;)[Lcom/cycling74/max/Atom;",jit_java_jitobj_send },
        { "send","(Ljava/lang/String;I)[Lcom/cycling74/max/Atom;",jit_java_jitobj_send_msg_int },
        { "send","(Ljava/lang/String;[I)[Lcom/cycling74/max/Atom;",jit_java_jitobj_send_msg_intarray },
        { "send","(Ljava/lang/String;F)[Lcom/cycling74/max/Atom;",jit_java_jitobj_send_msg_float },
        { "send","(Ljava/lang/String;[F)[Lcom/cycling74/max/Atom;",jit_java_jitobj_send_msg_floatarray },
        { "send","(Ljava/lang/String;Ljava/lang/String;)[Lcom/cycling74/max/Atom;",jit_java_jitobj_send_msg_string },
        { "send","(Ljava/lang/String;[Ljava/lang/String;)[Lcom/cycling74/max/Atom;",jit_java_jitobj_send_msg_stringarray },

    //      could do doubles and other types (also single atom)

        { "setAttr","(Ljava/lang/String;[Lcom/cycling74/max/Atom;)Z",jit_java_jitobj_setattr },
        { "setAttr","(Ljava/lang/String;I)Z",jit_java_jitobj_setattr_int },
        { "setAttr","(Ljava/lang/String;[I)Z",jit_java_jitobj_setattr_intarray },
        { "setAttr","(Ljava/lang/String;F)Z",jit_java_jitobj_setattr_float },
        { "setAttr","(Ljava/lang/String;[F)Z",jit_java_jitobj_setattr_floatarray },
        { "setAttr","(Ljava/lang/String;Ljava/lang/String;)Z",jit_java_jitobj_setattr_string },
        { "setAttr","(Ljava/lang/String;[Ljava/lang/String;)Z",jit_java_jitobj_setattr_stringarray },
    //      could do doubles and other types (also single atom)

        { "getAttr","(Ljava/lang/String;)[Lcom/cycling74/max/Atom;",jit_java_jitobj_getattr },
        { "getAttrInt","(Ljava/lang/String;)I",jit_java_jitobj_getattr_int },
        { "getAttrIntArray","(Ljava/lang/String;)[I",jit_java_jitobj_getattr_intarray },
        { "getAttrFloat","(Ljava/lang/String;)F",jit_java_jitobj_getattr_float },
        { "getAttrFloatArray","(Ljava/lang/String;)[F",jit_java_jitobj_getattr_floatarray },
        { "getAttrString","(Ljava/lang/String;)Ljava/lang/String;",jit_java_jitobj_getattr_string },
        { "getAttrStringArray","(Ljava/lang/String;)[Ljava/lang/String;",jit_java_jitobj_getattr_stringarray },
    //      could do doubles and other types (also single atom)

        { "getRegisteredName","()Ljava/lang/String;",jit_java_jitobj_getregisteredname },

        { "matrixcalc","(Ljava/lang/Object;Ljava/lang/Object;)Z",jit_java_jitobj_matrixcalc },

        // JitterMatrix class will have special methods for just about everything

        { "getJitterClass","()Ljava/lang/String;",jit_java_jitobj_get_class },
        { "understands","(Ljava/lang/String;)Z",jit_java_jitobj_understands},
        { NULL, NULL, NULL } 
    };

    if (!clazz)
        return;
    while (methods[count].name) count++; 
    JIT_JAVA_JNI_CALL(env,RegisterNatives)(env,clazz,methods,count);
    checkException(env);  
}


/*-----------------------------------------------------------
 *
 * utlilty functions
 * 
 *-----------------------------------------------------------*/

int checkException(JNIEnv *env) 
{
    if (JIT_JAVA_JNI_CALL(env,ExceptionCheck)(env)) {
        JIT_JAVA_JNI_CALL(env,ExceptionDescribe)(env);
        return 1;
    }
    return 0;
}

jclass jit_java_getclassbyname(JNIEnv *env, char *className) 
{
    jclass l_class = NULL;
    jclass g_class = NULL;
    
    JIT_JAVA_JNI_CALL(env,PushLocalFrame)(env,JIT_JAVA_FRAME_SIZE);
    
    JIT_JAVA_JNI_CALL(env,ExceptionClear)(env); 
    l_class = JIT_JAVA_JNI_CALL(env,FindClass)(env, className);
    
    if (JIT_JAVA_JNI_CALL(env,ExceptionCheck)(env) || (l_class == NULL)) {
        JIT_JAVA_JNI_CALL(env,ExceptionDescribe)(env);
        JIT_JAVA_JNI_CALL(env,ExceptionClear)(env);
        BAG2("Could not load class '%s'", className);
    }
    g_class = JIT_JAVA_JNI_CALL(env,NewGlobalRef)(env, l_class);
    if (g_class == NULL) {
        BAG2("Out of memory creating global ref for class '%s'", className);
    }
    
    JIT_JAVA_JNI_CALL(env,PopLocalFrame)(env,NULL);
    return g_class;
}


jobject jit_java_newatom(JNIEnv *env, t_atom *a) 
{
    jobject l_result = NULL;
    
    if (!a)
        return NULL;
    switch (a->a_type) {
        case A_LONG:
            l_result = JIT_JAVA_JNI_CALL(env,CallStaticObjectMethod)(env, g_atom_clazz,
                                                      g_newIntAtom_MID, (jint)a->a_w.w_long);
            break;
                
        case A_FLOAT:
            l_result = JIT_JAVA_JNI_CALL(env,CallStaticObjectMethod)(env, g_atom_clazz,
                                                      g_newFloatAtom_MID, (jfloat)a->a_w.w_float);
            break;
                
        case A_SYM: {
            jstring javaStr = JIT_JAVA_JNI_CALL(env,NewStringUTF)(env, a->a_w.w_sym->s_name);
            l_result = JIT_JAVA_JNI_CALL(env,CallStaticObjectMethod)(env, g_atom_clazz,
                                                      g_newStringAtom_MID,
                                                      javaStr);
              //we can do this since now the atom object has a ref to the string 
              JIT_JAVA_JNI_CALL(env,DeleteLocalRef)(env,javaStr);
            break;
        }
            
        default:
            error("jit_java_newatom: default (%d)", a->a_type);
            break;
    }
    
    return l_result;
}

jobjectArray jit_java_newatomarray(JNIEnv *env, short ac, t_atom *av) 
{
    jsize i;
    jobjectArray ja = JIT_JAVA_JNI_CALL(env,NewObjectArray)(env, ac, g_atom_clazz, NULL);
    
    for (i = 0; i < ac; i++) {
        jobject atom = jit_java_newatom(env, av+i);
        JIT_JAVA_JNI_CALL(env,SetObjectArrayElement)(env, ja, i, atom);
        JIT_JAVA_JNI_CALL(env,DeleteLocalRef)(env,atom);
    }
    return ja;
}

jintArray jit_java_newintarray(JNIEnv *env, short ac, t_atom *av) 
{
    jsize i;
    jint *vp;
    jintArray ja=0;

    if (ac&&av) {
        vp  = (jint *)jit_getbytes(ac * sizeof(jint));
        ja  = (jarray)JIT_JAVA_JNI_CALL(env,NewIntArray)(env,ac);
        checkException(env);
                        
        for(i=0;i<ac;i++)
            vp[i] = (jint)atom_getlong(av+i);   
        
        JIT_JAVA_JNI_CALL(env,SetIntArrayRegion)(env,(jintArray)ja,0,ac,(jint *)vp); 
        checkException(env);
        
        jit_freebytes(vp,ac*sizeof(jint));
    }

    return ja;
}

jfloatArray jit_java_newfloatarray(JNIEnv *env, short ac, t_atom *av) 
{
    jsize i;
    jfloat *vp;
    jfloatArray ja=0;

    if (ac&&av) {
        vp  = (jfloat *)jit_getbytes(ac * sizeof(jfloat));
        ja  = (jarray)JIT_JAVA_JNI_CALL(env,NewFloatArray)(env,ac);
        checkException(env);
                        
        for(i=0;i<ac;i++)
            vp[i] = (jfloat)atom_getfloat(av+i);    
        
        JIT_JAVA_JNI_CALL(env,SetFloatArrayRegion)(env,(jfloatArray)ja,0,ac,(jfloat *)vp); 
        checkException(env);
        
        jit_freebytes(vp,ac*sizeof(jfloat));
    }

    return ja;
}

jdoubleArray jit_java_newdoublearray(JNIEnv *env, short ac, t_atom *av) 
{
    jsize i;
    jdouble *vp;
    jdoubleArray ja=0;

    if (ac&&av) {
        vp  = (jdouble *)jit_getbytes(ac * sizeof(jdouble));
        ja  = (jarray)JIT_JAVA_JNI_CALL(env,NewFloatArray)(env,ac);
        checkException(env);
                        
        for(i=0;i<ac;i++)
            vp[i] = (jdouble)atom_getfloat(av+i);   
        
        JIT_JAVA_JNI_CALL(env,SetDoubleArrayRegion)(env,(jdoubleArray)ja,0,ac,(jdouble *)vp); 
        checkException(env);
        
        jit_freebytes(vp,ac*sizeof(jdouble));
    }

    return ja;
}

t_atom *jit_java_newargv(JNIEnv *env, jobjectArray array, short *nElts) {
    short argc;
    t_atom *result;
    int i;
    
    if(array == NULL)
    {
        *nElts = 0;
        return 0;
    }   
    argc = JIT_JAVA_JNI_CALL(env,GetArrayLength)(env, array);
    result = (t_atom *)jit_getbytes(argc * sizeof(t_atom));
        
    for (i = 0; i < argc; i++) {
        jobject javaAtom = JIT_JAVA_JNI_CALL(env,GetObjectArrayElement)(env, array, i);
        int javaAtomType = JIT_JAVA_JNI_CALL(env,CallIntMethod)(env, javaAtom, g_getAtomType_MID);

        switch (javaAtomType) {
            case ATOM_TYPENUM_LONG: {
                long value = JIT_JAVA_JNI_CALL(env,CallIntMethod)(env, javaAtom, g_getIntValue_MID);
                SETLONG(&result[i], value);
                break;
            }
            
            case ATOM_TYPENUM_FLOAT: {
                SETFLOAT(&result[i], JIT_JAVA_JNI_CALL(env,CallFloatMethod)(env, javaAtom, g_getFloatValue_MID));
                break;
            }
                
            case ATOM_TYPENUM_STRING: {
                jstring str = JIT_JAVA_JNI_CALL(env,CallObjectMethod)(env, javaAtom, g_getStringValue_MID);
                const char *chars = JIT_JAVA_JNI_CALL(env,GetStringUTFChars)(env, str, NULL);
                t_symbol *sym = gensym((char *)chars);
                SETSYM(&result[i], sym);
                JIT_JAVA_JNI_CALL(env,ReleaseStringUTFChars)(env, str, chars);
                JIT_JAVA_JNI_CALL(env,DeleteLocalRef)(env,str);
                break;
            }
            
            default: {
                post("jit_java_newargv: default (%d)", javaAtomType);
                break;
            }
        }
        JIT_JAVA_JNI_CALL(env,DeleteLocalRef)(env, javaAtom);
    }
    (*nElts) = argc;
    return result;
}

long jit_java_atomsfromintarray(JNIEnv *env, jintArray array, long count, t_atom *av)
{
    long i,ac=0;
    jint *elements;
    jboolean is_copy; 

    if (array) {
        ac = JIT_JAVA_JNI_CALL(env,GetArrayLength)(env,array);
        if (count&&ac>count)
            ac = count;
            
        elements = JIT_JAVA_JNI_CALL(env, GetIntArrayElements)(env,(jintArray)array,&is_copy);
        checkException(env);

        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);
        }

    }
    return ac;
}

long jit_java_atomsfromfloatarray(JNIEnv *env, jfloatArray array, long count, t_atom *av)
{
    long i,ac=0;
    jfloat *elements;
    jboolean is_copy; 

    if (array) {
        ac = JIT_JAVA_JNI_CALL(env,GetArrayLength)(env,array);
        if (count&&ac>count)
            ac = count;
            
        elements = JIT_JAVA_JNI_CALL(env, GetFloatArrayElements)(env,(jfloatArray)array,&is_copy);
        checkException(env);

        for(i=0;i<ac;i++)   
            atom_setfloat(av+i,elements[i]);
        if (is_copy)
        {
            JIT_JAVA_JNI_CALL(env, ReleaseFloatArrayElements)(env,(jfloatArray)array,elements,0);
            checkException(env);
        }

    }
    return ac;
}

long jit_java_atomsfromdoublearray(JNIEnv *env, jdoubleArray array, long count, t_atom *av)
{
    long i,ac=0;
    jdouble *elements;
    jboolean is_copy; 

    if (array) {
        ac = JIT_JAVA_JNI_CALL(env,GetArrayLength)(env,array);
        if (count&&ac>count)
            ac = count;
            
        elements = JIT_JAVA_JNI_CALL(env, GetDoubleArrayElements)(env,(jdoubleArray)array,&is_copy);
        checkException(env);

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

    }
    return ac;
}

Copyright © 2008, Cycling '74