void veejay_bundle_sample_add_fx_atom( void *osc, int id,int entry, const char *word, const char *format, int type, void *value )
{
char osc_path[256];
oscclient_t *c = (oscclient_t*) osc;
if(!c->bundle)
{
c->bundle = lo_bundle_new( LO_TT_IMMEDIATE );
}
sprintf(osc_path, "/sample_%d/fx_%d/%s", id, entry,word );
lo_message lmsg = lo_message_new();
char realwin[128];
sprintf(realwin, "%sFX%d", c->window, entry );
lo_message_add_string(lmsg, realwin );
lo_message_add_string(lmsg, osc_path );
int ival;
char *str;
double gval;
uint64_t val;
switch(type)
{
case VEVO_ATOM_TYPE_STRING:
str = (char*) *( (char*) value);
lo_message_add_string( lmsg, str );
break;
case VEVO_ATOM_TYPE_BOOL:
case VEVO_ATOM_TYPE_INT:
ival = (int) *( (int*) value );
lo_message_add_int32( lmsg, ival );
break;
case VEVO_ATOM_TYPE_DOUBLE:
gval = (double) *( (double*) value );
lo_message_add_double( lmsg, gval );
break;
case VEVO_ATOM_TYPE_UINT64:
val = (uint64_t) *( (uint64_t*) value );
lo_message_add_int64( lmsg, (int64_t) val );
break;
default:
lo_message_free( lmsg );
return;
break;
}
lo_bundle_add_message( c->bundle,"/update/widget", lmsg );
}
int main(int argc, const char * argv[])
{
int tcpflag = 1;
printf("Usage: lo_bndlsend [u] (u means use UDP)\n");
if (argc == 2) {
tcpflag = (strchr(argv[1], 'u') == NULL);
}
printf("tcpflag %d\n", tcpflag);
sleep(2); // allow some time for server to start
client = lo_address_new_with_proto(tcpflag ? LO_TCP : LO_UDP,
"localhost", "8100");
printf("client: %p\n", client);
char s[128];
lo_timetag now;
lo_timetag_now(&now);
lo_timetag timetag;
for (int i = 9; i >= 5; i--) {
// make the bundle
timetag_add(&timetag, now, 2 + i * 0.1);
lo_bundle bndl = lo_bundle_new(timetag);
// make first message
sprintf(s, "an arbitrary string at 2.%d", i);
lo_message msg1 = make_message(1000 + i, s);
// add the message to the bundle
lo_bundle_add_message(bndl, "/xyz/msg1", msg1);
// make second message
sprintf(s, "another arbitrary string at 2.%d", i);
lo_message msg2 = make_message(2000 + i, s);
// add the message to the bundle
lo_bundle_add_message(bndl, "/abcdefg/msg2", msg2);
// send it
lo_send_bundle(client, bndl);
}
send_nested(now, 3.0, 0.0, 3000);
send_nested(now, 3.1, 3.2, 4000);
sleep(1); // make sure messages go out
lo_address_free(client);
sleep(1); // time to clean up socketsa
printf("OSCSEND DONE\n");
return 0;
}
void veejay_bundle_add_blobs( void *osc, const char *msg, void *blub, void *blab, void *blib )
{
oscclient_t *c = (oscclient_t*) osc;
if(!c->bundle)
{
c->bundle = lo_bundle_new( LO_TT_IMMEDIATE );
}
lo_message lmsg = lo_message_new();
lo_blob blob = (lo_blob) blub;
lo_blob blob2 = (lo_blob) blab;
lo_blob blob3 = (lo_blob) blib;
lo_message_add_blob( lmsg, blob );
lo_message_add_blob( lmsg, blob2 );
lo_message_add_blob( lmsg, blob3 );
lo_bundle_add_message( c->bundle, msg, lmsg );
}
void *veejay_message_new_linked_pulldown( void *osc, const char *str1,const char *str2, const char *str3,
const char *str4, const char *format , const char *tooltip)
{
oscclient_t *c = (oscclient_t*) osc;
if(!c->bundle)
{
c->bundle = lo_bundle_new( LO_TT_IMMEDIATE );
}
lo_message lmsg = lo_message_new();
lo_message_add_string( lmsg, str1 );
lo_message_add_string( lmsg, str2 );
lo_message_add_string( lmsg, str3 );
lo_message_add_string( lmsg, str4 );
lo_message_add_string( lmsg, format );
lo_message_add_string( lmsg, tooltip );
return (void*) lmsg;
}
void veejay_bundle_add_atom( void *osc, const char *osc_path, const char *format, int type, void *value )
{
oscclient_t *c = (oscclient_t*) osc;
if(!c->bundle)
{
c->bundle = lo_bundle_new( LO_TT_IMMEDIATE );
}
lo_message lmsg = lo_message_new();
lo_message_add_string( lmsg,c->window );
lo_message_add_string( lmsg,osc_path );
int ival;
char *str;
double gval;
uint64_t val;
switch(type)
{
case VEVO_ATOM_TYPE_STRING:
str = (char*) *( (char*) value);
lo_message_add_string( lmsg, str );
break;
case VEVO_ATOM_TYPE_BOOL:
case VEVO_ATOM_TYPE_INT:
ival = (int) *( (int*) value );
lo_message_add_int32( lmsg, ival );
break;
case VEVO_ATOM_TYPE_DOUBLE:
gval = (double) *( (double*) value );
lo_message_add_double( lmsg, gval );
break;
case VEVO_ATOM_TYPE_UINT64:
val = (uint64_t) *( (uint64_t*) value );
lo_message_add_int64( lmsg, (int64_t) val );
break;
default:
lo_message_free( lmsg );
return;
break;
}
lo_bundle_add_message( c->bundle, "/update/widget", lmsg );
}
int lo_send_from(lo_address to, lo_server from, lo_timetag ts,
const char *path, const char *types, ...)
#endif
{
lo_bundle b = NULL;
va_list ap;
int ret;
#ifndef __GNUC__
const char *file = "";
int line = 0;
#endif
lo_message msg = lo_message_new();
if (ts.sec!=LO_TT_IMMEDIATE.sec || ts.frac!=LO_TT_IMMEDIATE.frac)
b = lo_bundle_new(ts);
// Clear any previous errors
to->errnum = 0;
to->errstr = NULL;
va_start(ap, types);
ret = lo_message_add_varargs_internal(msg, types, ap, file, line);
if (to->errnum) {
if (b) lo_bundle_free(b);
lo_message_free(msg);
return to->errnum;
}
if (b) {
lo_bundle_add_message(b, path, msg);
ret = lo_send_bundle_from(to, from, b);
} else {
ret = lo_send_message_from(to, from, path, msg);
}
// Free-up memory
lo_message_free(msg);
if (b) lo_bundle_free(b);
return ret;
}
void *veejay_message_new_pulldown( void *osc, const char *str1,const char *str2, const char *id, const char *str3,
const char *str4, double dv, const char *tooltip )
{
oscclient_t *c = (oscclient_t*) osc;
if(!c->bundle)
{
c->bundle = lo_bundle_new( LO_TT_IMMEDIATE );
}
lo_message lmsg = lo_message_new();
lo_message_add_string( lmsg, str1 );
lo_message_add_string( lmsg, str2 );
lo_message_add_string( lmsg, id );
lo_message_add_string( lmsg, str3 );
lo_message_add_string( lmsg, str4 );
lo_message_add_double( lmsg, dv );
lo_message_add_string( lmsg, tooltip );
return (void*) lmsg;
}
void veejay_bundle_plugin_add( void *osc, const char *window, const char *path, const char *format, void *value )
{
oscclient_t *c = (oscclient_t*) osc;
if(!c->bundle)
c->bundle = lo_bundle_new( LO_TT_IMMEDIATE );
lo_message lmsg = lo_message_new();
lo_message_add_string(lmsg, window );
lo_message_add_string(lmsg, path );
int n_elem = strlen( format );
int ival;
char *str;
double gval;
uint64_t val;
switch(*format)
{
case 's':
str = (char*) *( (char*) value);
lo_message_add_string( lmsg, str );
break;
case 'i':
ival = (int) *( (int*) value );
lo_message_add_int32( lmsg, ival );
break;
case 'd':
gval = (double) *( (double*) value );
lo_message_add_double( lmsg, gval );
break;
case 'h':
val = (uint64_t) *( (uint64_t*) value );
lo_message_add_int64( lmsg, (int64_t) val );
break;
default:
lo_message_free( lmsg );
return;
break;
}
lo_bundle_add_message( c->bundle,"/update/widget", lmsg );
}
static int send_msg_timestamped(lo_address a, lo_timetag *ts, char *path, term_t args)
{
lo_message msg=lo_message_new();
lo_bundle bun=lo_bundle_new(*ts);
if (add_msg_args(msg,args)) {
int ret;
lo_bundle_add_message(bun,path,msg);
ret = lo_send_bundle(a,bun);
lo_message_free(msg);
lo_bundle_free(bun);
if (ret==-1) {
return osc_error(lo_address_errno(a),lo_address_errstr(a),path);
} else {
return TRUE;
}
} else return FALSE;
}
void veejay_ui_bundle_add( void *osc, const char *msg, const char *format, ... )
{
oscclient_t *c = (oscclient_t*) osc;
if(!c->bundle)
{
c->bundle = lo_bundle_new( LO_TT_IMMEDIATE );
}
lo_message lmsg = lo_message_new();
va_list ap;
if( format )
{
va_start( ap, format );
veejay_add_arguments_( lmsg, format, ap );
va_end(ap);
}
lo_bundle_add_message( c->bundle, msg, lmsg );
}
void sendHandOSC() {
if (!haveHand)
return;
lo_bundle bundle = lo_bundle_new(LO_TT_IMMEDIATE);
if (!raw) {
jointCoords[0] = off_x + (mult_x * (480 - handCoords[0]) / 960); //Normalize coords to 0..1 interval
jointCoords[1] = off_y + (mult_y * (320 - handCoords[1]) / 640); //Normalize coords to 0..1 interval
jointCoords[2] = off_z + (mult_z * handCoords[2] * 7.8125 / 10000); //Normalize coords to 0..7.8125 interval
} else {
jointCoords[0] = handCoords[0];
jointCoords[1] = handCoords[1];
jointCoords[2] = handCoords[2];
}
oscFunc(&bundle, "l_hand", 6);
lo_send_bundle(addr, bundle);
printf("hand %.3f %.3f \r", jointCoords[0], jointCoords[1]);
haveHand = false;
}
void mapper_receiver_send_release_request(mapper_receiver rc,
mapper_signal sig,
mapper_signal_instance si,
mapper_timetag_t tt)
{
mapper_receiver_signal rs = rc->signals;
mapper_connection c;
if (!mapper_receiver_in_scope(rc, si->id_map->group))
return;
while (rs) {
if (rs->signal == sig)
break;
rs = rs->next;
}
if (!rs)
return;
//lo_bundle b = lo_bundle_new(tt);
lo_bundle b = lo_bundle_new(LO_TT_IMMEDIATE);
c = rs->connections;
while (c) {
lo_message m = lo_message_new();
if (!m)
return;
lo_message_add_int32(m, si->id_map->group);
lo_message_add_int32(m, si->id_map->remote);
lo_message_add_false(m);
lo_bundle_add_message(b, c->props.src_name, m);
c = c->next;
}
if (lo_bundle_count(b))
lo_send_bundle_from(rc->props.src_addr, rc->device->server, b);
lo_bundle_free_messages(b);
}
int info_handler(const char *path, const char *types, lo_arg **argv, int argc,
void *data, void *user_data)
{
// printf("info message\n");
// fflush(stdout);
lo_bundle b = lo_bundle_new( LO_TT_IMMEDIATE );
int num_joysticks = SDL_NumJoysticks();
// printf("Found %d joystick(s)\n\n", num_joysticks);
lo_message m1 = lo_message_new();
lo_message_add_int32( m1, num_joysticks );
lo_bundle_add_message( b, "/joystick/number", m1 );
int joy_idx;
for(joy_idx = 0; joy_idx < num_joysticks; ++joy_idx)
{
SDL_Joystick* joy = SDL_JoystickOpen(joy_idx);
if (!joy)
{
fprintf(stderr, "Unable to open joystick %d\n", joy_idx);
}
else
{
lo_message m2 = get_joystick_info_msg( joy_idx, joy );
lo_bundle_add_message( b, "/joystick/info", m2 );
// print_joystick_info(joy_idx, joy);
SDL_JoystickClose(joy);
}
// }
}
if ( lo_send_bundle_from( t, s, b ) == -1 ){
{ printf("sd2osc/info: OSC error %d: %s\n", lo_address_errno(t), lo_address_errstr(t)); }
}
lo_bundle_free( b );
fflush(stdout);
return 0;
}
void sendUserPosMsg(XnUserID id) {
XnPoint3D com;
sprintf(oscPositionAddressBuff[0], "/user/%d", id);
lo_bundle bundle = lo_bundle_new(LO_TT_IMMEDIATE);
lo_message msg = lo_message_new();
userGenerator.GetCoM(id, com);
if (!raw)
{
lo_message_add_float(msg, (float)(off_x + (mult_x * (1280 - com.X) / 2560)));
lo_message_add_float(msg, (float)(off_y + (mult_y * (1280 - com.Y) / 2560)));
lo_message_add_float(msg, (float)(off_z + (mult_z * com.Z * 7.8125 / 10000)));
}
else
{
lo_message_add_float(msg,com.X);
lo_message_add_float(msg,com.Y);
lo_message_add_float(msg,com.Z);
}
lo_bundle_add_message(bundle, oscPositionAddressBuff[0], msg);
lo_send_bundle(addr, bundle);
}
void veejay_xbundle_add( void *osc, const char *window, const char *widget, const char *format, ... )
{
oscclient_t *c = (oscclient_t*) osc;
if(!c->bundle)
{
c->bundle = lo_bundle_new( LO_TT_IMMEDIATE );
}
lo_message lmsg = lo_message_new();
if(!window)
lo_message_add_string(lmsg, c->window );
else
lo_message_add_string(lmsg, window );
lo_message_add_string(lmsg, widget );
if( format )
{
va_list ap;
va_start( ap, format );
veejay_add_arguments_( lmsg, format, ap );
va_end(ap);
}
lo_bundle_add_message( c->bundle, "/update/tegdiw", lmsg );
}
// note on memory handling of mapper_router_bundle_message():
// path: not owned, will not be freed (assumed is signal name, owned by signal)
// message: will be owned, will be freed when done
void send_or_bundle_message(mapper_link link, const char *path, lo_message msg,
mapper_timetag_t tt)
{
mapper_local_link llink = link->local;
// Check if a matching bundle exists
mapper_queue q = llink->queues;
while (q) {
if (memcmp(&q->tt, &tt,
sizeof(mapper_timetag_t))==0)
break;
q = q->next;
}
if (q) {
// Add message to existing bundle
lo_bundle_add_message(q->bundle, path, msg);
}
else {
// Send message immediately
lo_bundle b = lo_bundle_new(tt);
lo_bundle_add_message(b, path, msg);
lo_send_bundle_from(llink->data_addr, link->local_device->local->server, b);
lo_bundle_free_messages(b);
}
}
void main_loop(void *data) {
int i,j,n;
int32_t fseq = 0;
//verbose = 2;
// get the local IP adress for the TUIO2 source attribute
char hostname[64];
struct hostent *hp = NULL;
struct in_addr *addr = NULL;
gethostname(hostname, 64);
hp = gethostbyname(hostname);
if (hp==NULL) {
sprintf(hostname, "%s.local", hostname);
hp = gethostbyname(hostname);
}
if (hp!=NULL) {
for (i = 0; hp->h_addr_list[i] != 0; ++i) {
addr = (struct in_addr *)(hp->h_addr_list[i]);
}
} else {
//generate a random internet address
srand ( (unsigned int)time(NULL) );
int32_t r = rand();
addr = (struct in_addr*)&r;
}
while (running) {
uint8_t tag_count = 0;
bool updated = false;
lo_bundle osc_bundle = lo_bundle_new(LO_TT_IMMEDIATE);
nfc_target ant[MAX_TARGET_COUNT];
// List ISO14443A targets
if (verbose>1) printf("polling for a ISO14443A (MIFARE) tag:\n");
nfc_modulation nm = {
.nmt = NMT_ISO14443A,
.nbr = NBR_106,
};
lo_timetag frame_time;
lo_timetag_now (&frame_time);
for (int dev=0;dev<no_devices;dev++) {
if (pnd[dev] == NULL) continue;
if (!running) return;
lo_message frm_message = lo_message_new();
lo_message_add_int32(frm_message, fseq);
lo_message_add_timetag(frm_message, frame_time);
lo_message_add_int32(frm_message, 0); // sensor dim
if (device_count>1) sprintf(source_string, "NFOSC:%d",dev);
lo_message_add_string(frm_message, source_string); // source name
lo_bundle_add_message(osc_bundle, "/tuio2/frm", frm_message);
fseq++;
int szTargetFound = nfc_initiator_list_passive_targets (pnd[dev], nm, ant, MAX_TARGET_COUNT);
if (szTargetFound<0) {
if (no_devices==1) printf("NFC reader disconnected ...\n");
else printf("NFC reader #%d disconnected ...\n",dev);
pnd[dev] = NULL;
device_count--;
if (device_count==0) {
running=false;
return;
}
continue;
} else if (szTargetFound>0) {
for (n = 0; n < szTargetFound; n++) {
if (!running) return;
bool added = false;
nfosc_t found_tag;
found_tag.type_id = MIFARE_OTHER;
found_tag.device_id = dev;
decode_hex(ant[n].nti.nai.abtUid,ant[n].nti.nai.szUidLen);
strcpy(found_tag.uid_str,uid_str);
if ((ant[n].nti.nai.abtAtqa[0] == 0x00) && (ant[n].nti.nai.abtAtqa[1] == 0x04) && (ant[n].nti.nai.btSak == 0x09)) {
if (verbose>1) printf("NXP MIFARE Mini - UID: %s\n",uid_str);
found_tag.type_id = MIFARE_MINI;
} else if ((ant[n].nti.nai.abtAtqa[0] == 0x00) && (ant[n].nti.nai.abtAtqa[1] == 0x04) && (ant[n].nti.nai.btSak == 0x08)) {
if (verbose>1) printf("NXP MIFARE Classic 1K - UID: %s\n",uid_str);
found_tag.type_id = MIFARE_CLASSIC_1K;
} else if ((ant[n].nti.nai.abtAtqa[0] == 0x00) && (ant[n].nti.nai.abtAtqa[1] == 0x02) && (ant[n].nti.nai.btSak == 0x18)) {
if (verbose>1) printf("NXP MIFARE Classic 4K - UID: %s\n",uid_str);
found_tag.type_id = MIFARE_CLASSIC_4K;
} else if ((ant[n].nti.nai.abtAtqa[0] == 0x00) && (ant[n].nti.nai.abtAtqa[1] == 0x02) && (ant[n].nti.nai.btSak == 0x38)) {
if (verbose>1) printf("Nokia MIFARE Classic 4K - emulated - UID: %s\n",uid_str);
found_tag.type_id = MIFARE_CLASSIC_4K;
} else if ((ant[n].nti.nai.abtAtqa[0] == 0x00) && (ant[n].nti.nai.abtAtqa[1] == 0x44) && (ant[n].nti.nai.btSak == 0x00)) {
if (verbose>1) printf("NXP MIFARE Ultralight - UID: %s\n",uid_str);
found_tag.type_id = MIFARE_ULTRALIGHT;
} else if ((ant[n].nti.nai.abtAtqa[0] == 0x03) && (ant[n].nti.nai.abtAtqa[1] == 0x44) && (ant[n].nti.nai.btSak == 0x20)) {
if (verbose>1) printf("NXP MIFARE DESFire - UID: %s\n",uid_str);
} else if ((ant[n].nti.nai.abtAtqa[0] == 0x03) && (ant[n].nti.nai.abtAtqa[1] == 0x04) && (ant[n].nti.nai.btSak == 0x28)) {
if (verbose>1) printf("NXP JCOP31 - UID: %s\n",uid_str);
} else if ((ant[n].nti.nai.abtAtqa[0] == 0x00) && (ant[n].nti.nai.abtAtqa[1] == 0x48) && (ant[n].nti.nai.btSak == 0x20)) {
/* @todo handle ATS to be able to know which one it is */
if (verbose>1) printf("NXP JCOP31 or JCOP41 - UID: %s\n",uid_str);
} else if ((ant[n].nti.nai.abtAtqa[0] == 0x00) && (ant[n].nti.nai.abtAtqa[1] == 0x04) && (ant[n].nti.nai.btSak == 0x28)) {
if (verbose>1) printf("NXP JCOP41 - UID: %s\n",uid_str);
} else if ((ant[n].nti.nai.abtAtqa[0] == 0x00) && (ant[n].nti.nai.abtAtqa[1] == 0x04) && (ant[n].nti.nai.btSak == 0x88)) {
if (verbose>1) printf("Infineon MIFARE Classic 1K - UID: %s\n",uid_str);
found_tag.type_id = MIFARE_CLASSIC_1K;
} else if ((ant[n].nti.nai.abtAtqa[0] == 0x00) && (ant[n].nti.nai.abtAtqa[1] == 0x02) && (ant[n].nti.nai.btSak == 0x98)) {
if (verbose>1) printf("Gemplus MPCOS - UID: %s\n",uid_str);
} else if ((ant[n].nti.nai.abtAtqa[0] == 0x0C) && (ant[n].nti.nai.abtAtqa[1] == 0x00)) {
/* @note not sure if Jewel can be detected using this modulation */
if (verbose>1) printf("Innovision R&T Jewel - UID: %s\n",uid_str);
} else {
if (verbose>1) {
printf("ATQA (SENS_RES): %s\n", decode_hex(ant[n].nti.nai.abtAtqa,2));
printf(" UID (NFCID%c): ",(ant[n].nti.nai.abtUid[0]==0x08?'3':'1')); printf("%s\n",decode_hex(ant[n].nti.nai.abtUid,ant[n].nti.nai.szUidLen));
printf(" SAK (SEL_RES): %s\n", decode_hex(&ant[n].nti.nai.btSak,1));
if (ant[n].nti.nai.szAtsLen) {
printf(" ATS (ATR): %s\n",decode_hex(ant[n].nti.nai.abtAts,ant[n].nti.nai.szAtsLen));
}
printf("\n");
}
}
int32_t symbol_id = max_symbol_id;
int32_t i;
for (i=0;i<max_symbol_id;i++) {
if (strcmp(tag_database[i].uid_str,found_tag.uid_str)==0) {
symbol_id = i;
found_tag.symbol_id = symbol_id;
break;
}
}
if (symbol_id==max_symbol_id) {
symbol_id = max_symbol_id;
max_symbol_id++;
found_tag.symbol_id = symbol_id;
session_id++;
found_tag.session_id = session_id;
tag_database[symbol_id] = found_tag;
tag_buffer[buffer_size] = found_tag;
buffer_size++;
if (verbose) printf("assigning ID %d to UID %s\n",found_tag.symbol_id,found_tag.uid_str);
added = true;
} else {
int32_t b_pos = buffer_size;
for (i=0;i<buffer_size;i++) {
if ((strcmp(tag_buffer[i].uid_str,found_tag.uid_str)==0) && (tag_buffer[i].device_id==found_tag.device_id)) {
found_tag.session_id = tag_buffer[i].session_id;
b_pos=i;
break;
}
}
if (b_pos==buffer_size) {
session_id++;
found_tag.session_id = session_id;
tag_buffer[buffer_size] = found_tag;
buffer_size++;
added=true;
}
}
lo_message sym_message = lo_message_new();
lo_message_add_int32(sym_message, found_tag.session_id);
lo_message_add_int32(sym_message, found_tag.type_id);
lo_message_add_int32(sym_message, found_tag.symbol_id);
switch (found_tag.type_id) {
case MIFARE_ULTRALIGHT:
lo_message_add_string(sym_message, "mifare/ul");
break;
case MIFARE_CLASSIC_1K:
lo_message_add_string(sym_message, "mifare/1k");
break;
case MIFARE_CLASSIC_4K:
lo_message_add_string(sym_message, "mifare/4k");
break;
case MIFARE_MINI:
lo_message_add_string(sym_message, "mifare/mini");
break;
default:
lo_message_add_string(sym_message, "mifare/other");
}
lo_message_add_string(sym_message, found_tag.uid_str);
lo_bundle_add_message(osc_bundle, "/tuio2/sym", sym_message);
if (added) {
lo_message add_message = lo_message_new();
lo_message_add_int32(add_message, found_tag.device_id);
lo_message_add_int32(add_message, found_tag.symbol_id);
lo_message_add_int32(add_message, found_tag.type_id);
lo_message_add_string(add_message, found_tag.uid_str);
lo_bundle_add_message(osc_bundle, "/nfosc/add", add_message);
updated = true;
if (verbose) printf("add %d %d %d %s\n",found_tag.device_id,found_tag.symbol_id,found_tag.type_id,found_tag.uid_str);
}
frame_buffer[tag_count] = found_tag;
tag_count++;
}
}
lo_message sid_message = lo_message_new();
for (i=0;i<tag_count;i++)
if (frame_buffer[i].device_id==dev) lo_message_add_int32(sid_message, frame_buffer[i].session_id);
lo_bundle_add_message(osc_bundle, "/tuio2/alv", sid_message);
}
for (i=0;i<buffer_size;i++) {
bool removed = true;
for (j=0;j<=tag_count;j++) {
if ((strcmp(tag_buffer[i].uid_str,frame_buffer[j].uid_str)==0) && (tag_buffer[i].device_id == frame_buffer[j].device_id)) {
removed=false;
break;
}
}
if (removed) {
lo_message del_message = lo_message_new();
lo_message_add_int32(del_message, tag_buffer[i].device_id);
lo_message_add_int32(del_message, tag_buffer[i].symbol_id);
lo_message_add_int32(del_message, tag_buffer[i].type_id);
lo_message_add_string(del_message, tag_buffer[i].uid_str);
lo_bundle_add_message(osc_bundle, "/nfosc/del", del_message);
updated = true;
if (verbose) printf("del %d %d %d %s\n",tag_buffer[i].device_id,tag_buffer[i].symbol_id,tag_buffer[i].type_id,tag_buffer[i].uid_str);
}
}
if (updated) {
if(lo_send_bundle(target, osc_bundle) == -1) {
fprintf(stderr, "an OSC error occured: %s\n", lo_address_errstr(target));
}
}
if (verbose>1) {
if (tag_count==0) printf("no tag was found ...\n\n");
else if (tag_count==1) printf("1 tag was found ...\n\n");
else printf("%d tags were found ...\n\n",tag_count);
}
buffer_size = tag_count;
for (i=0; i<tag_count; i++) {
tag_buffer[i] = frame_buffer[i];
frame_buffer[i] = empty_tag;
}
for (int dev=0;dev<no_devices;dev++) {
if (pnd[dev] == NULL) continue;
if (nfc_device_set_property_bool(pnd[dev],NP_ACTIVATE_FIELD,false)<0) {
if (running) {
if (no_devices==1) printf("NFC reader disconnected ...\n");
else printf("NFC reader #%d disconnected ...\n",dev);
}
pnd[dev] = NULL;
device_count--;
if (device_count==0) {
running=false;
return;
}
} else {
nfc_device_set_property_bool(pnd[dev],NP_ACTIVATE_FIELD,true);
}
}
usleep(1000/no_devices);
}
}
int main()
{
lo_blob btest = lo_blob_new(sizeof(testdata), testdata);
lo_server_thread st, sta, stb;
lo_server s = lo_server_new(NULL, error);
lo_bundle b;
lo_message m1, m2;
char *server_url, *path, *protocol, *host, *port;
const char *host2, *port2;
lo_address a;
uint8_t midi_data[4] = {0xff, 0xf7, 0xAA, 0x00};
union end_test32 et32;
union end_test64 et64;
lo_timetag tt = {0x1, 0x80000000}, sched;
int count;
int proto;
char cmd[256];
test_deserialise();
sta = lo_server_thread_new("7591", error);
stb = lo_server_thread_new("7591", rep_error);
if (stb) {
fprintf(stderr, "FAILED: create bad server thread object!\n");
exit(1);
}
lo_server_thread_free(sta);
/* leak check */
st = lo_server_thread_new(NULL, error);
lo_server_thread_start(st);
#ifdef WIN32
Sleep(4);
#else
usleep(4000);
#endif
lo_server_thread_stop(st);
lo_server_thread_free(st);
st = lo_server_thread_new(NULL, error);
lo_server_thread_start(st);
lo_server_thread_stop(st);
lo_server_thread_free(st);
st = lo_server_thread_new(NULL, error);
lo_server_thread_free(st);
st = lo_server_thread_new(NULL, error);
lo_server_thread_free(st);
st = lo_server_thread_new(NULL, error);
a = lo_address_new_from_url("osc://localhost/");
TEST(a != NULL);
lo_address_free(a);
a = lo_address_new_from_url("osc.://localhost/");
TEST(a == NULL);
atexit(exitcheck);
printf("type tests\n");
TEST(sizeof(float) == sizeof(int32_t));
TEST(sizeof(double) == sizeof(int64_t));
et32.i = 0x23242526U;
et32.i = lo_htoo32(et32.i);
if (et32.c[0] != 0x23 || et32.c[1] != 0x24 || et32.c[2] != 0x25 ||
et32.c[3] != 0x26) {
fprintf(stderr, "failed 32bit endian conversion test\n");
fprintf(stderr, "0x23242526 -> %X\n", et32.i);
exit(1);
} else {
printf("passed 32bit endian conversion test\n");
}
et64.i = 0x232425262728292AULL;
et64.i = lo_htoo64(et64.i);
if (et64.c[0] != 0x23 || et64.c[1] != 0x24 || et64.c[2] != 0x25 ||
et64.c[3] != 0x26 || et64.c[4] != 0x27 || et64.c[5] != 0x28 ||
et64.c[6] != 0x29 || et64.c[7] != 0x2A) {
fprintf(stderr, "failed 64bit endian conversion\n");
fprintf(stderr, "0x232425262728292A -> %llX\n", (long long unsigned int)et64.i);
exit(1);
} else {
printf("passed 64bit endian conversion\n");
}
printf("\n");
/* OSC URL tests */
path = lo_url_get_path("osc.udp://localhost:9999/a/path/is/here");
if (strcmp(path, "/a/path/is/here")) {
printf("failed lo_url_get_path() test1\n");
printf("'%s' != '/a/path/is/here'\n", path);
exit(1);
} else {
printf("passed lo_url_get_path() test1\n");
}
free(path);
protocol = lo_url_get_protocol("osc.udp://localhost:9999/a/path/is/here");
if (strcmp(protocol, "udp")) {
printf("failed lo_url_get_protocol() test1\n");
printf("'%s' != 'udp'\n", protocol);
exit(1);
} else {
printf("passed lo_url_get_protocol() test1\n");
}
free(protocol);
protocol = lo_url_get_protocol("osc.tcp://localhost:9999/a/path/is/here");
if (strcmp(protocol, "tcp")) {
printf("failed lo_url_get_protocol() test2\n");
printf("'%s' != 'tcp'\n", protocol);
exit(1);
} else {
printf("passed lo_url_get_protocol() test2\n");
}
free(protocol);
protocol = lo_url_get_protocol("osc.udp://[::ffff:localhost]:9999/a/path/is/here");
if (strcmp(protocol, "udp")) {
printf("failed lo_url_get_protocol() test1 (IPv6)\n");
printf("'%s' != 'udp'\n", protocol);
exit(1);
} else {
printf("passed lo_url_get_protocol() test1 (IPv6)\n");
}
free(protocol);
proto = lo_url_get_protocol_id("osc.udp://localhost:9999/a/path/is/here");
if (proto != LO_UDP) {
printf("failed lo_url_get_protocol_id() test1\n");
printf("'%d' != LO_UDP\n", proto);
exit(1);
} else {
printf("passed lo_url_get_protocol_id() test1\n");
}
proto = lo_url_get_protocol_id("osc.tcp://localhost:9999/a/path/is/here");
if (proto != LO_TCP) {
printf("failed lo_url_get_protocol_id() test2\n");
printf("'%d' != LO_TCP\n", proto);
exit(1);
} else {
printf("passed lo_url_get_protocol_id() test2\n");
}
proto = lo_url_get_protocol_id("osc.invalid://localhost:9999/a/path/is/here");
if (proto != -1) {
printf("failed lo_url_get_protocol_id() test3\n");
printf("'%d' != -1\n", proto);
exit(1);
} else {
printf("passed lo_url_get_protocol_id() test3\n");
}
proto = lo_url_get_protocol_id("osc.udp://[::ffff:localhost]:9999/a/path/is/here");
if (proto != LO_UDP) {
printf("failed lo_url_get_protocol_id() test1 (IPv6)\n");
printf("'%d' != LO_UDP\n", proto);
exit(1);
} else {
printf("passed lo_url_get_protocol_id() test1 (IPv6)\n");
}
host = lo_url_get_hostname("osc.udp://foo.example.com:9999/a/path/is/here");
if (strcmp(host, "foo.example.com")) {
printf("failed lo_url_get_hostname() test1\n");
printf("'%s' != 'foo.example.com'\n", host);
exit(1);
} else {
printf("passed lo_url_get_hostname() test1\n");
}
free(host);
host = lo_url_get_hostname("osc.udp://[0000::::0001]:9999/a/path/is/here");
if (strcmp(host, "0000::::0001")) {
printf("failed lo_url_get_hostname() test2 (IPv6)\n");
printf("'%s' != '0000::::0001'\n", host);
exit(1);
} else {
printf("passed lo_url_get_hostname() test2 (IPv6)\n");
}
free(host);
port = lo_url_get_port("osc.udp://localhost:9999/a/path/is/here");
if (strcmp(port, "9999")) {
printf("failed lo_url_get_port() test1\n");
printf("'%s' != '9999'\n", port);
exit(1);
} else {
printf("passed lo_url_get_port() test1\n");
}
free(port);
port = lo_url_get_port("osc.udp://[::ffff:127.0.0.1]:9999/a/path/is/here");
if (strcmp(port, "9999")) {
printf("failed lo_url_get_port() test1 (IPv6)\n");
printf("'%s' != '9999'\n", port);
exit(1);
} else {
printf("passed lo_url_get_port() test1 (IPv6)\n");
}
free(port);
printf("\n");
a = lo_address_new_from_url("osc.tcp://foo.example.com:9999/");
host2 = lo_address_get_hostname(a);
if (strcmp(host2, "foo.example.com")) {
printf("failed lo_address_get_hostname() test\n");
printf("'%s' != 'foo.example.com'\n", host2);
exit(1);
} else {
printf("passed lo_address_get_hostname() test\n");
}
port2 = lo_address_get_port(a);
if (strcmp(port2, "9999")) {
printf("failed lo_address_get_port() test\n");
printf("'%s' != '9999'\n", port2);
exit(1);
} else {
printf("passed lo_address_get_port() test\n");
}
proto = lo_address_get_protocol(a);
if (proto != LO_TCP) {
printf("failed lo_address_get_protocol() test\n");
printf("'%d' != '%d'\n", proto, LO_TCP);
exit(1);
} else {
printf("passed lo_address_get_protocol() test\n");
}
server_url = lo_address_get_url(a);
if (strcmp(server_url, "osc.tcp://foo.example.com:9999/")) {
printf("failed lo_address_get_url() test\n");
printf("'%s' != '%s'\n", server_url, "osc.tcp://foo.example.com:9999/");
exit(1);
} else {
printf("passed lo_address_get_url() test\n");
}
free(server_url);
lo_address_free( a );
printf("\n");
/* Test blod sizes */
if (lo_blob_datasize(btest) != 5 || lo_blobsize(btest) != 12) {
printf("blob is %d (%d) bytes long, should be 5 (12)\n",
lo_blob_datasize(btest), lo_blobsize(btest));
lo_arg_pp(LO_BLOB, btest);
printf(" <- blob\n");
exit(1);
}
/* Server method handler tests */
server_url = lo_server_thread_get_url(st);
a = lo_address_new_from_url(server_url);
printf("Server URL: %s\n", server_url);
free(server_url);
/* add method that will match the path /foo/bar, with two numbers, coerced
* to float and int */
lo_server_thread_add_method(st, "/foo/bar", "fi", foo_handler, lo_server_thread_get_server(st));
lo_server_thread_add_method(st, "/reply", "s", reply_handler, NULL);
lo_server_thread_add_method(st, "/lotsofformats", "fisbmhtdSccTFNI",
lots_handler, NULL);
lo_server_thread_add_method(st, "/coerce", "dfhiSs",
coerce_handler, NULL);
lo_server_thread_add_method(st, "/bundle", NULL,
bundle_handler, NULL);
lo_server_thread_add_method(st, "/timestamp", NULL,
timestamp_handler, NULL);
lo_server_thread_add_method(st, "/jitter", "ti",
jitter_handler, NULL);
lo_server_thread_add_method(st, "/pattern/foo", NULL,
pattern_handler, "foo");
lo_server_thread_add_method(st, "/pattern/bar", NULL,
pattern_handler, "bar");
lo_server_thread_add_method(st, "/pattern/baz", NULL,
pattern_handler, "baz");
lo_server_thread_add_method(st, "/subtest", "i",
subtest_handler, st);
lo_server_thread_add_method(st, "/subtest-reply", "i",
subtest_reply_handler, NULL);
/* add method that will match any path and args */
lo_server_thread_add_method(st, NULL, NULL, generic_handler, NULL);
/* add method that will match the path /quit with no args */
lo_server_thread_add_method(st, "/quit", "", quit_handler, NULL);
/* check that the thread restarts */
lo_server_thread_start(st);
lo_server_thread_stop(st);
lo_server_thread_start(st);
if (lo_send(a, "/foo/bar", "ff", 0.12345678f, 23.0f) == -1) {
printf("OSC error A %d: %s\n", lo_address_errno(a), lo_address_errstr(a));
exit(1);
}
if (lo_send(a, "/foo/bar", "ff", 0.12345678f, 23.0f) == -1) {
printf("OSC error B %d: %s\n", lo_address_errno(a), lo_address_errstr(a));
exit(1);
}
test_validation(a);
test_multicast(st);
lo_send(a, "/", "i", 242);
lo_send(a, "/pattern/", "i", 243);
#ifndef _MSC_VER /* MS compiler refuses to compile this case */
lo_send(a, "/bar", "ff", 0.12345678f, 1.0/0.0);
#endif
lo_send(a, "/lotsofformats", "fisbmhtdSccTFNI", 0.12345678f, 123, "123",
btest, midi_data, 0x0123456789abcdefULL, tt, 0.9999, "sym",
'X', 'Y');
lo_send(a, "/coerce", "fdihsS", 0.1f, 0.2, 123, 124LL, "aaa", "bbb");
lo_send(a, "/coerce", "ffffss", 0.1f, 0.2f, 123.0, 124.0, "aaa", "bbb");
lo_send(a, "/coerce", "ddddSS", 0.1, 0.2, 123.0, 124.0, "aaa", "bbb");
lo_send(a, "/a/b/c/d", "sfsff", "one", 0.12345678f, "three",
-0.00000023001f, 1.0);
lo_send(a, "/a/b/c/d", "b", btest);
TEST(test_varargs(a, "/lotsofformats", "fisbmhtdSccTFNI", 0.12345678f, 123,
"123", btest, midi_data, 0x0123456789abcdefULL, tt,
0.9999, "sym", 'X', 'Y', LO_ARGS_END) == 0);
#ifdef __GNUC__
// Note: Lack of support for variable-argument macros in non-GCC compilers
// does not allow us to test for these conditions.
// too many args
TEST(test_varargs(a, "/lotsofformats", "f", 0.12345678f, 123,
"123", btest, midi_data, 0x0123456789abcdefULL, tt,
0.9999, "sym", 'X', 'Y', LO_ARGS_END) != 0);
// too many types
TEST(test_varargs(a, "/lotsofformats", "fisbmhtdSccTFNI", 0.12345678f, 123,
"123", btest, midi_data, 0x0123456789abcdefULL, tt, 0.5,
LO_ARGS_END) != 0);
#endif
// test lo_message_add
m1 = lo_message_new();
TEST(lo_message_add(m1, "fisbmhtdSccTFNI", 0.12345678f, 123, "123",
btest, midi_data, 0x0123456789abcdefULL, tt, 0.9999, "sym",
'X', 'Y') == 0);
lo_send_message(a, "/lotsofformats", m1);
lo_message_free(m1);
lo_blob_free(btest);
lo_send(a, "/pattern/*", "s", "a");
lo_send(a, "/pattern/ba[rz]", "s", "b");
server_url = lo_server_thread_get_url(st);
sprintf(cmd, "." PATHDELIM "subtest %s &", server_url);
if (system(cmd) != 0) {
fprintf(stderr, "Cannot execute subtest command\n");
exit(1);
}
system(cmd);
free(server_url);
#ifdef WIN32
Sleep(2000);
#else
sleep(2);
#endif
TEST(reply_count == 3);
TEST(pattern_count == 5);
TEST(subtest_count == 2);
TEST(subtest_reply_count == 22);
printf("\n");
{
lo_timetag t = {10,0xFFFFFFFC};
b = lo_bundle_new(t);
}
m1 = lo_message_new();
lo_message_add_string(m1, "abcdefghijklmnopqrstuvwxyz");
lo_message_add_string(m1, "ABCDEFGHIJKLMNOPQRSTUVWXYZ");
lo_bundle_add_message(b, "/bundle", m1);
lo_send_bundle(a, b);
/* This should be safe for multiple copies of the same message. */
lo_bundle_free_messages(b);
{
lo_timetag t = {1,2};
b = lo_bundle_new(t);
}
m1 = lo_message_new();
lo_message_add_int32(m1, 23);
lo_message_add_string(m1, "23");
lo_bundle_add_message(b, "/bundle", m1);
m2 = lo_message_new();
lo_message_add_string(m2, "24");
lo_message_add_int32(m2, 24);
lo_bundle_add_message(b, "/bundle", m2);
lo_bundle_add_message(b, "/bundle", m1);
/*
lo_send_bundle(a, b);
if (a->errnum) {
printf("error %d: %s\n", a->errnum, a->errstr);
exit(1);
}
*/
TEST(lo_send_bundle(a, b) == 88);
/* Test freeing out-of-order copies of messages in a bundle. */
lo_bundle_free_messages(b);
{
lo_timetag t = {10,0xFFFFFFFE};
b = lo_bundle_new(t);
}
m1 = lo_message_new();
lo_message_add_string(m1, "abcdefghijklmnopqrstuvwxyz");
lo_message_add_string(m1, "ABCDEFGHIJKLMNOPQRSTUVWXYZ");
lo_bundle_add_message(b, "/bundle", m1);
lo_send_bundle(a, b);
lo_message_free(m1);
lo_bundle_free(b);
lo_timetag_now(&sched);
sched.sec += 5;
b = lo_bundle_new(sched);
m1 = lo_message_new();
lo_message_add_string(m1, "future");
lo_message_add_string(m1, "time");
lo_message_add_string(m1, "test");
lo_bundle_add_message(b, "/bundle", m1);
lo_send_bundle(a, b);
lo_message_free(m1);
lo_bundle_free(b);
lo_send_timestamped(a, sched, "/bundle", "s", "lo_send_timestamped() test");
/* test bundle timestamp ends up in message struct (and doesn't end up in
unbundled messages) */
lo_timetag_now(&sched);
lo_send_timestamped(a, sched, "/timestamp", "it", 1, sched);
lo_send(a, "/timestamp", "it", 0, sched);
#define JITTER_ITS 25
/* jitter tests */
{
lo_timetag stamps[JITTER_ITS];
lo_timetag now;
int i;
for (i=0; i<JITTER_ITS; i++) {
lo_timetag_now(&now);
stamps[i] = now;
stamps[i].sec += 1;
stamps[i].frac = rand();
lo_send_timestamped(a, stamps[i], "/jitter", "ti", stamps[i], i);
}
}
#ifdef WIN32
Sleep(2000);
#else
sleep(2);
#endif
lo_address_free(a);
TEST(lo_server_thread_events_pending(st));
while (lo_server_thread_events_pending(st)) {
printf("pending events, wait...\n");
#ifdef WIN32
fflush(stdout);
Sleep(1000);
#else
sleep(1);
#endif
}
TEST(bundle_count == 7);
printf("\n");
printf("bundle timing jitter results:\n"
"max jitter = %fs\n"
"avg jitter = %fs\n"
"min jitter = %fs\n\n",
jitter_max, jitter_total/(float)jitter_count, jitter_min);
server_url = lo_server_get_url(s);
lo_server_add_method(s, NULL, NULL, generic_handler, NULL);
a = lo_address_new_from_url(server_url);
TEST(lo_server_recv_noblock(s, 0) == 0);
printf("Testing noblock API on %s\n", server_url);
lo_send(a, "/non-block-test", "f", 23.0);
count = 0;
while (!lo_server_recv_noblock(s, 10) && count++ < 1000) { }
if (count >= 1000) {
printf("lo_server_recv_noblock() test failed\n");
exit(1);
}
/* Delete methods */
lo_server_thread_del_method(st, "/coerce", "dfhiSs");
lo_server_del_method(s, NULL, NULL);
lo_address_free(a);
lo_server_free(s);
free(server_url);
#ifndef WIN32
{ /* UNIX domain tests */
lo_address ua;
lo_server us;
char *addr;
unlink("/tmp/testlo.osc");
us = lo_server_new_with_proto("/tmp/testlo.osc", LO_UNIX, error);
ua = lo_address_new_from_url("osc.unix:///tmp/testlo.osc");
TEST(lo_server_get_protocol(us) == LO_UNIX);
TEST(lo_send(ua, "/unix", "f", 23.0) == 16);
TEST(lo_server_recv(us) == 16);
addr = lo_server_get_url(us);
TEST(!strcmp("osc.unix:////tmp/testlo.osc", addr));
free(addr);
lo_address_free(ua);
ua = lo_address_new_with_proto(LO_UNIX, NULL, "/tmp/testlo.osc");
TEST(lo_send(ua, "/unix", "f", 23.0) == 16);
TEST(lo_server_recv(us) == 16);
lo_server_free(us);
lo_address_free(ua);
}
#endif
{ /* TCP tests */
lo_address ta;
lo_server ts;
char *addr;
ts = lo_server_new_with_proto(NULL, LO_TCP, error);
addr = lo_server_get_url(ts);
ta = lo_address_new_from_url(addr);
if (lo_address_errno(ta)) {
printf("err: %s\n", lo_address_errstr(ta));
exit(1);
}
TEST(lo_server_get_protocol(ts) == LO_TCP);
TEST(lo_send(ta, "/tcp", "f", 23.0) == 16);
TEST(lo_send(ta, "/tcp", "f", 23.0) == 16);
TEST(lo_server_recv(ts) == 16);
TEST(lo_server_recv(ts) == 16);
free(addr);
lo_server_free(ts);
lo_address_free(ta);
}
server_url = lo_server_thread_get_url(st);
a = lo_address_new_from_url(server_url);
/* exit */
lo_send(a, "/quit", NULL);
lo_address_free(a);
while (!done) {
#ifdef WIN32
Sleep(1);
#else
usleep(1000);
#endif
}
lo_server_thread_free(st);
free(server_url);
return 0;
}
void sendOSC() {
if (handMode) {
sendHandOSC();
return;
}
XnUserID aUsers[15];
XnUInt16 nUsers = 15;
userGenerator.GetUsers(aUsers, nUsers);
for (int i = 0; i < nUsers; ++i) {
if (userGenerator.GetSkeletonCap().IsTracking(aUsers[i])) {
lo_bundle bundle = lo_bundle_new(LO_TT_IMMEDIATE);
if (jointPos(aUsers[i], XN_SKEL_HEAD) == 0) {
oscFunc(&bundle, "head", 0);
}
if (jointPos(aUsers[i], XN_SKEL_NECK) == 0) {
oscFunc(&bundle, "neck", 1);
}
if (jointPos(aUsers[i], XN_SKEL_LEFT_COLLAR) == 0) {
oscFunc(&bundle, "l_collar", 2);
}
if (jointPos(aUsers[i], XN_SKEL_LEFT_SHOULDER) == 0) {
oscFunc(&bundle, "l_shoulder", 3);
}
if (jointPos(aUsers[i], XN_SKEL_LEFT_ELBOW) == 0) {
oscFunc(&bundle, "l_elbow", 4);
}
if (jointPos(aUsers[i], XN_SKEL_LEFT_WRIST) == 0) {
oscFunc(&bundle, "l_wrist", 5);
}
if (jointPos(aUsers[i], XN_SKEL_LEFT_HAND) == 0) {
oscFunc(&bundle, "l_hand", 6);
}
if (jointPos(aUsers[i], XN_SKEL_LEFT_FINGERTIP) == 0) {
oscFunc(&bundle, "l_fingertip", 7);
}
if (jointPos(aUsers[i], XN_SKEL_RIGHT_COLLAR) == 0) {
oscFunc(&bundle, "r_collar", 8);
}
if (jointPos(aUsers[i], XN_SKEL_RIGHT_SHOULDER) == 0) {
oscFunc(&bundle, "r_shoulder", 9);
}
if (jointPos(aUsers[i], XN_SKEL_RIGHT_ELBOW) == 0) {
oscFunc(&bundle, "r_elbow", 10);
}
if (jointPos(aUsers[i], XN_SKEL_RIGHT_WRIST) == 0) {
oscFunc(&bundle, "r_wrist", 11);
}
if (jointPos(aUsers[i], XN_SKEL_RIGHT_HAND) == 0) {
oscFunc(&bundle, "r_hand", 12);
}
if (jointPos(aUsers[i], XN_SKEL_RIGHT_FINGERTIP) == 0) {
oscFunc(&bundle, "r_fingertip", 13);
}
if (jointPos(aUsers[i], XN_SKEL_TORSO) == 0) {
oscFunc(&bundle, "torso", 14);
}
if (jointPos(aUsers[i], XN_SKEL_WAIST) == 0) {
oscFunc(&bundle, "waist", 15);
}
if (jointPos(aUsers[i], XN_SKEL_LEFT_HIP) == 0) {
oscFunc(&bundle, "l_hip", 16);
}
if (jointPos(aUsers[i], XN_SKEL_LEFT_KNEE) == 0) {
oscFunc(&bundle, "l_knee", 17);
}
if (jointPos(aUsers[i], XN_SKEL_LEFT_ANKLE) == 0) {
oscFunc(&bundle, "l_ankle", 18);
}
if (jointPos(aUsers[i], XN_SKEL_LEFT_FOOT) == 0) {
oscFunc(&bundle, "l_foot", 19);
}
if (jointPos(aUsers[i], XN_SKEL_RIGHT_HIP) == 0) {
oscFunc(&bundle, "r_hip", 20);
}
if (jointPos(aUsers[i], XN_SKEL_RIGHT_KNEE) == 0) {
oscFunc(&bundle, "r_knee", 21);
}
if (jointPos(aUsers[i], XN_SKEL_RIGHT_ANKLE) == 0) {
oscFunc(&bundle, "r_ankle", 22);
}
if (jointPos(aUsers[i], XN_SKEL_RIGHT_FOOT) == 0) {
oscFunc(&bundle, "r_foot", 23);
}
if (lo_send_bundle(addr, bundle) != 0) {
printf("error: unable to send bundle\n");
lo_bundle_pp(bundle);
}
lo_bundle_free_messages(bundle);
}
else {
//Send user's center of mass
sendUserPosMsg(aUsers[i]);
}
}
}
void* Pure_lo_bundle_new(lo_timetag* arg0)
{
return lo_bundle_new(*arg0);
}
int main()
{
//clean buffer
memset(buffer1, 0xc3, sizeof(buffer1));
//generate liblo message 1
size_t len = 128;
lo_message message = lo_message_new();
assert_non_null(message, "Generating A Liblo Message 1 (int/float)", __LINE__);
lo_message_add_float(message, 24.0);
lo_message_add_int32(message, 42);
lo_message_serialise(message, "/path", buffer1, &len);
assert_str_eq("/path", buffer1, "Verifying Path From Message 1", __LINE__);
assert_f32_eq(24.0f, rtosc_argument(buffer1, 0).f,
"Verifying Float From Message 1", __LINE__);
assert_int_eq(42, rtosc_argument(buffer1, 1).i,
"Verifying Int From Message 1", __LINE__);
assert_int_eq(20, rtosc_message_length(buffer1, 128),
"Verifying Length From Message 1", __LINE__);
//Message 2
size_t len2 = rtosc_message(buffer2, 1024, "/li", "bb", 4, buffer1, 4, buffer1);
assert_int_eq(24, len2, "Generate A Rtosc Message 2 (bb)", __LINE__);
lo_message msg2 = lo_message_deserialise((void*)buffer2, len2, &result_var);
if(assert_non_null(msg2, "Deserialize Message 2 To Liblo", __LINE__))
printf("# Liblo Did Not Accept the Rtosc Message [error '%d']\n", result_var);
//Message 3
size_t len3 = rtosc_message(buffer3+4, 2048, "/close-ui", "");
assert_int_eq(16, len3, "Generate A Rtosc Message 3 ()", __LINE__);
lo_message msg3 = lo_message_deserialise((void*)(buffer3+4), len3, &result_var);
if(assert_non_null(msg2, "Deserialize Message 3 To Liblo", __LINE__))
printf("#Liblo Did Not Accept the Rtosc Message [error '%d']\n", result_var);
//Bundle 4
size_t len4 = rtosc_bundle(buffer4, 2048, 0xdeadbeefcafebaad, 3, buffer1, buffer2, buffer3+4);
assert_int_eq(88, len4, "Generate A Bundle 4", __LINE__);
//Bundle 5
lo_timetag time;
time.sec = 0xdeadbeef;
time.frac = 0xcafebaad;
lo_bundle ms4 = lo_bundle_new(time);
lo_bundle_add_message(ms4, "/path", message);
lo_bundle_add_message(ms4, "/li", msg2);
lo_bundle_add_message(ms4, "/close-ui", msg3);
size_t len5 = 2048;
lo_bundle_serialise(ms4,(void*)buffer5, &len5);
//Verify 4 == 5
assert_non_null(ms4, "Generate A Liblo Bundle 5", __LINE__);
assert_hex_eq(buffer5, buffer4, len5, len4,
"Verify Liblo Style Bundles", __LINE__);
//Cleanup
lo_message_free(message);
lo_message_free(msg2);
lo_message_free(msg3);
lo_bundle_free(ms4);
return test_summary();
}
void mapper_receiver_send_update(mapper_receiver r,
mapper_signal sig,
mapper_signal_instance si,
mapper_timetag_t tt)
{
// find the signal connection
mapper_receiver_signal rc = r->signals;
while (rc) {
if (rc->signal == sig)
break;
rc = rc->next;
}
if (!rc)
return;
lo_bundle b = lo_bundle_new(tt);
mapper_connection c = rc->connections;
while (c) {
if (c->props.mode != MO_REVERSE) {
c = c->next;
continue;
}
if (!sig->active_instances) {
// If there are no active instances, send null response
lo_message m = lo_message_new();
if (!m)
return;
lo_message_add_nil(m);
lo_bundle_add_message(b, c->props.query_name, m);
}
else if (sig->props.num_instances == 1) {
lo_message m = lo_message_new();
if (!m)
return;
message_add_coerced_signal_value(m, sig, sig->active_instances,
c->props.src_type);
lo_bundle_add_message(b, c->props.query_name, m);
}
else if (si) {
lo_message m = lo_message_new();
if (!m)
return;
lo_message_add_int32(m, si->id_map->group);
lo_message_add_int32(m, si->id_map->remote);
if (si->has_value)
message_add_coerced_signal_value(m, sig, si, c->props.src_type);
else
lo_message_add_nil(m);
lo_bundle_add_message(b, c->props.query_name, m);
}
else {
// TODO: need to make one->many instance mapping a connection property
si = sig->active_instances;
while (si) {
lo_message m = lo_message_new();
if (!m)
return;
lo_message_add_int32(m, si->id_map->group);
lo_message_add_int32(m, si->id_map->remote);
if (si->has_value)
message_add_coerced_signal_value(m, sig, si, c->props.src_type);
else
lo_message_add_nil(m);
lo_bundle_add_message(b, c->props.query_name, m);
si = si->next;
}
}
c = c->next;
}
lo_send_bundle(r->props.src_addr, b);
lo_bundle_free_messages(b);
}
void moNetOSCOut::SendDataMessage( int i, moDataMessage &datamessage ) {
#ifdef OSCPACK
if (packetStream==NULL) {
cout << "moNetOSCOut::SendDataMessage > error: packetStream is NULL" << endl;
return;
}
#endif
//cout << "moNetOSCOut::SendDataMessage > start" << endl;
#ifdef OSCPACK
packetStream->Clear();
//cout << "moNetOSCOut::SendDataMessage > Clear() ok." << endl;
(*packetStream) << osc::BeginBundleImmediate;
//cout << "moNetOSCOut::SendDataMessage > BeginBundleImmediate ok." << endl;
(*packetStream) << osc::BeginMessage( moText("")+ IntToStr(datamessage.Count()) );
//cout << "moNetOSCOut::SendDataMessage > data in messages:" << datamessage.Count() << endl;
#else
lo_timetag timetag;
lo_timetag_now(&timetag);
lo_bundle bundle = lo_bundle_new(timetag);
lo_message ms = lo_message_new();
moText oscpath = "";
#endif
moData data;
int nfields = 0;
int error = 0;
try {
for(int j=0; j< datamessage.Count(); j++) {
data = datamessage[j];
if (debug_is_on) MODebug2->Message( moText("moNetOSCOut::SendDataMessage "+GetLabelName()+" > data:") + IntToStr(j) );
switch(data.Type()) {
#ifdef OSCPACK
case MO_DATA_NUMBER_FLOAT:
(*packetStream) << data.Float();
break;
case MO_DATA_NUMBER_INT:
(*packetStream) << data.Int();
break;
case MO_DATA_NUMBER_LONG:
(*packetStream) << data.Long();
break;
case MO_DATA_NUMBER_DOUBLE:
(*packetStream) << data.Double();
break;
case MO_DATA_TEXT:
(*packetStream) << (char*)data.Text();
break;
#else
case MO_DATA_NUMBER_FLOAT:
error = lo_message_add_float( ms , data.Float());
nfields++;
break;
case MO_DATA_NUMBER_INT:
error = lo_message_add_int32( ms , data.Int());
nfields++;
break;
case MO_DATA_NUMBER_LONG:
error = lo_message_add_int64( ms , data.Long());
nfields++;
break;
case MO_DATA_NUMBER_DOUBLE:
error = lo_message_add_double( ms , data.Double());
nfields++;
break;
case MO_DATA_TEXT:
if (oscpath=="") {
oscpath = data.Text();
moText mot = data.Text().Left(50000);
error = lo_message_add_string( ms , (char*)mot);
nfields++;
} else {
moText mot = data.Text().Left(50000);
error = lo_message_add_string( ms , (char*)mot);
nfields++;
}
break;
#endif
}
if (error<0)
MODebug2->Error(moText("moNetOSCOut > data error adding value: ") + data.ToText() );
}
#ifdef OSCPACK
} catch(osc::Exception E) {
MODebug2->Error( moText("moNetOSCOut > Exception: ") + E.what()
+ " packet actual size: (" + IntToStr( (*packetStream).Size() ) + ") "
+ " Data too long for buffer: (max OUTPUT_BUFFER_SIZE:" + IntToStr(OUTPUT_BUFFER_SIZE) + ") "
+ data.ToText()
+ " (size:"+ IntToStr(data.ToText().Length())+" )"
+ " (total size:" + IntToStr( data.ToText().Length() + (*packetStream).Size() ) + ")" );
}
(*packetStream) << osc::EndMessage;
//cout << "moNetOSCOut::SendDataMessage > osc::EndMessage ok" << endl;
//cout << "osc::EndBundle: " << endl;
//cout << osc::EndBundle << endl;
#ifdef MO_WIN32
(*packetStream) << osc::EndBundle;
#endif
//cout << "moNetOSCOut::SendDataMessage > osc::EndBundle ok" << endl;
//cout << "moNetOSCOut::SendDataMessage > sending." << endl;
if (transmitSockets[i]) {
//MODebug2->Message(moText("moNetOSCOut > sending ") + IntToStr(i) + " size:" + IntToStr(packetStream->Size()) );
transmitSockets[i]->Send( packetStream->Data(), packetStream->Size() );
}
#else
} catch(...) {