Exemplo n.º 1
0
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 );

}
Exemplo n.º 2
0
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;
}
Exemplo n.º 3
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 );
}
Exemplo n.º 4
0
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;
}
Exemplo n.º 5
0
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 );

}
Exemplo n.º 6
0
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;
}
Exemplo n.º 7
0
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;
}
Exemplo n.º 8
0
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 );
}
Exemplo n.º 9
0
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;
}
Exemplo n.º 10
0
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 );
}
Exemplo n.º 11
0
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;
}
Exemplo n.º 12
0
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);
}
Exemplo n.º 13
0
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;
}
Exemplo n.º 14
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);
}
Exemplo n.º 15
0
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 );
}
Exemplo n.º 16
0
// 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);
    }
}
Exemplo n.º 17
0
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);
    }
}
Exemplo n.º 18
0
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;
}
Exemplo n.º 19
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]);
		}
	}
}
Exemplo n.º 20
0
void* Pure_lo_bundle_new(lo_timetag* arg0)
{
  return lo_bundle_new(*arg0);
}
Exemplo n.º 21
0
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();
}
Exemplo n.º 22
0
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);
}
Exemplo n.º 23
0
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(...) {