void minimum_bang(t_minimum *x)
{
long i;
t_big_atom themin;
long minIndex;
long res;
double fres;
minIndex = 0;
themin.a_type = A_NOTHING;
systhread_mutex_lock(x->m_mutex);
for (i=0; i < x->m_count; i++)
minimum_compare(&themin,x->m_args+i, &i, &minIndex);
systhread_mutex_unlock(x->m_mutex);
outlet_int(x->m_out2, minIndex);
if (x->m_outtype==A_LONG) {
if (themin.a_type == A_LONG)
res = themin.w_long;
else
res = (long)themin.w_float;
outlet_int(x->m_out,res);
} else {
if (themin.a_type == A_FLOAT)
fres = themin.w_float;
else
fres = (float)themin.w_long;
outlet_float(x->m_out,fres);
}
}
void minimum_float(t_minimum *x, double f)
{
systhread_mutex_lock(x->m_mutex);
atom_setfloat(x->m_args,f);
systhread_mutex_unlock(x->m_mutex);
minimum_bang(x);
}
void minimum_int(t_minimum *x, long n)
{
systhread_mutex_lock(x->m_mutex);
atom_setlong(x->m_args,n);
systhread_mutex_unlock(x->m_mutex);
minimum_bang(x);
}
void depth_callback(freenect_device *dev, void *pixels, uint32_t timestamp){
t_jit_freenect_grab *x;
x = freenect_get_user(dev);
if(!x)
{
error("Invalid max object supplied in depth_callback\n");// TODO:should print only in debug mode
return;
}
//post("depth_callback called\n");//TODO:r
if (x->is_open)
{
systhread_mutex_lock(x->backbuffer_mutex);
// pthread_mutex_lock(&x->cb_mutex);
//assert(x->depth_back == pixels);
// x->depth_back = x->depth_mid;
x->depth_back = x->depth_mid;
freenect_set_depth_buffer(dev, x->depth_back);
x->depth_mid = (uint16_t*)pixels;
x->got_depth++;
systhread_mutex_unlock(x->backbuffer_mutex);
}
//pthread_mutex_unlock(&x->cb_mutex);
}
void rgb_callback(freenect_device *dev, void *pixels, uint32_t timestamp){
t_jit_freenect_grab *x;
x = freenect_get_user(dev);
if(!x)
{
error("Invalid max object supplied in rgb_callback\n");// TODO:should print only in debug mode
return;
}
if (x->is_open)
{
systhread_mutex_lock(x->backbuffer_mutex);
//pthread_mutex_lock(&x->cb_mutex);
/*
x->rgb_data = pixels;
x->rgb_timestamp = timestamp;
x->have_rgb_frames++;
*/
//assert(x->rgb_back == pixels);
x->rgb_back = x->rgb_mid;
freenect_set_video_buffer(dev, x->rgb_back);
x->rgb_mid = (uint8_t*)pixels;
x->got_rgb++;
systhread_mutex_unlock(x->backbuffer_mutex);
}
//pthread_mutex_unlock(&x->cb_mutex);
}
void *simplethread_threadproc(t_simplethread *x)
{
// loop until told to stop
while (1) {
// test if we're being asked to die, and if so return before we do the work
if (x->x_systhread_cancel)
break;
systhread_mutex_lock(x->x_mutex);
x->x_foo++; // fiddle with shared data
systhread_mutex_unlock(x->x_mutex);
qelem_set(x->x_qelem); // notify main thread using qelem mechanism
systhread_sleep(x->x_sleeptime); // sleep a bit
}
x->x_systhread_cancel = false; // reset cancel flag for next time, in case
// the thread is created again
systhread_exit(0); // this can return a value to systhread_join();
return NULL;
}
void minimum_ft1(t_minimum *x, double f)
{
t_atom tmp = x->m_args[0];
systhread_mutex_lock(x->m_mutex);
minimum_resize(x,2);
x->m_args[0] = tmp;
atom_setfloat(x->m_args+1,f);
x->m_count = 2;
systhread_mutex_unlock(x->m_mutex);
}
void minimum_in1(t_minimum *x, long n)
{
t_atom tmp = x->m_args[0];
systhread_mutex_lock(x->m_mutex);
minimum_resize(x,2);
x->m_args[0] = tmp;
atom_setlong(x->m_args+1,n);
x->m_count = 2;
systhread_mutex_unlock(x->m_mutex);
}
// triggered by the helper thread
void simplethread_qfn(t_simplethread *x)
{
int myfoo;
systhread_mutex_lock(x->x_mutex);
myfoo = x->x_foo; // access shared data
systhread_mutex_unlock(x->x_mutex);
// *never* wrap outlet calls with systhread_mutex_lock()
outlet_int(x->x_outlet, myfoo);
}
void minimum_list(t_minimum *x, t_symbol *s, long ac, t_atom *av)
{
long i;
systhread_mutex_lock(x->m_mutex);
minimum_resize(x,ac);
for (i=0; i < ac; i++,av++) {
if (atom_gettype(av)==A_LONG)
atom_setlong(x->m_args+i,atom_getlong(av));
else if (atom_gettype(av)==A_FLOAT)
atom_setfloat(x->m_args+i,atom_getfloat(av));
}
x->m_count = ac;
systhread_mutex_unlock(x->m_mutex);
minimum_bang(x);
}
void simpleparallel_dobang(t_simpleparallel *x)
{
int myfoo;
// create new task and execute it
if (x->x_sysparallel_task == NULL) {
post("creating a new parallel task");
x->x_sysparallel_task = sysparallel_task_new(x,(method) simpleparallel_threadproc, 0);
x->x_sysparallel_task->flags = SYSPARALLEL_PRIORITY_TASK_LOCAL;
}
sysparallel_task_execute(x->x_sysparallel_task);
systhread_mutex_lock(x->x_mutex);
myfoo = x->x_foo;
systhread_mutex_unlock(x->x_mutex);
// *never* wrap outlet calls with systhread_mutex_lock()
outlet_int(x->x_outlet, myfoo);
}
void *simpleparallel_threadproc(t_sysparallel_worker *w)
{
t_simpleparallel *x = (t_simpleparallel *)w->data;
int i,myfoo=0,iterations;
double time = systimer_gettime();
object_post((t_object *)x,"worker %ld of %ld started",w->id,w->task->workercount);
// do some work
iterations = x->x_iterations;
for (i=0; i<iterations; i++) {
myfoo++;
}
// increment our main value
systhread_mutex_lock(x->x_mutex);
x->x_foo += myfoo; // fiddle with shared data
systhread_mutex_unlock(x->x_mutex);
object_post((t_object *)x,"worker %ld of %ld ended (%fms)",w->id,w->task->workercount,systimer_gettime()-time);
return NULL;
}
void simpleparallel_foo(t_simpleparallel *x, long foo)
{
systhread_mutex_lock(x->x_mutex);
x->x_foo = foo; // override our current value
systhread_mutex_unlock(x->x_mutex);
}
t_jit_err jit_freenect_grab_matrix_calc(t_jit_freenect_grab *x, void *inputs, void *outputs)
{
t_jit_err err=JIT_ERR_NONE;
long depth_savelock=0,rgb_savelock=0;
t_jit_matrix_info depth_minfo,rgb_minfo;
void *depth_matrix,*rgb_matrix;
char *depth_bp, *rgb_bp;
uint8_t *tmp8;
uint16_t *tmp16;
int has_new_frame = 0;
int sync_to_depth = 0;
depth_matrix = jit_object_method(outputs,_jit_sym_getindex,0);
rgb_matrix = jit_object_method(outputs,_jit_sym_getindex,1);
if (x && depth_matrix && rgb_matrix) {
postNesaFlood("matrixcalc:isopem=%i",x->is_open);
if (x->is_open)
{
systhread_mutex_lock(x->backbuffer_mutex);
if (x->got_depth>0) {
tmp16 = x->depth_front;
x->depth_front = x->depth_mid;
x->depth_mid = tmp16;
x->got_depth = 0;
has_new_frame=1;
sync_to_depth=1;
}
if (x->got_rgb>0) {
tmp8 = x->rgb_front;
x->rgb_front = x->rgb_mid;
x->rgb_mid = tmp8;
x->got_rgb = 0;
has_new_frame=1;
}
systhread_mutex_unlock(x->backbuffer_mutex);
}
else {
postNesaFlood("matrixcalc:device not open");
}
depth_savelock = (long) jit_object_method(depth_matrix,_jit_sym_lock,1);
rgb_savelock = (long) jit_object_method(rgb_matrix,_jit_sym_lock,1);
if(!x->device){
goto out;
}
jit_object_method(depth_matrix,_jit_sym_getinfo,&depth_minfo);
jit_object_method(rgb_matrix,_jit_sym_getinfo,&rgb_minfo);
if ((depth_minfo.type == _jit_sym_char) || (rgb_minfo.type != _jit_sym_char))
{
err=JIT_ERR_MISMATCH_TYPE;
goto out;
}
if(x->device->video_format == FREENECT_VIDEO_IR_8BIT){
if(rgb_minfo.planecount != 1){
rgb_minfo.planecount = 1;
jit_object_method(rgb_matrix, _jit_sym_setinfo, &rgb_minfo);
jit_object_method(rgb_matrix, _jit_sym_getinfo, &rgb_minfo);
}
}
else{
if(rgb_minfo.planecount != 4){
rgb_minfo.planecount = 4;
jit_object_method(rgb_matrix, _jit_sym_setinfo, &rgb_minfo);
jit_object_method(rgb_matrix, _jit_sym_getinfo, &rgb_minfo);
}
}
/*
if (rgb_minfo.planecount != 4) //overkill, but you can never be too sure
{
err=JIT_ERR_MISMATCH_PLANE;
goto out;
}
*/
if(x->type==NULL){
x->type = depth_minfo.type;
}
if((depth_minfo.planecount != 1)&&(x->mode < 4)){
depth_minfo.planecount = 1;
depth_minfo.type = x->type;
depth_minfo.dimcount = 2;
depth_minfo.dim[0] = DEPTH_WIDTH;
depth_minfo.dim[1] = DEPTH_HEIGHT;
depth_minfo.flags = 0L;
jit_object_method(depth_matrix,_jit_sym_setinfo_ex,&depth_minfo);
jit_object_method(depth_matrix,_jit_sym_getinfo,&depth_minfo);
}
if((x->mode < 4)&&(x->type != depth_minfo.type)){
x->type = depth_minfo.type;
}
jit_object_method(depth_matrix,_jit_sym_getdata,&depth_bp);
if (!depth_bp) { err=JIT_ERR_INVALID_OUTPUT; goto out;}
jit_object_method(rgb_matrix,_jit_sym_getdata,&rgb_bp);
if (!rgb_bp) { err=JIT_ERR_INVALID_OUTPUT; goto out;}
if((depth_minfo.type != x->lut_type) || !x->lut.f_ptr){
calculate_lut(&x->lut, depth_minfo.type, x->mode);
x->lut_type = depth_minfo.type;
}
//Grab and copy matrices
/* x->has_frames = 0; //Assume there are no new frames
if(x->have_rgb_frames || x->have_depth_frames){
x->timestamp = MAX(x->rgb_timestamp,x->depth_timestamp);
if(x->have_rgb_frames){
copy_rgb_data(x->rgb_data, rgb_bp, &rgb_minfo);
x->have_rgb_frames = 0;
//x->has_frames = 1;
}
if(x->have_depth_frames){
//if(x->mode == 4){
// build_geometry(x, depth_matrix, depth_bp, &depth_minfo);
//}
//else{
copy_depth_data(x->depth_data, depth_bp, &depth_minfo, &x->lut);
//}
x->have_depth_frames = 0;
x->has_frames = 1;
}
else if((x->clear_depth)&&((x->rgb_timestamp - x->depth_timestamp)>3000000)){
jit_object_method(depth_matrix, _jit_sym_clear);
x->has_frames = 1;
post("Clearing depth...");//TODO:r
}
}
*/
if (x->is_open)
{
x->has_frames=sync_to_depth;//has_new_frame;
if (sync_to_depth>0) {
copy_rgb_data(x->rgb_front, rgb_bp, &rgb_minfo);
copy_depth_data(x->depth_front, depth_bp, &depth_minfo, &x->lut);
}
}
else {
postNesa("device not open");//TODO:r
}
} else {
return JIT_ERR_INVALID_PTR;
}
out:
jit_object_method(depth_matrix,gensym("lock"),depth_savelock);
jit_object_method(rgb_matrix,gensym("lock"),rgb_savelock);
//systhread_mutex_unlock(x->x_mutex);
return err;
}
//recursive function to handle higher dimension matrices, by processing 2D sections at a time
void jit_3m_calculate_ndim(t_jit_3m *x, long dimcount, long *dim, long planecount,
t_jit_matrix_info *in1_minfo, char *bip1)
{
long i,j,n;
char *ip1;
t_jit_op_info in1_opinfo;
t_jit_3m_vecdata vecdata;
if (dimcount<1) return; //safety
switch(dimcount) {
case 1:
dim[1] = 1;
case 2:
jit_3m_precalc(&vecdata,in1_minfo,bip1); //parallel moved thread local
n = dim[0];
in1_opinfo.stride = in1_minfo->dim[0]>1?planecount:0;
if (in1_minfo->type==_jit_sym_char) {
for (i=0;i<dim[1];i++){
for (j=0;j<planecount;j++) {
in1_opinfo.p = bip1 + i*in1_minfo->dimstride[1] + j;
jit_3m_vector_char(n,&in1_opinfo,&(vecdata.v_char.min[j]),
&(vecdata.v_char.mean[j]),&(vecdata.v_char.max[j]));
}
}
//parallel: protect access to global vecdata write
systhread_mutex_lock(x->mutex);
for (j=0;j<planecount;j++) {
if (vecdata.v_char.min[j]<x->vd.v_char.min[j])
x->vd.v_char.min[j] = vecdata.v_char.min[j];
if (vecdata.v_char.max[j]>x->vd.v_char.max[j])
x->vd.v_char.max[j] = vecdata.v_char.max[j];
x->vd.v_char.mean[j] += vecdata.v_char.mean[j];
}
systhread_mutex_unlock(x->mutex);
} else if (in1_minfo->type==_jit_sym_long) {
for (i=0;i<dim[1];i++){
for (j=0;j<planecount;j++) {
in1_opinfo.p = bip1 + i*in1_minfo->dimstride[1] + j*4;
jit_3m_vector_long(n,&in1_opinfo,&(vecdata.v_long.min[j]),
&(vecdata.v_long.mean[j]),&(vecdata.v_long.max[j]));
}
}
//parallel: protect access to global vecdata write
systhread_mutex_lock(x->mutex);
for (j=0;j<planecount;j++) {
if (vecdata.v_long.min[j]<x->vd.v_long.min[j])
x->vd.v_long.min[j] = vecdata.v_long.min[j];
if (vecdata.v_long.max[j]>x->vd.v_long.max[j])
x->vd.v_long.max[j] = vecdata.v_long.max[j];
x->vd.v_long.mean[j] += vecdata.v_long.mean[j];
}
systhread_mutex_unlock(x->mutex);
} else if (in1_minfo->type==_jit_sym_float32) {
for (i=0;i<dim[1];i++){
for (j=0;j<planecount;j++) {
in1_opinfo.p = bip1 + i*in1_minfo->dimstride[1] + j*4;
jit_3m_vector_float32(n,&in1_opinfo,&(vecdata.v_float32.min[j]),
&(vecdata.v_float32.mean[j]),&(vecdata.v_float32.max[j]));
}
}
//parallel: protect access to global vecdata write
systhread_mutex_lock(x->mutex);
for (j=0;j<planecount;j++) {
if (vecdata.v_float32.min[j]<x->vd.v_float32.min[j])
x->vd.v_float32.min[j] = vecdata.v_float32.min[j];
if (vecdata.v_float32.max[j]>x->vd.v_float32.max[j])
x->vd.v_float32.max[j] = vecdata.v_float32.max[j];
x->vd.v_float32.mean[j] += vecdata.v_float32.mean[j];
}
systhread_mutex_unlock(x->mutex);
} else if (in1_minfo->type==_jit_sym_float64) {
for (i=0;i<dim[1];i++){
for (j=0;j<planecount;j++) {
in1_opinfo.p = bip1 + i*in1_minfo->dimstride[1] + j*8;
jit_3m_vector_float64(n,&in1_opinfo,&(vecdata.v_float64.min[j]),
&(vecdata.v_float64.mean[j]),&(vecdata.v_float64.max[j]));
}
}
//parallel: protect access to global vecdata write
systhread_mutex_lock(x->mutex);
for (j=0;j<planecount;j++) {
if (vecdata.v_float64.min[j]<x->vd.v_float64.min[j])
x->vd.v_float64.min[j] = vecdata.v_float64.min[j];
if (vecdata.v_float64.max[j]>x->vd.v_float64.max[j])
x->vd.v_float64.max[j] = vecdata.v_float64.max[j];
x->vd.v_float64.mean[j] += vecdata.v_float64.mean[j];
}
systhread_mutex_unlock(x->mutex);
}
break;
default:
for (i=0;i<dim[dimcount-1];i++) {
ip1 = bip1 + i*in1_minfo->dimstride[dimcount-1];
jit_3m_calculate_ndim(x,dimcount-1,dim,planecount,in1_minfo,ip1);
}
}
}
