void connect_signals() { char source_name[1024], destination_name[1024]; printf("%s\n", mdev_name(source)); printf("%s\n", mdev_name(destination)); lo_address a = lo_address_new_from_url("osc.udp://224.0.1.3:7570"); lo_address_set_ttl(a, 1); lo_send(a, "/link", "ss", mdev_name(source), mdev_name(destination)); int j = 50; while (j >= 0) { mdev_poll(source, 10); mdev_poll(destination, 10); j--; } msig_full_name(sendsig, source_name, 1024); msig_full_name(recvsig, destination_name, 1024); lo_send(a, "/connect", "ss", source_name, destination_name); lo_address_free(a); }
void connect_signals() { char source_name[1024], destination_name[1024]; printf("%s\n", mdev_name(source)); printf("%s\n", mdev_name(destination)); lo_address a = lo_address_new_from_url("osc.udp://224.0.1.3:7570"); lo_address_set_ttl(a, 1); lo_send(a, "/link", "ss", mdev_name(source), mdev_name(destination)); // wait for link to be processed int j = 50; while (j >= 0) { mdev_poll(source, 10); mdev_poll(destination, 10); j--; } msig_full_name(sendsig, source_name, 1024); msig_full_name(recvsig, destination_name, 1024); lo_send(a, "/connect", "ssssss", source_name, destination_name, "@mode", "expression", "@expression", "y=y{-1}+1"); lo_address_free(a); // wait for connection to be processed j = 50; while (j >= 0) { mdev_poll(source, 10); mdev_poll(destination, 10); j--; } }
void send_zyncoder(uint8_t i) { if (i>=MAX_NUM_ZYNCODERS) return; struct zyncoder_st *zyncoder = zyncoders + i; if (zyncoder->enabled==0) return; if (zyncoder->midi_ctrl>0) { //Send to MIDI output zynmidi_send_ccontrol_change(zyncoder->midi_chan,zyncoder->midi_ctrl,zyncoder->value); //Send to MIDI controller feedback => TODO: Reverse Mapping!! ctrlfb_send_ccontrol_change(zyncoder->midi_chan,zyncoder->midi_ctrl,zyncoder->value); //printf("SEND MIDI CHAN %d, CTRL %d = %d\n",zyncoder->midi_chan,zyncoder->midi_ctrl,zyncoder->value); } else if (zyncoder->osc_lo_addr!=NULL && zyncoder->osc_path[0]) { if (zyncoder->step >= 8) { if (zyncoder->value>=64) { lo_send(zyncoder->osc_lo_addr,zyncoder->osc_path, "T"); //printf("SEND OSC %s => T\n",zyncoder->osc_path); } else { lo_send(zyncoder->osc_lo_addr,zyncoder->osc_path, "F"); //printf("SEND OSC %s => F\n",zyncoder->osc_path); } } else { lo_send(zyncoder->osc_lo_addr,zyncoder->osc_path, "i",zyncoder->value); //printf("SEND OSC %s => %d\n",zyncoder->osc_path,zyncoder->value); } } }
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; }
int main(int argc, char** argv) { char * hostname = "localhost"; if(argc > 1) { hostname = argv[1]; } if(argc == 3) { lo_send(lo_address_new("18.224.0.163", ELMO_UDP_PORT), ELMO_COMMAND, "fff", 0.0f, 0.0f, 0.0f); lo_send(lo_address_new("18.224.0.168", ELMO_UDP_PORT), ELMO_COMMAND, "fff", 0.0f, 0.0f, 0.0f); return; } sqlights_light_initialize(hostname); initialize_elmo_light("18.224.0.163", "elmo0"); initialize_elmo_light("18.224.0.168", "elmo1"); struct timeval tv, tv2; gettimeofday(&tv, NULL); while(1) { while(0 == sqlights_lights_handle(0)); gettimeofday(&tv2, NULL); if(tv2.tv_sec>tv.tv_sec || tv2.tv_usec-tv.tv_usec >= 33000) { update_lights(); tv = tv2; } } }
void loop() { printf("-------------------- GO ! --------------------\n"); int i = 0; if (automate) { char source_name[1024], destination_name[1024]; printf("%s\n", mdev_name(source)); printf("%s\n", mdev_name(destination)); lo_address a = lo_address_new_from_url("osc.udp://224.0.1.3:7570"); lo_address_set_ttl(a, 1); lo_send(a, "/link", "ss", mdev_name(source), mdev_name(destination)); msig_full_name(sendsig, source_name, 1024); msig_full_name(recvsig, destination_name, 1024); lo_send(a, "/connect", "ssss", source_name, destination_name, "@mode", "reverse"); lo_address_free(a); } while (i >= 0 && !done) { msig_update_float(recvsig, ((i % 10) * 1.0f)); printf("\ndestination value updated to %f -->\n", (i % 10) * 1.0f); mdev_poll(destination, 1); mdev_poll(source, 100); i++; } }
void set_random_flac(int i) { if (list.size() > 0) { int n = rand()%list.size(); string filename = list[n]; list.erase(list.begin() + n); switch(i) { case 0: deck0_play = 0; deck0_amp = 0.0; lo_send(address, "/1/fader1", "f", 0.0); lo_send(address, "/1/toggle1", "i", 0); lo_send(address, "/1/toggle2", "i", 0); deck0.delete_buffer(); deck0 = Play(filename.c_str()); deck0.set_loop(0); lo_send(address, "/1/rotary3", "f", 1.0); lo_send(address, "/1/toggle1", "i", 1); break; case 1: deck1_play = 0; deck1_amp = 0.0; lo_send(address, "/1/fader2", "f", 0.0); lo_send(address, "/1/toggle3", "i", 0); lo_send(address, "/1/toggle4", "i", 0); deck1.delete_buffer(); deck1 = Play(filename.c_str()); deck1.set_loop(0); lo_send(address, "/1/rotary6", "f", 1.0); lo_send(address, "/1/toggle3", "i", 1); break; } } }
void* lp2osc() { int row,col,press; while (1) { lp_receive(lp); if (dest != NULL) { if (lp->event[0] == NOTE) { // matrix or scene row = lp->event[1] / 16; col = lp->event[1] % 16; press = lp->event[2]; if (col == 8) { // scene event lo_send(dest, "/lp/scene", "ii", row, press); } else { // matrix event lo_send(dest, "/lp/matrix", "iii", row, col, press); } } else { // ctrl event col = lp->event[1] - 104; press = lp->event[2]; lo_send(dest, "/lp/ctrl", "ii", col, press); } } } }
void heartbeat() { if (mNeedToEnd) { Time now = Time::getCurrentTime(); RelativeTime dt = (now - mLastXYTime); if (dt.inMilliseconds() > 200) { mEditor->getMover()->end(kOsc); mNeedToEnd = false; } } if (!mAddress) return; int src = mEditor->getOscLeapSource(); if (src != mSource) { String s = "Source "; s << (src+1); lo_send(mAddress, kSelectSourcePath, "s", s.toRawUTF8()); mSource = src; } FPoint p = mFilter->getSourceXY01(src); if (mSourceXY != p) { //fprintf(stderr, "sent new pos to %s\n", kSourceXYPath); lo_send(mAddress, kSourceXYPath, "ff", p.y, p.x); mSourceXY = p; } }
// pa callback static int paCallback( const void *inputBuffer, void *outputBuffer, unsigned long framesPerBuffer, const PaStreamCallbackTimeInfo* timeInfo, PaStreamCallbackFlags statusFlags, void *userData ) { float *out = (float*)outputBuffer; float left, right; float rec_samples[FRAMES_PER_BUFFER*2]; float deck0_out[2], deck1_out[2]; unsigned int i, rec_i = 0; (void) inputBuffer; /* Prevent unused variable warning. */ for( i=0; i<framesPerBuffer; i++ ) { left = 0; right = 0; if (deck0_play) { deck0_out[0] = deck0.out(); deck0_out[1] = deck0.out(); left += deck0_out[0]*deck0_amp * 0.5; right += deck0_out[1]*deck0_amp * 0.5; if (deck0_vol < deck0_out[0]) deck0_vol = deck0_out[0]; } if (deck1_play) { deck1_out[0] = deck1.out(); deck1_out[1] = deck1.out(); left += deck1_out[0]*deck1_amp * 0.5; right += deck1_out[1]*deck1_amp * 0.5; if (deck1_vol < deck1_out[0]) deck1_vol = deck1_out[0]; } *out++ = left; *out++ = right; if (REC) { rec_samples[rec_i++] = left; rec_samples[rec_i++] = right; } if (count%SAMPLE_RATE==0) { lo_send(address, "/1/rotary3", "f", 1.0 - deck0.get_position()); lo_send(address, "/1/rotary6", "f", 1.0 - deck1.get_position()); lo_send(address, "/1/fader3", "f", list.size()/(float)max_list); } if (count%(int)(SAMPLE_RATE*0.1)==0) { lo_send(address, "/1/rotary2", "f", deck0_vol); lo_send(address, "/1/rotary5", "f", deck1_vol); deck0_vol *= 0.9; deck1_vol *= 0.9; } count++; } if (REC) rec.write(rec_samples); return 0; }
void OSCServer::sendBusBank(int bankNumber) { //Request an update for the bus bank faders strcpy(cu.what,"busBank"); cu.bankIndex = bankNumber; jack_ringbuffer_write(controllerUpdate,(char *) &cu, sizeof(ControllerUpdateEvent)); lo_send(touchOSC,"/controller/bus/bank/number","s",std::string(std::to_string(bankNumber+1)).c_str()); for(int i=0; i<8; i++){ lo_send(touchOSC,(std::string("/controller/bus/label/").append(std::to_string(i+1))).c_str(),"s", (std::string("Track ").append(std::to_string(bankNumber*8+i+1))).c_str()); } //let the GUI know there is work to do pASMView->scene_access_signal(); }
void osc_send_exiting(const OscData* oscData) { char targetPath[strlen(oscData->path)+9]; strcpy(targetPath, oscData->path); strcat(targetPath, "/exiting"); lo_send(oscData->addr, targetPath, ""); }
void osc_send_update(const OscData* oscData, const char* const url) { char targetPath[strlen(oscData->path)+8]; strcpy(targetPath, oscData->path); strcat(targetPath, "/update"); lo_send(oscData->addr, targetPath, "s", url); }
void osc_send_midi(const OscData* oscData, unsigned char data[4]) { char targetPath[strlen(oscData->path)+6]; strcpy(targetPath, oscData->path); strcat(targetPath, "/midi"); lo_send(oscData->addr, targetPath, "m", data); }
void osc_send_control(const OscData* oscData, const int32_t index, const float value) { char targetPath[strlen(oscData->path)+9]; strcpy(targetPath, oscData->path); strcat(targetPath, "/control"); lo_send(oscData->addr, targetPath, "if", index, value); }
void osc_send_configure(const OscData* oscData, const char* const key, const char* const value) { char targetPath[strlen(oscData->path)+11]; strcpy(targetPath, oscData->path); strcat(targetPath, "/configure"); lo_send(oscData->addr, targetPath, "ss", key, value); }
int osc_init(struct twinterface *twinterface) { osc = (struct osc *) malloc(sizeof(struct osc)); osc->twinterface = twinterface; osc->ndeck = 0; /* start a new server on port 7770 */ st = lo_server_thread_new("7771", error); /* add method that will match any path and args */ lo_server_thread_add_method(st, "/xwax/ppm", "ibi", ppm_handler, NULL); lo_server_thread_add_method(st, "/xwax/ppm_end", "i", ppm_end_handler, NULL); /* add method that will match any path and args */ lo_server_thread_add_method(st, "/xwax/track_load", "iissi", track_load_handler, NULL); /* add method that will match any path and args */ lo_server_thread_add_method(st, "/xwax/position", "iff", pos_handler, NULL); /* add method that will match any path and args */ lo_server_thread_add_method(st, "/xwax/scale", "i", scale_handler, NULL); /* add method that will match any path and args */ //lo_server_thread_add_method(st, NULL, NULL, generic_handler, NULL); lo_server_thread_start(st); /* Notify osc server that where at this address */ lo_address t = lo_address_new(ADDRESS, "7770"); lo_send(t, "/xwax/connect", ""); printf("Sent connect message\n"); return 0; }
// Register server as available void* DSPServer::registration(void* arg) { DSPServer* serv = (DSPServer*)arg; char host_name[256]; gethostname(host_name, sizeof(host_name)); #ifdef LLVM_DSP_FACTORY string target = getDSPMachineTarget(); #else string target = "Interpreter"; #endif stringstream name_service; name_service << searchIP() << ":" << serv->fPort << ":" << host_name << ":" << target; lo_address adress = lo_address_new("224.0.0.1", "7770"); while (true) { #ifdef WIN32 Sleep(1); #else usleep(1000000); #endif pthread_testcancel(); string res = name_service.str(); lo_send(adress, "/faustcompiler", "is", getpid(), res.c_str()); } pthread_exit(NULL); }
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 main() { // install signal handler if (signal(SIGINT, endall) == SIG_ERR) printf("[FAILED] to install SIGINT handle\n"); // we're reading directly from serial ArduinoSerial arduino(ARDUINO_SERIAL); char buffer[BUFFER_S]; memset(buffer, '\0', BUFFER_S); // our main loop while(1) { // getLine() blocks until we get a newline or cr // and fills buffer with stuff arduino.getLine( buffer); printf("%s", buffer); // this message looks like "p\n" if( buffer[0] == 'p') { printf("got play\n"); lo_address server = lo_address_new(SERVER, SERVER_PORT); lo_send(server, "/playtrigger", ""); lo_address_free(server);; } // get rid of previous data memset(buffer, BUFFER_S, '\0'); } return 0; }
// Callback: An existing user was lost void XN_CALLBACK_TYPE lost_user(xn::UserGenerator& generator, XnUserID nId, void* pCookie) { printf("Lost user %d\n", nId); if (kitchenMode) return; lo_send(addr, "/lost_user","i",(int)nId); }
int main(int argc,char *argv[]) { srand(time(NULL)); int quit = 0; int seed = rand() % 255; lo_address client = lo_address_new("localhost","9999"); lo_server_thread server = lo_server_thread_new("9998",err_callback); lo_server_thread_add_method(server,"/client/quit","",quit_callback,(void*)&quit); lo_server_thread_add_method(server,NULL,NULL,all_callback,NULL); printf("starting osc server at %s with seed %d\n",lo_server_thread_get_url(server),seed); lo_server_thread_start(server); int k = 0; while (!quit) { if (lo_send(client,"/client/test","ii",seed,k++) < 0) fprintf(stderr,"osc client error: %s\n",lo_address_errstr(client)); sleep(1); } printf("stopping osc server\n"); lo_server_thread_stop(server); lo_server_thread_free(server); lo_address_free(client); return 0; }
int main(int argc, char *argv[]) { lo_server st = lo_server_thread_new(NULL, NULL); lo_address t; if (argc != 2) { fprintf(stderr, "Usage: subtest <uri>\n"); return 1; } lo_server_thread_add_method(st, NULL, "i", subtest_handler, NULL); lo_server_thread_start(st); t = lo_address_new_from_url(argv[1]); lo_send(t, "/subtest", "i", 0xf00); #ifdef WIN32 Sleep(4000); #else sleep(4); #endif return 0; }
/* catch joint messages and send only l_hand and r_hand messages */ int joint_handler (const char *path, const char *types, lo_arg **argvx, int argc, void *data, void * user_data) { int j; // counter variable struct filter *fltp; // pointer to a struct filter /* if no message, return 1 */ if (!data) return 1; /* verify that the filter exists. */ if (user_data == NULL) return 1; /* convert user_data type */ fltp = (struct filter *) user_data; /* verify that the user_data represents a filter */ if (fltp->signature != FILTER_SIGNATURE) return 1; /* if the joint in the message matches a joint in filter, forward message */ for (j = 0; j < fltp->num_joints; j++) { if (strcmp (&argvx[0]->s, fltp->joints[j]) == 0) lo_send (fltp->addr, path, types, &argvx[0]->s, argvx[1]->i, argvx[2]->f, argvx[3]->f, argvx[4]->f); } // for return 1; } // joint_handler
static void *controller_thread(void *p) { int last_scene = -1; lo_address address = lo_address_new(NULL, OSC_PORT); printf("THREAD\n"); while (scene != EXITV) { #ifdef DEBUG printf(". %d\n", scene); #endif if (last_scene != scene) { last_scene = scene; if (last_scene > 0 && last_scene <= NUM_SCENES) { lo_send(address, OSC_PATH, "i", last_scene); } } #ifdef DEBUG usleep(1000000); #else usleep(10000); #endif } lo_address_free(address); #ifdef DEBUG printf("DONE\n"); #endif return NULL; }
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, const char *argv[]) { printf("Usage: lo_benchmk_client [n_addrs]\n" " n_addrs is number of paths, default is 20\n" " end n_addrs with t for TCP, e.g. 20t\n"); if (argc == 2) { n_addrs = atoi(argv[1]); printf("n_addrs is %d\n", n_addrs); use_tcp = (strchr(argv[1], 't') != NULL); } // create address for server server = lo_address_new_with_proto(use_tcp ? LO_TCP : LO_UDP, "localhost", "8000"); // create client lo_server client = lo_server_new_with_proto("8001", use_tcp ? LO_TCP : LO_UDP, NULL); // make addresses and register them with server addresses = (char **) malloc(sizeof(char **) * n_addrs); for (int i = 0; i < n_addrs; i++) { char path[100]; sprintf(path, "/benchmark/%d", i); addresses[i] = (char *) malloc(strlen(path)); strcpy(addresses[i], path); lo_server_add_method(client, path, "i", &handler, NULL); } lo_send(server, addresses[msg_count % n_addrs], "i", msg_count); while (1) { lo_server_recv_noblock(client, 0); } }
void OscCtrlServer::prop_cb(const std::string &internal_subscriber_name, const std::string &quiddity_name, const std::string &property_name, const std::string &value, void *user_data) { OscCtrlServer *context = static_cast<OscCtrlServer *>(user_data); auto it = context->osc_subscribers_.find(internal_subscriber_name); if (context->osc_subscribers_.end() == it) return; std::pair<std::string, std::string> address = context->osc_subscribers_[internal_subscriber_name]; lo_address t = lo_address_new(address.first.c_str(), address.second.c_str()); gchar *subscriber_name = context->retrieve_subscriber_name(internal_subscriber_name.c_str()); gchar *message = g_strdup_printf("/property/%s/%s/%s", subscriber_name, quiddity_name.c_str(), property_name.c_str()); lo_send(t, message, "s", value.c_str()); g_free(subscriber_name); g_free(message); lo_address_free(t); }
int main() { // install signal handler if (signal(SIGINT, endall) == SIG_ERR) printf("[FAILED] to install SIGINT handle\n"); // we're reading directly from serial ArduinoSerial arduino(ARDUINO_SERIAL); char buffer[BUFFER_S]; memset(buffer, '\0', BUFFER_S); // our main loop while(1) { int velocity = -1 , id = -1; // getLine() blocks until we get a newline or cr // and fills buffer with stuff int size = arduino.getLine( buffer); printf("%s", buffer); // our input looks like "i 123 v 4567" // so that id would be 123 and velocity would be 456 sscanf(buffer, "i %d v %d\n", &id, &velocity); if( id != -1 && velocity != -1) { // show what we got printf( "s = %d, id = %d, vel = %d\n", size, id, velocity); int min = 0; int max = NUM_VIDEOS; int newint = rand()%(max-min + 1) + min; lo_address server = lo_address_new(SERVER, SERVER_PORT); lo_send(server, "/stopall", "i", velocity); // lo_send(server, "/playloop", "i", id); /* now we're sending a random video number because we have more videos than buttons, plus dave wanted it to be random anyway */ lo_send(server, "/playloop", "i", newint); lo_address_free(server); } // get rid of previous data memset(buffer, BUFFER_S, '\0'); } return 0; }
// Callback: New user was detected void XN_CALLBACK_TYPE new_user(xn::UserGenerator& generator, XnUserID nId, void* pCookie) { printf("New User %d\n", nId); userGenerator.GetSkeletonCap().RequestCalibration(nId, TRUE); if (kitchenMode) return; lo_send(addr, "/new_user","i",(int)nId); }