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