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