void *max_ta_jit_kinect2_new(t_symbol *s, long argc, t_atom *argv)
{
t_max_ta_jit_kinect2 *x;
void *o;
x = (t_max_ta_jit_kinect2 *)max_jit_object_alloc(max_ta_jit_kinect2_class, gensym("ta_jit_kinect2"));
if (x) {
o = jit_object_new(gensym("ta_jit_kinect2"));
if (o) {
max_jit_mop_setup_simple(x, o, argc, argv);
max_jit_attr_args(x, argc, argv);
t_atom_long depthdim[2] = {DEPTH_WIDTH, DEPTH_HEIGHT};
t_atom_long rgbdim[2] = {RGB_WIDTH, RGB_HEIGHT};
//TA: set depth matrix initial attributes
void *output = max_jit_mop_getoutput(x, 1);
jit_attr_setsym(output, _jit_sym_type, _jit_sym_float32);
jit_attr_setlong_array(output, _jit_sym_dim, 2, depthdim);
jit_attr_setlong(output, _jit_sym_planecount, 1);
//TA: set rgb matrix initial attributes
output = max_jit_mop_getoutput(x, 2);
jit_attr_setsym(output, _jit_sym_type, _jit_sym_char);
jit_attr_setlong_array(output, _jit_sym_dim, 2, rgbdim);
jit_attr_setlong(output, _jit_sym_planecount, 4);
}
else {
jit_object_error((t_object *)x, "ta.jit.kinect2: could not allocate object");
object_free((t_object *)x);
x = NULL;
}
}
return (x);
}
void *max_jit_submatrix_new(t_symbol *s, long argc, t_atom *argv)
{
t_max_jit_submatrix *x;
void *o,*m,*mop,*p;
t_jit_matrix_info info;
if (x=(t_max_jit_submatrix *)max_jit_obex_new(max_jit_submatrix_class,gensym("jit_submatrix"))) {
if (o=jit_object_new(gensym("jit_submatrix"))) {
max_jit_obex_jitob_set(x,o);
max_jit_obex_dumpout_set(x,outlet_new(x,NULL));
max_jit_mop_setup(x);
max_jit_mop_inputs(x);
max_jit_mop_outputs(x);
mop=max_jit_obex_adornment_get(x,_jit_sym_jit_mop);
jit_attr_setlong(mop,gensym("adapt"),0);
jit_attr_setlong(mop,gensym("caninplace"),0);
jit_attr_setlong(mop,gensym("outputmode"),1);
//make the output matrix a data reference w/NULL data pointer
m = max_jit_mop_getoutput(x,1);
jit_object_method(m,_jit_sym_getinfo,&info);
jit_object_method(m,gensym("freedata"));
info.flags = JIT_MATRIX_DATA_REFERENCE;
info.size = 0;
p = NULL;
jit_object_method(m,_jit_sym_setinfo_ex,&info);
jit_object_method(m,_jit_sym_data,p);
max_jit_attr_args(x,argc,argv);
} else {
jit_object_error((t_object *)x,"jit.submatrix: could not allocate object");
freeobject((t_object *) x);
x = NULL;
}
}
return (x);
}
void *max_jit_histogram_new(t_symbol *s, long argc, t_atom *argv)
{
t_max_jit_histogram *x;
void *o,*m;
t_jit_matrix_info info;
long dim=256;
t_symbol *type=_jit_sym_long;
if (x=(t_max_jit_histogram *)max_jit_obex_new(max_jit_histogram_class,gensym("jit_histogram"))) {
if (o=jit_object_new(gensym("jit_histogram"))) {
max_jit_mop_setup_simple(x,o,argc,argv);
//default long 256 output(plane is linked)
if (argc>=3) {
if ((argv[0].a_type==A_LONG)&&(argv[1].a_type==A_SYM)&&(argv[2].a_type==A_LONG)) {
type = jit_atom_getsym(argv+1);
if (type!=_jit_sym_char)
type = _jit_sym_long;
dim = jit_atom_getlong(argv+2);
}
}
m = max_jit_mop_getoutput(x,1);
jit_object_method(m,_jit_sym_getinfo,&info);
info.type = type;
info.dimcount = 1;
info.dim[0] = dim;
jit_object_method(m,_jit_sym_setinfo,&info);
max_jit_attr_args(x,argc,argv);
} else {
jit_object_error((t_object *)x,"jit.histogram: could not allocate object");
freeobject((t_object *) x);
x = NULL;
}
}
return (x);
}
void *max_jit_rgb2luma_new(t_symbol *s, long argc, t_atom *argv)
{
t_max_jit_rgb2luma *x;
void *o,*m;
t_jit_matrix_info info;
if (x=(t_max_jit_rgb2luma *)max_jit_obex_new(max_jit_rgb2luma_class,gensym("jit_rgb2luma"))) {
if (o=jit_object_new(gensym("jit_rgb2luma"))) {
max_jit_mop_setup_simple(x,o,argc,argv);
//1-plane char out
m = max_jit_mop_getoutput(x,1);
jit_object_method(m,_jit_sym_getinfo,&info);
info.type = _jit_sym_char;
info.planecount = 1;
info.dimcount = 2;
// info.dim[0] = 160;
// info.dim[1] = 120;
jit_object_method(m,_jit_sym_setinfo,&info);
max_jit_attr_args(x,argc,argv);
} else {
jit_object_error((t_object *)x,"jit.rgb2luma: could not allocate object");
freeobject((t_object *) x);
x = NULL;
}
}
return (x);
}
void *max_jit_unpack_new(t_symbol *s, long argc, t_atom *argv)
{
t_max_jit_unpack *x;
void *o,*m,*p,*mop;
t_jit_matrix_info info;
long i;
if (x=(t_max_jit_unpack *)max_jit_obex_new(max_jit_unpack_class,gensym("jit_unpack"))) {
if (o=jit_object_new(gensym("jit_unpack"))) {
max_jit_obex_jitob_set(x,o);
max_jit_obex_dumpout_set(x,outlet_new(x,NULL));
max_jit_mop_setup(x);
max_jit_mop_inputs(x);
if (argc&&(i=jit_atom_getlong(argv))) {
CLIP(i,1,JIT_MATRIX_MAX_PLANECOUNT);
} else {
i=4;
}
x->outlets = i;
max_jit_mop_variable_addoutputs(x,i);
while (i) {
p=max_jit_mop_getoutput(x,i);
jit_attr_setlong(p,gensym("minplanecount"),1);
jit_attr_setlong(p,gensym("maxplanecount"),1);
i--;
}
max_jit_mop_outputs(x);
max_jit_mop_matrix_args(x,argc,argv);
//set adapt true if only plane argument(should come after matrix_args call)
if ((max_jit_attr_args_offset(argc,argv)<=1) &&
(mop=max_jit_obex_adornment_get(x,_jit_sym_jit_mop)))
{
jit_attr_setlong(mop,_jit_sym_adapt,1);
}
max_jit_attr_args(x,argc,argv);
} else {
jit_object_error((t_object *)x,"jit.unpack: could not allocate object");
freeobject(x);
x = NULL;
}
}
return (x);
}
void *max_jit_dmxmap_new(t_symbol *s, long argc, t_atom *argv)
{
t_max_jit_dmxmap *x;
void *o,*m;
t_jit_matrix_info info;
long n;
if (x = (t_max_jit_dmxmap *)max_jit_obex_new(class_max_jit_dmxmap,gensym("jit_dmxmap"))) {
if (o=jit_object_new(gensym("jit_dmxmap"))) {
attr_args_process(x, argc, argv);
argc = attr_args_offset(argc, argv);
max_jit_obex_jitob_set(x, o);
max_jit_obex_dumpout_set(x, outlet_new(x,NULL));
max_jit_mop_setup(x);
max_jit_mop_inputs(x);
max_jit_mop_outputs(x);
if(argc == 1)
n = jit_atom_getlong(&argv[0]);
else
n = 512;
m = max_jit_mop_getoutput(x, 1);
jit_object_method(m, _jit_sym_getinfo, &info);
info.type = _jit_sym_char;
info.planecount = 1;
info.dimcount = 1;
info.dim[0] = n;
info.dimstride[0] = 1;
info.dimstride[1] = n;
jit_object_method(m, _jit_sym_setinfo, &info);
//max_jit_obex_jitob_set(x,o);
//max_jit_attr_args(x,argc,argv);
} else {
jit_object_error((t_object *)x,"jit.dmxmap: out of memory");
freeobject((void *)x);
x = NULL;
goto out;
}
}
out:
return (x);
}
void max_jit_unpack_jit_matrix(t_max_jit_unpack *x, t_symbol *s, long argc, t_atom *argv)
{
long i;
long jump[JIT_MATRIX_MAX_PLANECOUNT];
void *o, *p;
o = max_jit_obex_jitob_get(x);
jit_attr_getlong_array(o, gensym("jump"), JIT_MATRIX_MAX_PLANECOUNT, jump);
for(i=0; i < x->outlets; i++) {
p=max_jit_mop_getoutput(x,i+1);
jit_attr_setlong(p,gensym("minplanecount"),jump[i]);
jit_attr_setlong(p,gensym("maxplanecount"),jump[i]);
}
max_jit_mop_jit_matrix(x,s,argc,argv);
}
void max_jit_submatrix_mproc(t_max_jit_submatrix *x, void *mop)
{
t_jit_err err;
if (err=(t_jit_err) jit_object_method(
max_jit_obex_jitob_get(x),
_jit_sym_matrix_calc,
jit_object_method(mop,_jit_sym_getinputlist),
jit_object_method(mop,_jit_sym_getoutputlist)))
{
jit_error_code(x,err);
} else {
max_jit_mop_outputmatrix(x);
jit_object_method(max_jit_mop_getoutput(x,1),_jit_sym_data,NULL);
}
}
void *max_jit_coerce_new(t_symbol *s, long argc, t_atom *argv)
{
t_max_jit_coerce *x;
void *o,*m,*mop,*p;
t_jit_matrix_info info;
long attrstart;
t_atom_long planecount=4;
t_symbol *type=_jit_sym_char;
if (x=(t_max_jit_coerce *)max_jit_obex_new(max_jit_coerce_class,gensym("jit_coerce"))) {
if (o=jit_object_new(gensym("jit_coerce"))) {
max_jit_obex_jitob_set(x,o);
max_jit_obex_dumpout_set(x,outlet_new(x,NULL));
max_jit_mop_setup(x);
max_jit_mop_inputs(x);
max_jit_mop_outputs(x);
mop=max_jit_obex_adornment_get(x,_jit_sym_jit_mop);
jit_attr_setlong(mop,gensym("adapt"),0);
jit_attr_setlong(mop,gensym("caninplace"),0);
jit_attr_setlong(mop,gensym("outputmode"),1);
//make the output matrix a data reference w/NULL data pointer
attrstart = max_jit_attr_args_offset(argc,argv);
if (attrstart&&argv) {
jit_atom_arg_getlong(&planecount, 0, attrstart, argv);
jit_atom_arg_getsym(&type, 1, attrstart, argv);
jit_attr_setlong(o,_jit_sym_planecount,planecount);
jit_attr_setsym(o,_jit_sym_type,type);
}
m = max_jit_mop_getoutput(x,1);
jit_object_method(m,_jit_sym_getinfo,&info);
jit_object_method(m,gensym("freedata"));
info.flags = JIT_MATRIX_DATA_REFERENCE;
info.size = 0;
p = NULL;
jit_object_method(m,_jit_sym_setinfo_ex,&info);
jit_object_method(m,_jit_sym_data,p);
max_jit_attr_args(x,argc,argv);
} else {
jit_object_error((t_object *)x,"jit.coerce: could not allocate object");
freeobject((t_object *) x);
x = NULL;
}
}
return (x);
}
