lo_address lo_address_new_from_url(const char *url)
{
lo_address a;
int protocol;
char *host, *port, *proto;
if (!url || !*url) {
return NULL;
}
protocol = lo_url_get_protocol_id(url);
if (protocol == LO_UDP || protocol == LO_TCP) {
host = lo_url_get_hostname(url);
port = lo_url_get_port(url);
a = lo_address_new_with_proto(protocol, host, port);
if(host) free(host);
if(port) free(port);
#ifndef WIN32
} else if (protocol == LO_UNIX) {
port = lo_url_get_path(url);
a = lo_address_new_with_proto(LO_UNIX, NULL, port);
if(port) free(port);
#endif
} else {
proto = lo_url_get_protocol(url);
fprintf(stderr, PACKAGE_NAME ": protocol '%s' not supported by this "
"version\n", proto);
if(proto) free(proto);
return NULL;
}
return a;
}
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);
}
}
//ctrl+c etc
static void signal_handler(int sig)
{
shutdown_in_progress=1;
process_enabled=0;
fprintf(stderr,"\nterminate signal %d received.\n",sig);
if(close_on_incomp==0)
{
fprintf(stderr,"telling sender to pause.\n");
//lo_address loa = lo_address_new(sender_host,sender_port);
lo_address loa = lo_address_new_with_proto(lo_proto, sender_host,sender_port);
lo_message msg=lo_message_new();
lo_send_message (loa, "/pause", msg);
lo_message_free(msg);
}
usleep(1000);
fprintf(stderr,"cleaning up...");
lo_server_thread_free(lo_st);
rb_free(rb);
rb_free(rb_helper);
fprintf(stderr,"done.\n");
fflush(stderr);
exit(0);
}
//================================================================
void osc_error_handler(int num, const char *msg, const char *path)
{
if(close_on_incomp==1 && shutdown_in_progress==0)
{
fprintf(stderr,"/!\\ liblo server error %d: %s %s\n", num, path, msg);
fprintf(stderr,"telling sender to pause.\n");
//lo_address loa=lo_address_new(sender_host,sender_port);
lo_address loa=lo_address_new_with_proto(lo_proto, sender_host,sender_port);
lo_message msg=lo_message_new();
lo_send_message(loa, "/pause", msg);
lo_message_free(msg);
io_quit("incompatible_jack_settings");
fprintf(stderr,"cleaning up...");
jack_client_close(client);
//lo_server_thread_free(lo_st);
jack_ringbuffer_free(rb);
jack_ringbuffer_free(rb_helper);
fprintf(stderr," done.\n");
exit(1);
}
else if(shutdown_in_progress==0)
{
fprintf(stderr,"\r/!\\ liblo server error %d: %s %s\n", num, path, msg);
//should be a param
}
}//end osc_error_handler
int OscTransmitter::addAddress(const char * host, const char * port, int proto)
{
lo_address addr = lo_address_new_with_proto(proto, host, port);
if(addr == 0)
return -1;
addresses_.push_back(addr);
return (int)addresses_.size() - 1;
}
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;
}
//================================================================
//ctrl+c etc
static void signal_handler(int sig)
{
fprintf(stderr,"\nterminate signal %d received.\n",sig);
io_quit("terminated");
shutdown_in_progress=1;
process_enabled=0;
if(close_on_incomp==0)
{
fprintf(stderr,"telling sender to pause.\n");
//lo_address loa=lo_address_new(sender_host,sender_port);
lo_address loa=lo_address_new_with_proto(lo_proto, sender_host,sender_port);
lo_message msg=lo_message_new();
lo_send_message(loa, "/pause", msg);
lo_message_free(msg);
}
fprintf(stderr,"cleaning up...");
jack_deactivate(client);
int index=0;
while(ioPortArray[index]!=NULL && index<input_port_count)
{
jack_port_unregister(client,ioPortArray[index]);
index++;
}
jack_client_close(client);
// lo_server_thread_free(lo_st);
jack_ringbuffer_free(rb);
jack_ringbuffer_free(rb_helper);
fprintf(stderr," done.\n");
exit(0);
}//end signal_handler
Client::Client( const std::string &host, int port, Proto proto /* = PROTO_UDP */ )
{
std::string portStr = boost::lexical_cast< std::string >( port );
mAddress = lo_address_new_with_proto( proto, host.c_str(), portStr.c_str() );
}
lo_address lo_address_new(const char *host, const char *port)
{
return lo_address_new_with_proto(LO_UDP, host ,port);
}
int
main (int argc, char *argv[])
{
//////////////////////////////////////////////
//will be removed
// sample_rate=44100;
sample_rate=48000;
// period_size=2048;
period_size=4096;
// period_size=256;
//period_size=128;
bytes_per_sample=4;
//osc
const char *listenPort;
//command line options parsing
//http://www.gnu.org/software/libc/manual/html_node/Using-Getopt.html
static struct option long_options[] =
{
{"help", no_argument, 0, 'h'},
{"version", no_argument, 0, 'v'},
{"loinfo", no_argument, 0, 'x'},
{"out", required_argument, 0, 'o'},
{"offset", required_argument, 0, 'f'},
{"16", no_argument, 0, 'y'},
{"max", required_argument, 0, 'm'},//max (allocate) buffer
{"update", required_argument, 0, 'u'},//screen info update every nth cycle
{"limit", required_argument, 0, 'l'},//test, stop after n processed
{0, 0, 0, 0}
};
//print program header
if(argc>1 && strcmp(argv[1],"--version"))
{
print_header("audio_post_send");
}
if (argc - optind < 1)
{
fprintf (stderr, "Missing arguments, see --help.\n\n");
exit(1);
}
int opt;
//do until command line options parsed
while (1)
{
/* getopt_long stores the option index here. */
int option_index = 0;
opt = getopt_long (argc, argv, "", long_options, &option_index);
/* Detect the end of the options. */
if (opt == -1)
{
break;
}
switch (opt)
{
case 0:
/* If this option set a flag, do nothing else now. */
if (long_options[option_index].flag != 0)
{
break;
}
case 'h':
print_help();
break;
case 'v':
print_version();
break;
case 'x':
check_lo_props(1);
return 1;
case 'o':
output_port_count=atoi(optarg);
if(output_port_count>max_channel_count)
{
fprintf(stderr,"*** limiting playback ports to %d, sry\n",max_channel_count);
output_port_count=max_channel_count;
}
port_count=fmin(input_port_count,output_port_count);
break;
case 'f':
channel_offset=atoi(optarg);
break;
case 'm':
//min 1 MB
max_buffer_size=fmax(1,(uint64_t)atoll(optarg)*1000*1000);
break;
case 'u':
update_display_every_nth_cycle=fmax(1,(uint64_t)atoll(optarg));
break;
case 'l':
receive_max=fmax(1,(uint64_t)atoll(optarg));
test_mode=1;
fprintf(stderr,"*** limiting number of messages: %" PRId64 "\n",receive_max);
break;
case '?': //invalid commands
/* getopt_long already printed an error message. */
fprintf (stderr, "Wrong arguments, see --help.\n\n");
exit(1);
break;
default:
break;
} //end switch op
}//end while(1)
//remaining non optional parameters listening port, remote host, remote port
if(argc-optind != 3)
{
fprintf (stderr, "Wrong arguments, see --help.\n\n");
exit(1);
}
if(check_lo_props(0)>0)
{
return 1;
}
if(have_libjack()!=0)
{
fprintf(stderr,"/!\\ libjack not found (JACK not installed?). this is fatal: audio_post_send needs JACK to run.\n");
//io_quit("nolibjack");
exit(1);
}
listenPort=argv[optind];
//tcp target
remote_tcp_host=argv[optind+1];
remote_tcp_port=argv[optind+2];
loa_tcp = lo_address_new_with_proto(LO_TCP, remote_tcp_host, remote_tcp_port);
//initialize time
gettimeofday(&tv, NULL);
tt_prev.sec=tv.tv_sec;
tt_prev.frac=tv.tv_usec;
//print startup info
fprintf(stderr,"listening on UDP port: %s\n",listenPort);
//udp/tcp use the same port for now
fprintf(stderr,"started TCP server on port: %s\n",listenPort);
fprintf(stderr,"channels (forward): %d\n",output_port_count);
fprintf(stderr,"channel offset: %d\n",channel_offset);
fprintf(stderr, "TCP target: %s:%s\n",remote_tcp_host,remote_tcp_port);
fprintf(stderr, "period size (TCP forward): %d samples\n",period_size);
fprintf(stderr, "delay between TCP sends: %d ms\n",delay_between_tcp_sends);
fprintf(stderr, "delay between TCP retries on broken connection: %d ms\n",delay_between_tcp_retries);
//ringbuffer size bytes
uint64_t rb_size;
//use as given via param --max or:
if(max_buffer_size==0)
{
//default
//10 MB . .
max_buffer_size=10000000;
}
//
rb_size=max_buffer_size;
fprintf(stderr,"allocated buffer size: %" PRId64 " bytes (%.2f MB)\n",max_buffer_size,(float)max_buffer_size/1000/1000);
//====================================
//main ringbuffer osc blobs -> jack output
rb = rb_new (rb_size);
//helper ringbuffer: used when remote period size < local period size
rb_helper = rb_new (rb_size);
if(rb==NULL)
{
fprintf(stderr,"could not create a ringbuffer with that size.\n");
fprintf(stderr,"try --max <smaller size>.\n");
exit(1);
}
/* install a signal handler to properly quits jack client */
#ifndef _WIN
signal(SIGQUIT, signal_handler);
signal(SIGHUP, signal_handler);
#endif
signal(SIGTERM, signal_handler);
signal(SIGINT, signal_handler);
//add osc hooks & start UDP server
registerOSCMessagePatterns(listenPort);
lo_server_thread_start(lo_st);
//start TCP server, for forwarding to final receiver
lo_st_tcp = lo_server_thread_new_with_proto(listenPort, LO_TCP, error);
lo_server_thread_start(lo_st_tcp);
fflush(stderr);
/* keep running until the Ctrl+C */
while(1)
{
//possibly clean shutdown without any glitches
if(shutdown_in_progress==1)
{
signal_handler(42);
}
//if tcp message could not be sent
if(process()<0)
{
//wait x and update info
int i;
for(i=0;i<delay_between_tcp_retries;i++)
{
usleep(1000);
print_info();
}
}
else
{
//wait y and update info
int i;
for(i=0;i<delay_between_tcp_sends;i++)
{
usleep(1000);
print_info();
}
}
}
exit (0);
}
//================================================================
int main(int argc, char *argv[])
{
//jack
const char **ports;
//jack_options_t options = JackNullOption;
jack_status_t status;
//options struct was here
if(argc-optind<1)
{
print_header("jack_audio_receive");
fprintf(stderr, "Missing arguments, see --help.\n\n");
exit(1);
}
int opt;
//do until command line options parsed
while(1)
{
/* getopt_long stores the option index here. */
int option_index=0;
opt=getopt_long(argc, argv, "", long_options, &option_index);
/* Detect the end of the options. */
if(opt==-1)
{
break;
}
switch(opt)
{
case 0:
/* If this option set a flag, do nothing else now. */
if(long_options[option_index].flag!=0)
{
break;
}
case 'h':
print_header("jack_audio_receive");
print_help();
break;
case 'v':
print_version();
break;
case 'x':
print_header("jack_audio_receive");
check_lo_props(1);
return 1;
case 'o':
output_port_count=atoi(optarg);
if(output_port_count>max_channel_count)
{
output_port_count=max_channel_count;
}
port_count=fmin(input_port_count,output_port_count);
break;
case 'f':
channel_offset=atoi(optarg);
break;
case 'y':
bytes_per_sample=2;
break;
case 'n':
client_name=optarg;
break;
case 's':
server_name=optarg;
jack_opts |= JackServerName;
break;
case 'b':
pre_buffer_size=fmax(1,(uint64_t)atoll(optarg));
break;
case 'm':
max_buffer_size=fmax(1,(uint64_t)atoll(optarg));
break;
case 'u':
update_display_every_nth_cycle=fmax(1,(uint64_t)atoll(optarg));
break;
case 'l':
receive_max=fmax(1,(uint64_t)atoll(optarg));
test_mode=1;
break;
case 'a':
io_host=optarg;
break;
case 'c':
io_port=optarg;
break;
case 't':
use_tcp=1;
remote_tcp_server_port=optarg;
break;
case '?': //invalid commands
/* getopt_long already printed an error message. */
print_header("jack_audio_receive");
fprintf(stderr, "Wrong arguments, see --help.\n\n");
exit(1);
break;
default:
break;
} //end switch op
}//end while(1)
//remaining non optional parameters listening port
if(argc-optind!=1)
{
print_header("jack_audio_receive");
fprintf(stderr, "Wrong arguments, see --help.\n\n");
exit(1);
}
localPort=argv[optind];
//for commuication with a gui / other controller / visualizer
loio=lo_address_new_with_proto(LO_UDP, io_host, io_port);
//if was set to use random port
if(atoi(localPort)==0)
{
//for lo_server_thread_new_with_proto
localPort=NULL;
}
//add osc hooks & start osc server early (~right after cmdline parsing)
registerOSCMessagePatterns(localPort);
lo_server_thread_start(lo_st);
//read back port (in case of random)
//could use
//int lo_server_thread_get_port(lo_server_thread st)
const char *osc_server_url=lo_server_get_url(lo_server_thread_get_server(lo_st));
localPort=lo_url_get_port(osc_server_url);
//int lport=lo_server_thread_get_port(lo_st);
//notify osc gui
if(io_())
{
lo_message msgio=lo_message_new();
lo_message_add_float(msgio, version);
lo_message_add_float(msgio, format_version);
lo_send_message(loio, "/startup", msgio);
lo_message_free(msgio);
}
if(check_lo_props(0)>0)
{
return 1;
}
if(use_tcp==1)
{
lo_proto=LO_TCP;
}
if(shutup==0)
{
print_header("jack_audio_receive");
if(output_port_count>max_channel_count)
{
fprintf(stderr,"/!\\ limiting playback ports to %d, sry\n",max_channel_count);
}
if(test_mode==1)
{
fprintf(stderr,"/!\\ limiting number of messages: %" PRId64 "\n",receive_max);
}
}
//check for default jack server env var
char *evar=getenv("JACK_DEFAULT_SERVER");
if(evar==NULL || strlen(evar)<1)
{
#ifndef _WIN
unsetenv("JACK_DEFAULT_SERVER");
#endif
}
else if(server_name==NULL)
{
//use env var if no server was given with --sname
server_name=evar;
}
if(server_name==NULL || strlen(server_name)<=0)
{
server_name="default";
}
if(client_name==NULL)
{
client_name="receive";
}
if(have_libjack()!=0)
{
fprintf(stderr,"/!\\ libjack not found (JACK not installed?). this is fatal: jack_audio_receive needs JACK to run.\n");
io_quit("nolibjack");
exit(1);
}
//initialize time
gettimeofday(&tv, NULL);
tt_prev.sec=tv.tv_sec;
tt_prev.frac=tv.tv_usec;
//create an array of input ports
ioPortArray=(jack_port_t**) malloc(output_port_count * sizeof(jack_port_t*));
//open a client connection to the JACK server
client=jack_client_open(client_name, jack_opts, &status, server_name);
if(client==NULL)
{
fprintf(stderr,"jack_client_open() failed, status = 0x%2.0x\n", status);
if(status & JackServerFailed)
{
fprintf(stderr,"Unable to connect to JACK server.\n");
io_quit("nojack");
}
exit(1);
}
if(use_tcp==1)
{
if(shutup==0)
{
fprintf(stderr,"receiving on TCP port: %s\n",localPort);
}
}
else
{
if(shutup==0)
{
fprintf(stderr,"receiving on UDP port: %s\n",localPort);
}
}
client_name=jack_get_client_name(client);
if(shutup==0)
{
fprintf(stderr,"started JACK client '%s' on server '%s'\n",client_name,server_name);
if(status & JackNameNotUnique)
{
fprintf(stderr, "/!\\ name '%s' was automatically assigned\n", client_name);
}
}
if(status & JackNameNotUnique)
{
io_simple("/client_name_changed");
}
//print startup info
read_jack_properties();
if(shutup==0)
{
print_common_jack_properties();
fprintf(stderr,"channels (playback): %d\n",output_port_count);
fprintf(stderr,"channel offset: %d\n",channel_offset);
print_bytes_per_sample();
fprintf(stderr,"multi-channel period size: %d bytes\n",
output_port_count*period_size*bytes_per_sample
);
char *strat="fill with zero (silence)";
if(zero_on_underflow==0)
{
strat="re-use last available period";
}
fprintf(stderr,"underflow strategy: %s\n",strat);
if(rebuffer_on_restart==1)
{
fprintf(stderr,"rebuffer on sender restart: yes\n");
}
else
{
fprintf(stderr,"rebuffer on sender restart: no\n");
}
if(rebuffer_on_underflow==1)
{
fprintf(stderr,"rebuffer on underflow: yes\n");
}
else
{
fprintf(stderr,"rebuffer on underflow: no\n");
}
if(allow_remote_buffer_control==1)
{
fprintf(stderr,"allow external buffer control: yes\n");
}
else
{
fprintf(stderr,"allow external buffer control: no\n");
}
if(close_on_incomp==1)
{
fprintf(stderr,"shutdown receiver when incompatible data received: yes\n");
}
else
{
fprintf(stderr,"shutdown receiver when incompatible data received: no\n");
}
}//end cond. print
char buf[64];
format_seconds(buf,(float)pre_buffer_size*period_size/(float)sample_rate);
uint64_t rb_size_pre=pre_buffer_size*output_port_count*period_size*bytes_per_sample;
if(shutup==0)
{
fprintf(stderr,"initial buffer size: %" PRId64 " mc periods (%s, %" PRId64 " bytes, %.2f MB)\n",
pre_buffer_size,
buf,
rb_size_pre,
(float)rb_size_pre/1000/1000
);
}
buf[0]='\0';
//ringbuffer size bytes
uint64_t rb_size;
//ringbuffer mc periods
int max_buffer_mc_periods;
//max given as param (user knows best. if pre=max, overflows are likely)
if(max_buffer_size>0)
{
max_buffer_mc_periods=fmax(pre_buffer_size,max_buffer_size);
rb_size=max_buffer_mc_periods
*output_port_count*period_size*bytes_per_sample;
}
else //"auto"
{
//make max buffer 0.5 seconds larger than pre buffer
max_buffer_mc_periods=pre_buffer_size+ceil(0.5*(float)sample_rate/period_size);
rb_size=max_buffer_mc_periods
*output_port_count*period_size*bytes_per_sample;
}
max_buffer_size=max_buffer_mc_periods;
format_seconds(buf,(float)max_buffer_mc_periods*period_size/sample_rate);
if(shutup==0)
{
fprintf(stderr,"allocated buffer size: %" PRId64 " mc periods (%s, %" PRId64 " bytes, %.2f MB)\n",
max_buffer_size,
buf,
rb_size,
(float)rb_size/1000/1000
);
}
buf[0]='\0';
io_dump_config();
//====================================
//main ringbuffer osc blobs -> jack output
rb=jack_ringbuffer_create(rb_size);
//helper ringbuffer: used when remote period size < local period size
rb_helper=jack_ringbuffer_create(rb_size);
if(rb==NULL)
{
fprintf(stderr,"could not create a ringbuffer with that size.\n");
fprintf(stderr,"try --max <smaller size>.\n");
io_quit("ringbuffer_too_large");
exit(1);
}
//JACK will call process() for every cycle (given by JACK)
//NULL could be config/data struct
jack_set_process_callback(client, process, NULL);
jack_set_xrun_callback(client, xrun_handler, NULL);
//register hook to know when JACK shuts down or the connection
//was lost (i.e. client zombified)
jack_on_shutdown(client, jack_shutdown_handler, 0);
// Register each output port
int port;
for(port=0; port<output_port_count; port ++)
{
// Create port name
char* portName;
if(asprintf(&portName, "output_%d", (port+1)) < 0)
{
fprintf(stderr,"Could not create portname for port %d", port);
io_quit("port_error");
exit(1);
}
// Register the output port
ioPortArray[port]=jack_port_register(client, portName, JACK_DEFAULT_AUDIO_TYPE, JackPortIsOutput, 0);
if(ioPortArray[port]==NULL)
{
fprintf(stderr,"Could not create output port %d\n", (port+1));
io_quit("port_error");
exit(1);
}
}
/* Tell the JACK server that we are ready to roll. Our
* process() callback will start running now. */
if(jack_activate(client))
{
fprintf(stderr, "cannot activate client");
io_quit("cannot_activate_client");
exit(1);
}
/* Connect the ports. You can't do this before the client is
* activated, because we can't make connections to clients
* that aren't running. Note the confusing (but necessary)
* orientation of the driver backend ports: playback ports are
* "input" to the backend, and capture ports are "output" from
* it.
*/
//prevent to get physical midi ports
const char* pat="audio";
ports=jack_get_ports(client, NULL, pat, JackPortIsPhysical|JackPortIsInput);
if(ports==NULL)
{
if(shutup==0)
{
fprintf(stderr,"no physical playback ports\n");
}
//exit(1);
}
if(autoconnect==1)
{
fprintf(stderr, "\n");
int j=0;
int i;
for(i=0;i<output_port_count;i++)
{
if(ports[i]!=NULL
&& ioPortArray[j]!=NULL
&& jack_port_name(ioPortArray[j])!=NULL)
{
if(!jack_connect(client, jack_port_name(ioPortArray[j]), ports[i]))
{
if(shutup==0)
{
fprintf(stderr, "autoconnect: %s -> %s\n",
jack_port_name(ioPortArray[j]),ports[i]
);
}
io_simple_string_double("/autoconnect",jack_port_name(ioPortArray[j]),ports[i]);
j++;
}
else
{
if(shutup==0)
{
fprintf(stderr, "autoconnect: failed: %s -> %s\n",
jack_port_name(ioPortArray[j]),ports[i]
);
}
}
}
else
{
//no more playback ports
break;
}
}//end for all output ports
if(shutup==0)
{
fprintf(stderr, "\n");
}
}
free(ports);
fflush(stderr);
/* install a signal handler to properly quits jack client */
#ifndef _WIN
signal(SIGQUIT, signal_handler);
signal(SIGHUP, signal_handler);
#endif
signal(SIGTERM, signal_handler);
signal(SIGINT, signal_handler);
if(use_tcp==1)
{
//10 MB max
int desired_max_tcp_size=10000000;
lo_server s=lo_server_thread_get_server(lo_st);
int ret_set_size=lo_server_max_msg_size(s, desired_max_tcp_size);
if(shutup==0)
{
printf("set tcp max size return: %d\n",ret_set_size);
io_simple("/tcp_max_size_xxxx");
}
}
not_yet_ready=0;
io_simple("/start_main_loop");
//run possibly forever until not interrupted by any means
while(1)
{
//possibly clean shutdown without any glitches
if(shutdown_in_progress==1)
{
signal_handler(42);
}
#ifdef WIN_
Sleep(1000);
#else
sleep(1);
#endif
}
exit(0);
}//end main
//================================================================
// /audio
//handler for audio messages
int osc_audio_handler(const char *path, const char *types, lo_arg **argv, int argc,
void *data, void *user_data)
{
if(shutdown_in_progress==1 || not_yet_ready==1)
{
return 0;
}
//init to 0, increment before use
msg_received_counter++;
gettimeofday(&tv, NULL);
//first blob is at data_offset+1 (one-based)
int data_offset=4;
//ignore first n channels/blobs
data_offset+=channel_offset;
message_number_prev=message_number;
//the messages are numbered sequentially. first msg is numberd 1
message_number=argv[0]->h;
if(message_number_prev<message_number-1)
{
fprintf(stderr,"\ngap in message sequence! possibly lost %" PRId64" message(s) on the way.\n"
,message_number-message_number_prev-1);
fflush(stderr);
}
//total args count minus metadata args count = number of blobs
input_port_count=argc-data_offset;
//only process useful number of channels
port_count=fmin(input_port_count,output_port_count);
if(port_count < 1)
{
fprintf(stderr,"channel offset %d >= available input channels %d! (nothing to receive). shutting down...\n"
,channel_offset
,channel_offset+input_port_count);
fflush(stderr);
shutdown_in_progress=1;
return 0;
}
//check sample rate and period size if sender (re)started or values not yet initialized (=no /offer received)
if(message_number_prev>message_number || message_number==1 || remote_sample_rate==0 || remote_period_size==0 )
{
lo_address loa;
if(use_tcp==1)
{
lo_address loa_=lo_message_get_source(data);
loa=lo_address_new_with_proto(lo_proto,lo_address_get_hostname(loa_),remote_tcp_server_port);
}
else
{
loa=lo_message_get_source(data);
}
strcpy(sender_host,lo_address_get_hostname(loa));
strcpy(sender_port,lo_address_get_port(loa));
//option --rebuff
if(rebuffer_on_restart==1)
{
uint64_t can_read_count=jack_ringbuffer_read_space(rb);
pre_buffer_counter=fmax(0,(float)can_read_count/(float)bytes_per_sample/(float)period_size/(float)port_count);
//start buffering
process_enabled=0;
}
else
{
pre_buffer_counter=0;
}
remote_sample_rate=argv[3]->i;
if(sample_rate!=remote_sample_rate)
{
if(close_on_incomp==0)
{
//sending deny will tell sender to stop/quit
lo_message msg=lo_message_new();
lo_message_add_float(msg,format_version);
lo_message_add_int32(msg,sample_rate);
// /deny as reply to /audio should be the same as for /deny as reply to /offer
//will need change of /audio (add format, bytes_per_sample)
///////
lo_message_add_int32(msg,99);
lo_send_message(loa, "/deny", msg);
lo_message_free(msg);
fprintf(stderr,"\ndenying transmission from %s:%s\n(incompatible JACK settings on sender: SR: %d). telling sender to stop.\n",
lo_address_get_hostname(loa),lo_address_get_port(loa),remote_sample_rate
);
fflush(stderr);
message_number=0;
message_number_prev=0;
remote_sample_rate=0;
remote_period_size=0;
//pre_buffer_counter=0;
}
else
{
lo_address loa;
if(use_tcp==1)
{
lo_address loa_=lo_message_get_source(data);
loa=lo_address_new_with_proto(lo_proto,lo_address_get_hostname(loa_),remote_tcp_server_port);
}
else
{
loa=lo_message_get_source(data);
}
fprintf(stderr,"\ndenying transmission from %s:%s\nincompatible JACK settings on sender: SR: %d.\nshutting down (see option --close)...\n",
lo_address_get_hostname(loa),lo_address_get_port(loa),remote_sample_rate
);
fflush(stderr);
shutdown_in_progress=1;
return 0;
}
}
remote_period_size=lo_blob_datasize((lo_blob)argv[0+data_offset])/bytes_per_sample;
if(shutup==0 && quiet==0)
{
fprintf(stderr,"\nsender was (re)started. ");
lo_address loa=lo_message_get_source(data);
fprintf(stderr,"receiving from %s:%s\n",lo_address_get_hostname(loa),lo_address_get_port(loa));
}
io_simple("/sender_restarted");
if(shutup==0 && quiet==0)
{
if(remote_period_size!=period_size)
{
fprintf(stderr,"sender period size: %d samples (%.3f x local)\n\n",remote_period_size,(float)remote_period_size/period_size);
}
else
{
fprintf(stderr,"equal sender and receiver period size\n\n");
}
fflush(stderr);
}
}//end if "no-offer init" was needed
remote_xrun_counter=argv[1]->h;
lo_timetag tt=argv[2]->t;
double msg_time=tt.sec+(double)tt.frac/1000000;
double msg_time_prev=tt_prev.sec+(double)tt_prev.frac/1000000;
//unused for now
// double time_now=tv.tv_sec+(double)tv.tv_usec/1000000;
time_interval=msg_time-msg_time_prev;
time_interval_sum+=time_interval;
time_interval_avg=(float)time_interval_sum/msg_received_counter;
tt_prev=tt;
//reset avg calc, check and reset after use
if(msg_received_counter>=avg_calc_interval)
{
msg_received_counter=0;
time_interval_sum=0;
}
if(pre_buffer_counter>=pre_buffer_size && process_enabled==0)
{
//if buffer filled, start to output audio in process()
process_enabled=1;
}
int mc_period_bytes=period_size*bytes_per_sample*port_count;
//check if a whole mc period can be written to the ringbuffer
uint64_t can_write_count=jack_ringbuffer_write_space(rb);
if(can_write_count < mc_period_bytes)
{
buffer_overflow_counter++;
/////////////////
if(shutup==0 && quiet==0)
{
fprintf(stderr,"\rBUFFER OVERFLOW! this is bad -----%s","\033[0J");
}
return 0;
}
//========================================
//new: support different period sizes on sender / receiver (still need same SR)
//this needs more tests and optimization
if(period_size==remote_period_size)
{
int i;
//don't read more channels than we have outputs
for(i=0;i < port_count;i++)
{
//get blob (=one period of one channel)
unsigned char *data=lo_blob_dataptr((lo_blob)argv[i+data_offset]);
//fprintf(stderr,"size %d\n",lo_blob_datasize((lo_blob)argv[i+data_offset]));
//write to ringbuffer
//==========================================
//int cnt=
jack_ringbuffer_write(rb, (void *) data,
period_size*bytes_per_sample);
}
pre_buffer_counter++;
}
else if(period_size>remote_period_size)
{
int i;
//don't read more channels than we have outputs
for(i=0;i < port_count;i++)
{
//get blob (=one period of one channel)
unsigned char *data=lo_blob_dataptr((lo_blob)argv[i+data_offset]);
//fprintf(stderr,"size %d\n",lo_blob_datasize((lo_blob)argv[i+data_offset]));
//write to temporary ringbuffer until there is enough data
//==========================================
//int cnt=
jack_ringbuffer_write(rb_helper, (void *) data,
remote_period_size*bytes_per_sample);
}
//if enough data collected for one larger multichannel period
while(jack_ringbuffer_read_space(rb_helper) >=mc_period_bytes
&& jack_ringbuffer_write_space(rb) >=mc_period_bytes)
{
//transfer from helper to main ringbuffer
unsigned char* data;
data=malloc( mc_period_bytes);
//store orig pointer
unsigned char* orig_data=data;
jack_ringbuffer_read(rb_helper,data, mc_period_bytes);
for(i=0;i < port_count;i++)
{
int k;
for(k=0;k<(period_size/remote_period_size);k++)
{
//reset pointer
data=orig_data;
//position in helper buffer for next sample for main buffer
data+= k*remote_period_size*bytes_per_sample*port_count
+ i*remote_period_size*bytes_per_sample;
//write one channel snipped (remote_period_size) to main buffer
//int w=
jack_ringbuffer_write(rb,(void *)data,remote_period_size*bytes_per_sample);
}
}
data=orig_data;
free(data);
pre_buffer_counter++;
}
}
else if(period_size<remote_period_size)
{
int k;
for(k=0;k<(remote_period_size/period_size);k++)
{
int i;
//don't read more channels than we have outputs
for(i=0;i < port_count;i++)
{
//get blob (=one period of one channel)
unsigned char *data=lo_blob_dataptr((lo_blob)argv[i+data_offset]);
//fprintf(stderr,"size %d\n",lo_blob_datasize((lo_blob)argv[i+data_offset]));
//write to ringbuffer
//==========================================
data+=k*period_size*bytes_per_sample;
//int cnt=
jack_ringbuffer_write(rb, (void *) data,
period_size*bytes_per_sample);
}
pre_buffer_counter++;
}
}
return 0;
}//end osc_audio_handler
//================================================================
// /offer
//sender offers audio
int osc_offer_handler(const char *path, const char *types, lo_arg **argv, int argc,
void *data, void *user_data)
{
if(shutdown_in_progress==1 || not_yet_ready==1)
{
return 0;
}
float offered_format_version=argv[0]->f;
int offered_sample_rate=argv[1]->i;
int offered_bytes_per_sample=argv[2]->i;
int offered_period_size=argv[3]->i;
//unused here
// int offered_channel_count=argv[4]->i;
// float offered_data_rate=argv[5]->f;
// uint64_t request_counter=argv[6]->h;
lo_message msg=lo_message_new();
//send back to host that offered audio
//lo_address loa=lo_message_get_source(data);
lo_address loa;
if(use_tcp==1)
{
lo_address loa_=lo_message_get_source(data);
loa=lo_address_new_with_proto(lo_proto,lo_address_get_hostname(loa_),remote_tcp_server_port);
}
else
{
loa=lo_message_get_source(data);
}
//check if compatible with sender
//could check more stuff (channel count, data rate, sender host/port, ...)
if(
offered_sample_rate==sample_rate
&& offered_bytes_per_sample==bytes_per_sample
&& offered_format_version==format_version
//new: support non-matching period sizes
//&& offered_period_size==period_size
)
{
remote_sample_rate=sample_rate;
remote_period_size=offered_period_size;
strcpy(sender_host,lo_address_get_hostname(loa));
strcpy(sender_port,lo_address_get_port(loa));
//sending accept will tell the sender to start transmission
lo_send_message(loa, "/accept", msg);
/*
fprintf(stderr,"\nreceiving from %s:%s",
lo_address_get_hostname(loa),lo_address_get_port(loa));
*/
starting_transmission=1;
}
//data is incompatible, handle depending on --close
else if(close_on_incomp==0)
{
//sending deny will tell sender to stop/quit
lo_message_add_float(msg,format_version);
lo_message_add_int32(msg,sample_rate);
lo_message_add_int32(msg,bytes_per_sample);
lo_send_message(loa, "/deny", msg);
fprintf(stderr,"\ndenying transmission from %s:%s\nincompatible JACK settings or format version on sender:\nformat version: %.2f\nSR: %d\nbytes per sample: %d\ntelling sender to stop.\n",
lo_address_get_hostname(loa),lo_address_get_port(loa),offered_format_version,offered_sample_rate,offered_bytes_per_sample
);
//shutting down is not a good strategy for the receiver in this case
//shutdown_in_progress=1;
}
else
{
fprintf(stderr,"\ndenying transmission from %s:%s\nincompatible JACK settings or format version on sender\nformat version: %.2f\nSR: %d\nshutting down... (see option --close)\n",
lo_address_get_hostname(loa),lo_address_get_port(loa),offered_format_version,offered_sample_rate
);
shutdown_in_progress=1;
}
lo_message_free(msg);
fflush(stderr);
return 0;
} //end osc_offer_handler
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;
}
