int osc_send( const char *port, const char *msg, const char *format, ...) { lo_address t = lo_address_new(NULL, port); lo_message message = lo_message_new(); va_list args; va_start( args, format); while( *format != '\0') { switch( *format) { case 's': lo_message_add_string( message, va_arg( args, const char *)); break; case 'i': lo_message_add_int32( message, va_arg( args, int)); break; case 'f': lo_message_add_float( message, va_arg( args, double)); break; } ++format; } va_end( args); if( !lo_send_message( t, msg, message)) { printf("OSC error %d: %s\n", lo_address_errno(t), lo_address_errstr(t)); } if( osc_log) osc_log_print( msg, message); lo_message_free( message); lo_address_free( t); return 0; }
int osc_send_track_load(struct deck *de) { struct player *pl; struct track *tr; pl = &de->player; tr = pl->track; if(tr) { /* send a message to /xwax/track_load with two arguments, report any * errors */ int c; for(c = 0; c < osc_nclient%3; ++c) { if (lo_send(address[c], "/xwax/track_load", "iissi", de->ncontrol, (int) tr, de->record->artist, de->record->title, tr->rate ) == -1) { printf("OSC error %d: %s\n", lo_address_errno(address[c]), lo_address_errstr(address[c])); } printf("osc_send_track_load: sent track_load to %s\n", lo_address_get_url(address[c])); sleep(1); // Wierd bug in liblo that makes second track load not catched by client's track_load_handler if sent too fast } } return 0; }
int osc_send_status(lo_address a, int d) { struct deck *de; struct player *pl; struct track *tr; de = &osc_deck[d]; pl = &de->player; tr = pl->track; char *path; if(tr->path) path = tr->path; else path = ""; if(tr) { /* send a message to /xwax/status */ if (lo_send(a, "/xwax/status", "isssfffi", de->ncontrol, // deck number (int) path, // track path (string) de->record->artist, // artist name (string) de->record->title, // track title (string) (float) tr->length / (float) tr->rate, // track length in seconds (float) player_get_elapsed(pl), // player position in seconds (float) pl->pitch, // player pitch (float) pl->timecode_control) // timecode activated or not (int) == -1) { printf("OSC error %d: %s\n", lo_address_errno(a), lo_address_errstr(a)); } printf("osc_send_status: sent deck %i status to %s\n", d, lo_address_get_url(a)); } return 0; }
int main(int argc, char *argv[]) { /* build a blob object from some data */ lo_blob btest = lo_blob_new(sizeof(testdata), testdata); /* an address to send messages to. sometimes it is better to let the server * pick a port number for you by passing NULL as the last argument */ lo_address t = lo_address_new(NULL, "7770"); if (argc > 1 && argv[1][0] == '-' && argv[1][1] == 'q') { /* send a message with no arguments to the path /quit */ lo_send(t, "/quit", NULL); } else { /* send a message to /foo/bar with two float arguments, report any * errors */ if (lo_send(t, "/foo/bar", "ff", 0.12345678f, 23.0f) == -1) { printf("OSC error %d: %s\n", lo_address_errno(t), lo_address_errstr(t)); } /* send a message to /a/b/c/d with a mixtrure of float and string * arguments */ lo_send(t, "/a/b/c/d", "sfsff", "one", 0.12345678f, "three", -0.00000023001f, 1.0); /* send a 'blob' object to /a/b/c/d */ lo_send(t, "/a/b/c/d", "b", btest); /* send a jamin scene change instruction with a 32bit integer argument */ lo_send(t, "/jamin/scene", "i", 2); } return 0; }
SLBus::~SLBus() { if ( lo_send( sl_target_, "/quit", "" ) == -1 ) { spdlog::get( "main" )->error( "OSC error {}: {}", lo_address_errno(sl_target_), lo_address_errstr(sl_target_) ); } while (clipset_.size()) clipset_.pop_back(); }
void unreg_cb(int loop, const char* monitor, const char* cb_addr) { char addr[29]; if (loop == -2) sprintf(addr, "/unregister_auto_update"); else sprintf(addr, "/sl/%d/unregister_auto_update", loop); if (lo_send(sl, addr, "siss", monitor, 200, osc_host, cb_addr) == -1) { printf("OSC error %d: %s\n", lo_address_errno(sl), lo_address_errstr(sl)); } }
int osc_send_quit( const char *port) { lo_address t = lo_address_new(NULL, port); if( !lo_send( t, "/quit" , "")) { printf("OSC error %d: %s\n", lo_address_errno(t), lo_address_errstr(t)); } return 0; }
int osc_send_vector( const char *port, const char *msg) { lo_address t = lo_address_new(NULL, port); if( !lo_send( t, "/a/b/c" , "fff" , 10.0f, 10.0f, 10.0f)) { printf("OSC error %d: %s\n", lo_address_errno(t), lo_address_errstr(t)); } return 0; }
int subtest_handler(const char *path, const char *types, lo_arg **argv, int argc, lo_message data, void *user_data) { int i; lo_address a = lo_message_get_source(data); static char *uri = NULL; printf("subtest: got reply (%s)\n", path); if (!uri) { uri = lo_address_get_url(a); } else { char *new_uri = lo_address_get_url(a); if (strcmp(uri, new_uri)) { printf("ERROR: %s != %s\n", uri, new_uri); exit(1); } free(new_uri); } lo_send(a, "/subtest-reply", "i", 0xbaa); if (lo_address_errno(a)) { fprintf(stderr, "subtest error %d: %s\n", lo_address_errno(a), lo_address_errstr(a)); exit(1); } for (i=0; i<10; i++) { #ifdef WIN32 /* TODO: Wait time of 2.233 not easily doable in Windows */ Sleep(2); #else usleep(2233); #endif lo_send(a, "/subtest-reply", "i", 0xbaa+i); } return 0; }
int osc_send_position(int d, const float position) { lo_address t = lo_address_new(ADDRESS, "7770"); if (lo_send(t, "/xwax/position", "if", d, position) == -1) { #ifdef __ANDROID__ __android_log_print(ANDROID_LOG_DEBUG, "osc.c", "OSC error %d: %s\n", lo_address_errno(t), lo_address_errstr(t)); #endif } return 1; }
void get_control(int loop, const char* control, const char* cb_addr) { char addr[27]; if (loop < -5) { printf("get_control invalid loop %d\n", loop); } else { sprintf(addr, "/sl/%d/get", loop); if (lo_send(sl, addr, "sss", control, osc_host, cb_addr) == -1) { printf("OSC error %d: %s\n", lo_address_errno(sl), lo_address_errstr(sl)); } } }
int osc_send_scale(int scale) { /* send a message to /xwax/track_load with two arguments, report any * errors */ int c; for(c = 0; c < osc_nclient%3; ++c) { if (lo_send(address[c], "/xwax/scale", "i", scale) == -1) { printf("OSC error %d: %s\n", lo_address_errno(address[c]), lo_address_errstr(address[c])); } } return 0; }
static int send_msg(lo_address a, char *path, term_t args) { lo_message msg=lo_message_new(); if (add_msg_args(msg,args)) { if (lo_send_message(a,path,msg)==-1) { lo_message_free(msg); return osc_error(lo_address_errno(a),lo_address_errstr(a),path); } else { lo_message_free(msg); return TRUE; } } else return FALSE; }
int main(int argc, char *argv[]) { lo_address t = lo_address_new(NULL, "7770"); sleep(5); smallIncr = (TWOPI)/360.0; for (theta = TWOPI ; theta >= 0.0 ; theta = theta-smallIncr) { int jsVal = (int) round(sin(theta)*32767.0) ; if (lo_send(t, path, types, jsNum , jsAxis , jsVal) == -1) { printf("OSC error %d: %s\n", lo_address_errno(t), lo_address_errstr(t)); } usleep(40000); printf("path=%s , types=%s argslist = %d %d %d\n",path , types , jsNum , jsAxis , jsVal) ; } }
int main(int argc, char *argv[]) { /* an address to send messages to. sometimes it is better to let the server * pick a port number for you by passing NULL as the last argument */ lo_address t = lo_address_new(NULL, "7770"); char mode = 't'; float x = 0.0; float delta = 0.1; int n = 0; /* slider number */ if (argc == 2) { mode = argv[1][0]; if (mode == '?' || mode == 'h' || (mode != 'i' && mode != 't')) { printf("usage: test-client [?hti]\n"); printf(" default (t) is triangle, (i)nteractive sends msg after each return\n"); exit(1); } } printf("lo_address_new done\n"); /* send messages to /slider with two arguments, report any * errors */ while (1) { if (lo_send(t, "/slider", "if", n, x) == -1) { printf("OSC error %d: %s\n", lo_address_errno(t), lo_address_errstr(t)); break; } else { printf("/slider %d %g\n", n, x); } x = x + delta; if (x > 1.0 - delta * 0.5) { x = 1.0; delta = -delta; } else if (x < -delta * 0.5) { x = 0.0; delta = -delta; } if (mode == 'i') { while (getchar() != '\n') ; } else { usleep(100000); } } printf("done calling lo_send\n"); return 0; }
void SLClip::send2SL(const char* pathend, lo_message msg) { auto mainlog = spdlog::get( "main" ); mainlog->info( "SLClip::send2SL"); lo_message_pp( msg ); lo_address target = ((SLBus*)parent_)->getSLTarget(); mainlog->info( "* address : {}", target); std::string path = "/sl/" + std::to_string( sl_id_ ) + pathend; mainlog->info( "* path : {}", path); if ( lo_send_message( target, path.c_str(), msg ) == -1 ) { mainlog->error( "OSC error {}: {}", lo_address_errno(target), lo_address_errstr(target) ); } mainlog->info( "/SLClip::send2SL"); }
int osc_send_pos(int d, const float pos, const float pitch) { //lo_address t = lo_address_new(NULL, "7771"); //lo_address t = lo_address_new(address, "7771"); /* send a message to /xwax/position with one float argument, report any * errors */ int c; for(c = 0; c < osc_nclient%3; ++c) { if (lo_send(address[c], "/xwax/position", "iff", d, pos, pitch) == -1) { printf("OSC error %d: %s\n", lo_address_errno(address[c]), lo_address_errstr(address[c])); } } return 0; }
void test_multicast(lo_server_thread st) { /* test multicast server and sender */ /* message is sent from st otherwise reply doesn't work */ lo_server ms = lo_server_new_multicast("224.0.1.1", "15432", error); lo_address ma = lo_address_new("224.0.1.1", "15432"); lo_address_set_ttl(ma, 1); lo_server_add_method(ms, "/foo/bar", "fi", foo_handler, ms); lo_server_add_method(ms, "/reply", "s", reply_handler, NULL); if (lo_send_from(ma, lo_server_thread_get_server(st), LO_TT_IMMEDIATE, "/foo/bar", "ff", 0.12345678f, 23.0f) == -1) { printf("multicast send error %d: %s\n", lo_address_errno(ma), lo_address_errstr(ma)); exit(1); } TEST(lo_server_recv(ms)==24); lo_server_free(ms); lo_address_free(ma); }
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; }
int foo_handler(const char *path, const char *types, lo_arg **argv, int argc, lo_message data, void *user_data) { lo_server serv = (lo_server)user_data; lo_address src = lo_message_get_source(data); char *url = lo_address_get_url(src); char *server_url = lo_server_get_url(serv); printf("Address of us: %s\n", server_url); printf("%s <- f:%f, i:%d\n", path, argv[0]->f, argv[1]->i); if (lo_send_from(src, serv, LO_TT_IMMEDIATE, "/reply", "s", "a reply") == -1) { printf("OSC reply error %d: %s\nSending to %s\n", lo_address_errno(src), lo_address_errstr(src), url); exit(1); } else { printf("Reply sent to %s\n\n", url); } free(server_url); free(url); return 0; }
void SLBus::addClip( std::shared_ptr<SLClip> clip ) { stk::FileWvIn f( clip->getURI() ); float duration = f.getSize() / f.getFileRate(); if ( lo_send( sl_target_, "/loop_add", "if", f.channelsOut(), duration ) == -1 ) { spdlog::get( "main" )->error( "OSC error {}: {}", lo_address_errno(sl_target_), lo_address_errstr(sl_target_) ); } else { clip->setParent( this ); clip->setSLid( clipset_.size() ); clip->SLget( "state" ); sleep(1); clip->SLget( "state" ); clip->SLload(); clipset_.push_back( clip ); Waiter::getInstance()->selectClip( clip ); } }
int main(int argc, char *argv[]) { lo_address ad; if (argc > 1) { printf("Connecting to %s\n", argv[1]); ad = lo_address_new_from_url(argv[1]); } else { printf("Connecting to %s\n", MONOHORN_URL); ad = lo_address_new_from_url(MONOHORN_URL); } if (lo_address_errno(ad) < 0) { fprintf(stderr, "LO Error: %s\n", lo_address_errstr(ad)); return 1; } int ret = 0; while (1) { rb_raise(); rb_bottom(); rb_render(ad); if (lo_send(ad, "/render", NULL) < 0) { fprintf(stderr, "LO Error: %s\n", lo_address_errstr(ad)); ret = 1; break; } // 15 frames /sec usleep(1000000 / 15); } lo_send(ad, "/clear", NULL); return ret; }
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; }
int osc_send_ppm_block(struct track *tr) { if(tr) { int c; for(c = 0; c < osc_nclient%3; ++c) { int i = 0; while(i < tr->length) { int j = 0; unsigned char ppm_block[24575]; while(j < 24575 && i < tr->length) { ppm_block[j] = track_get_ppm(tr, i); ++j; i += 64; } /* build a blob object from some data */ lo_blob blob = lo_blob_new(j, &ppm_block); //lo_server server = lo_server_thread_get_server(st_tcp); if (lo_send(address[c], "/xwax/ppm", "ibi", (int) tr, blob, tr->length ) == -1) { printf("OSC error %d: %s\n", lo_address_errno(address[c]), lo_address_errstr(address[c])); } lo_blob_free(blob); } lo_send(address[c], "/xwax/ppm_end", "i", (int) tr); printf("Sent %p blocks to %s\n", tr, lo_address_get_url(address[c])); sleep(1); // Wierd bug in liblo that makes second track load not catched by client's track_load_handler if sent too fast } } return 0; }
int osc_send_ints( const char *port, const char *msg, int count, int *val) { lo_address t = lo_address_new(NULL, port); lo_message message = lo_message_new(); int i; for( i = 0; i < count; i++) { lo_message_add_int32( message, val[i]); } if( !lo_send_message( t, msg, message)) { printf("OSC error %d: %s\n", lo_address_errno(t), lo_address_errstr(t)); } if( osc_log) osc_log_print( msg, message); lo_message_free( message); lo_address_free( t); return 0; }
/* catch any osc incoming messages. */ int OscCtrlServer::osc_handler(const char *path, const char *types, lo_arg ** argv, int argc, void * /*data */ , void *user_data) { OscCtrlServer *context = static_cast<OscCtrlServer *>(user_data); std::shared_ptr<QuiddityManager> manager = context->get_quiddity_manager(); if (!(bool) manager) { g_warning("OscCtrlServer: cannot get quiddity manager"); return 0; } // create if (g_str_has_prefix(path, "/c") || g_str_has_prefix(path, "/C")) { if (argc == 1) { gchar *class_name = string_from_osc_arg(types[0], argv[0]); manager->create(class_name); g_free(class_name); } else if (argc == 2) { gchar *class_name = string_from_osc_arg(types[0], argv[0]); gchar *quid_name = string_from_osc_arg(types[1], argv[1]); manager->create(class_name, quid_name); g_free(class_name); g_free(quid_name); } else g_warning("OSCctl: wrong arg number for create"); return 0; } // remove if (g_str_has_prefix(path, "/r") || g_str_has_prefix(path, "/R")) { if (argc == 1) { gchar *quid_name = string_from_osc_arg(types[0], argv[0]); manager->remove(quid_name); g_free(quid_name); } else g_warning("OSCctl: wrong arg number for remove"); return 0; } // set_property if (g_str_has_prefix(path, "/s") || g_str_has_prefix(path, "/S")) { if (argc == 3) { gchar *quid_name = string_from_osc_arg(types[0], argv[0]); gchar *prop_name = string_from_osc_arg(types[1], argv[1]); gchar *value = string_from_osc_arg(types[2], argv[2]); manager->set_property(quid_name, prop_name, value); g_free(quid_name); g_free(prop_name); g_free(value); } else g_warning("OSCctl: wrong arg number for set_property"); return 0; } // invoke if (g_str_has_prefix(path, "/i") || g_str_has_prefix(path, "/I")) { if (argc >= 2) { gchar *quid_name = string_from_osc_arg(types[0], argv[0]); gchar *method_name = string_from_osc_arg(types[1], argv[1]); int i; std::vector<std::string> args; for (i = 2; i < argc; i++) { gchar *val = string_from_osc_arg(types[i], argv[i]); args.push_back(val); g_free(val); } manager->invoke(quid_name, method_name, nullptr, args); g_free(quid_name); g_free(method_name); } else g_warning("OSCctl: wrong arg number for invoke"); return 0; } // add an osc subscriber if (g_str_has_prefix(path, "/a") || g_str_has_prefix(path, "/A")) { if (argc == 3) { gchar *subscriber_name = string_from_osc_arg(types[0], argv[0]); gchar *host = string_from_osc_arg(types[1], argv[1]); gchar *port = string_from_osc_arg(types[2], argv[2]); gchar *port_int = string_float_to_string_int(port); gchar *internal_subscriber_name = context->make_internal_subscriber_name(subscriber_name); if (context->osc_subscribers_.end() == context->osc_subscribers_.find(internal_subscriber_name)) { g_warning ("OscCtrlServer: a subscriber named %s is already registered", subscriber_name); return 0; } if (host == nullptr || port_int == nullptr) { g_warning("OscCtrlServer: issue with host name or port"); return 0; } context->osc_subscribers_[internal_subscriber_name] = std::make_pair(host, port_int); if (!manager->make_property_subscriber(internal_subscriber_name, OscCtrlServer::prop_cb, context)) return 0; g_debug("subscriber %s, %s, %s", subscriber_name, host, port_int); g_free(internal_subscriber_name); g_free(subscriber_name); g_free(host); g_free(port); g_free(port_int); } else g_warning("OSCctl: add subscriber needs 3 args (name, host, port)"); return 0; } // delete an osc subscriber if (g_str_has_prefix(path, "/d") || g_str_has_prefix(path, "/D")) { if (argc == 1) { gchar *subscriber_name = string_from_osc_arg(types[0], argv[0]); gchar *internal_subscriber_name = context->make_internal_subscriber_name(subscriber_name); auto it = context->osc_subscribers_.find(internal_subscriber_name); if (context->osc_subscribers_.end() == it) { g_warning ("OscCtrlServer: cannot delete non existing subscriber named %s", subscriber_name); return 0; } manager->remove_property_subscriber(internal_subscriber_name); context->osc_subscribers_.erase(it); g_free(internal_subscriber_name); g_free(subscriber_name); } else g_warning("OSCctl: delete subscriber needs 1 args (name)"); return 0; } // subscribe to a property if (g_strcmp0(path, "/get") == 0) { if (argc == 3) { gchar *quiddity_name = string_from_osc_arg(types[0], argv[0]); gchar *property_name = string_from_osc_arg(types[1], argv[1]); gchar *response_url = string_from_osc_arg(types[2], argv[2]); if (quiddity_name == nullptr || property_name == nullptr || response_url == nullptr) { g_warning ("OscCtrlServer: issue with quiddity name or property name or response url"); return 0; } std::string value = manager->get_property(quiddity_name, property_name); lo_address response_lo_address = lo_address_new_from_url(response_url); if (response_lo_address != nullptr && !lo_address_errno(response_lo_address)) { gchar *message = g_strdup_printf("/%s/%s", quiddity_name, property_name); lo_send(response_lo_address, message, "s", value.c_str()); lo_address_free(response_lo_address); g_free(message); } else g_debug("url osc error in get"); g_free(quiddity_name); g_free(property_name); g_free(response_url); } else g_warning ("OSCctl: subscribe property needs 3 args (name, quiddity, property)"); return 0; } // subscribe to a property if (g_str_has_prefix(path, "/get_property_") || g_str_has_prefix(path, "/G")) { if (argc == 3) { gchar *subscriber_name = string_from_osc_arg(types[0], argv[0]); gchar *quiddity_name = string_from_osc_arg(types[1], argv[1]); gchar *property_name = string_from_osc_arg(types[2], argv[2]); gchar *internal_subscriber_name = context->make_internal_subscriber_name(subscriber_name); if (context->osc_subscribers_.end() == context->osc_subscribers_.find(internal_subscriber_name)) { g_warning ("OscCtrlServer: a subscriber named %s does not exist", subscriber_name); return 0; } if (quiddity_name == nullptr || property_name == nullptr) { g_warning ("OscCtrlServer: issue with quiddity name or property name"); return 0; } if (!manager->subscribe_property(internal_subscriber_name, quiddity_name, property_name)) g_warning("OscCtrlServer: pb subscribing to %s, %s", quiddity_name, property_name); g_free(internal_subscriber_name); g_free(subscriber_name); g_free(quiddity_name); g_free(property_name); } else g_warning ("OSCctl: subscribe property needs 3 args (name, quiddity, property)"); return 0; } // unsubscribe to a property if (g_str_has_prefix(path, "/u") || g_str_has_prefix(path, "/U")) { if (argc == 3) { gchar *subscriber_name = string_from_osc_arg(types[0], argv[0]); gchar *quiddity_name = string_from_osc_arg(types[1], argv[1]); gchar *property_name = string_from_osc_arg(types[2], argv[2]); gchar *internal_subscriber_name = context->make_internal_subscriber_name(subscriber_name); if (context->osc_subscribers_.end() == context->osc_subscribers_.find(internal_subscriber_name)) { g_warning ("OscCtrlServer: a subscriber named %s does not exist", subscriber_name); return 0; } if (quiddity_name == nullptr || property_name == nullptr) { g_warning ("OscCtrlServer: issue with quiddity name or property name"); return 0; } if (!manager->unsubscribe_property(internal_subscriber_name, quiddity_name, property_name)) g_warning("OscCtrlServer: pb unsubscribing to %s, %s", quiddity_name, property_name); g_free(internal_subscriber_name); g_free(subscriber_name); g_free(quiddity_name); g_free(property_name); } else g_warning ("OSCctl: unsubscribe property needs 3 args (name, quiddity, property)"); return 0; } g_debug("unknown osc path %s", path); return 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; }
void printPacketInfo(const MIDIPacket* packet) { double timeinsec = packet->timeStamp / (double)1e9; // printf("%9.3lf\t", timeinsec); int i; if (packet->length == 3) { if ((packet->data[0] & 0xf0) == 0x90) { // Note down int channel = packet->data[0] & 0x0f; int note = packet->data[1]; int velocity = packet->data[2]; printf("Down chan=%d %d vel=%d\n", channel, note, velocity); char keyboard[16], trigger[16]; if (!channel) { sprintf(keyboard, "keyboard"); sprintf(trigger, "trigger"); } else { sprintf(keyboard, "keyboard%d", channel+1); sprintf(trigger, "trigger%d", channel+1); } if (lo_send(t, "/set", "ssf", keyboard, "result", 0.1*(note-48)/12.0) == -1) { printf("OSC error %d: %s\n", lo_address_errno(t), lo_address_errstr(t)); } if (lo_send(t, "/set", "ssf", trigger, "result", velocity/127.0) == -1) { printf("OSC error %d: %s\n", lo_address_errno(t), lo_address_errstr(t)); } } else if ((packet->data[0] & 0xf0) == 0x80) { // Note up int channel = packet->data[0] & 0x0f; int note = packet->data[1]; int velocity = 0;//packet->data[2]; printf("Up chan=%d %d vel=%d\n", channel, note, velocity); char keyboard[16], trigger[16]; if (!channel) { sprintf(keyboard, "keyboard"); sprintf(trigger, "trigger"); } else { sprintf(keyboard, "keyboard%d", channel+1); sprintf(trigger, "trigger%d", channel+1); } if (lo_send(t, "/set", "ssf", keyboard, "result", 0.1*(note-48)/12.0) == -1) { printf("OSC error %d: %s\n", lo_address_errno(t), lo_address_errstr(t)); } if (lo_send(t, "/set", "ssf", trigger, "result", velocity/127.0) == -1) { printf("OSC error %d: %s\n", lo_address_errno(t), lo_address_errstr(t)); } } else if ((packet->data[0] & 0xf0) == 0xe0) { // Pitch bend int channel = packet->data[0] & 0x0f; int lo_byte = packet->data[1]; int hi_byte = packet->data[2]; printf("bend chan=%d value=%d %d\n", channel, hi_byte, lo_byte); int value = hi_byte*0x80+lo_byte; char bend[16]; if (!channel) { sprintf(bend, "bend"); } else { sprintf(bend, "bend%d", channel+1); } if (lo_send(t, "/set", "ssf", bend, "result", (float)value/0x4000) == -1) { printf("OSC error %d: %s\n", lo_address_errno(t), lo_address_errstr(t)); } } else if ((packet->data[0] & 0xf0) == 0xb0 && packet->data[1] == 1) { // Pitch modulation int channel = packet->data[0] & 0x0f; int value = packet->data[2]; printf("modulation chan=%d value=%d\n", channel, value); char modulation[16]; if (!channel) { sprintf(modulation, "modulation"); } else { sprintf(modulation, "modulation%d", channel+1); } if (lo_send(t, "/set", "ssf", modulation, "result", (float)value/0x80) == -1) { printf("OSC error %d: %s\n", lo_address_errno(t), lo_address_errstr(t)); } } } #if 0 for (i=0; i<packet->length; i++) { if (packet->data[i] < 0x7f) { printf("%d ", packet->data[i]); } else { printf("0x%x ", packet->data[i]); } } printf("\n"); #endif }