// *****************************************************************************
std::vector<lo_message> ConstraintsNode::getState () const
{
// inherit state from base class
std::vector<lo_message> ret = GroupNode::getState();
lo_message msg;
osg::Vec3 v;
msg = lo_message_new();
lo_message_add(msg, "ss", "setTarget", this->getTarget());
ret.push_back(msg);
msg = lo_message_new();
lo_message_add(msg, "si", "setConstraintMode", this->getConstraintMode());
ret.push_back(msg);
msg = lo_message_new();
v = getCubeSize();
lo_message_add(msg, "sfff", "setCubeSize", v.x(), v.y(), v.z());
ret.push_back(msg);
msg = lo_message_new();
v = getCubeOffset();
lo_message_add(msg, "sfff", "setCubeOffset", v.x(), v.y(), v.z());
ret.push_back(msg);
return ret;
}
void nfosc_stop() {
int i;
if (!running) return;
running = false;
if( main_thread ) pthread_detach(main_thread);
main_thread = NULL;
lo_bundle osc_bundle = lo_bundle_new(LO_TT_IMMEDIATE);
for (i=0;i<buffer_size;i++) {
lo_message del_message = lo_message_new();
lo_message_add_int32(del_message, tag_buffer[i].device_id);
lo_message_add_int32(del_message, tag_buffer[i].symbol_id);
lo_message_add_int32(del_message, tag_buffer[i].type_id);
lo_message_add_string(del_message, tag_buffer[i].uid_str);
lo_bundle_add_message(osc_bundle, "/nfosc/del", del_message);
if (verbose) printf("del %d %d %d %s\n",tag_buffer[i].session_id,tag_buffer[i].symbol_id,tag_buffer[i].type_id,tag_buffer[i].uid_str);
}
lo_timetag frame_time;
lo_timetag_now (&frame_time);
for (int dev=0;dev<no_devices;dev++) {
if (pnd[dev]==NULL) continue;
lo_message frm_message = lo_message_new();
lo_message_add_int32(frm_message, -1);
lo_message_add_timetag(frm_message, frame_time);
lo_message_add_int32(frm_message, 0); // sensor dim
if (device_count>1) sprintf(source_string, "NFOSC:%d",dev);
lo_message_add_string(frm_message, source_string); // source name
lo_bundle_add_message(osc_bundle, "/tuio2/frm", frm_message);
lo_message sid_message = lo_message_new();
lo_bundle_add_message(osc_bundle, "/tuio2/alv", sid_message);
}
int ret = lo_send_bundle(target, osc_bundle);
if(ret == -1) {
fprintf(stderr, "an OSC error occured: %s\n", lo_address_errstr(target));
exit(1);
}
for (int dev=0;dev<no_devices;dev++) {
if (pnd[dev]!=NULL) {
printf("closing NFC reader #%d: %s\n",dev,nfc_device_get_name(pnd[dev]));
nfc_close(pnd[dev]);
}
}
nfc_exit(context);
write_database();
}
std::vector<lo_message> GeometryNode::getState () const
{
// inherit state from base class
std::vector<lo_message> ret = GroupNode::getState();
lo_message msg;
osg::Vec3 v3;
osg::Vec4 v4;
// put this one last:
/*
msg = lo_message_new();
lo_message_add(msg, "sfffffffffff", "setVertices", getVertices());
ret.push_back(msg);
*/
osg::Vec3Array *vArray = dynamic_cast<osg::Vec3Array*>(geometry_->getVertexArray());
for (unsigned int i=0; i<vArray->getNumElements(); i++)
{
//v3 = (*vArray)[i];
msg = lo_message_new();
lo_message_add(msg, "sifff", "setVertex", i, (*vArray)[i].x(), (*vArray)[i].y(), (*vArray)[i].z());
ret.push_back(msg);
}
osg::Vec4Array *cArray = dynamic_cast<osg::Vec4Array*>(geometry_->getColorArray());
for (unsigned int i=0; i<cArray->getNumElements(); i++)
{
msg = lo_message_new();
lo_message_add(msg, "siffff", "setColor", i, (*cArray)[i].x(), (*cArray)[i].y(), (*cArray)[i].z(), (*cArray)[i].w());
ret.push_back(msg);
}
osg::Vec2Array *tArray = dynamic_cast<osg::Vec2Array*>(geometry_->getTexCoordArray(0));
for (unsigned int i=0; i<tArray->getNumElements(); i++)
{
msg = lo_message_new();
lo_message_add(msg, "siff", "setTexCoord", i, (*tArray)[i].x(), (*tArray)[i].y());
ret.push_back(msg);
}
msg = lo_message_new();
lo_message_add(msg, "si", "setSingleSided", getSingleSided());
ret.push_back(msg);
return ret;
}
//================================================================
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 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_controller::_deactivate_cb(const char* path, const char* types,
lo_arg** argv, int argc, lo_message msg)
{
if (!m_restricted || is_target (lo_message_get_source(msg))) {
pair<int,int> net_id(argv[0]->i, argv[1]->i);
map<pair<int,int>, int>::iterator it = m_local_id.find(net_id);
world_node obj;
if (it != m_local_id.end() &&
!(obj = m_world->find_node(it->second)).is_null()) {
m_skip++;
m_world->deactivate_node(obj);
m_skip--;
if (m_broadcast) {
lo_message newmsg = lo_message_new();
lo_message_add_int32(newmsg, argv[0]->i);
lo_message_add_int32(newmsg, argv[1]->i);
broadcast_message_from(PSYNTH_OSC_MSG_DEACTIVATE, newmsg, lo_message_get_source(msg));
lo_message_free(newmsg);
}
}
}
return 0;
}
int osc_controller::_add_cb(const char* path, const char* types,
lo_arg** argv, int argc, lo_message msg)
{
if (!m_restricted || is_target(lo_message_get_source(msg))) {
pair<int,int> net_id(argv[0]->i, argv[1]->i);
m_skip++;
world_node obj = m_world->add_node(std::string(&argv[2]->s));
m_skip--;
if (!obj.is_null()) {
int local_id = obj.get_id ();
m_net_id[local_id] = net_id;
m_local_id[net_id] = local_id;
if (m_broadcast) {
lo_message newmsg = lo_message_new();
lo_message_add_int32(newmsg, argv[0]->i);
lo_message_add_int32(newmsg, argv[1]->i);
lo_message_add_string(newmsg, &argv[2]->s);
broadcast_message_from(PSYNTH_OSC_MSG_ADD, newmsg, lo_message_get_source(msg));
lo_message_free(newmsg);
}
}
}
return 0;
}
bool OscController::sendMessage(const char *path, const char *types, ...)
{
if(path == NULL || types == NULL || transmitAddress_ == NULL)
return false;
va_list ap;
bool ret = false;
char *totalPath = (char *)malloc((strlen(path) + globalPrefix_.length())*sizeof(char));
strcpy(totalPath, globalPrefix_.c_str());
strcat(totalPath, path);
lo_message msg = lo_message_new();
va_start(ap, types);
ret = (lo_message_add_varargs(msg, types, ap) == 0); // Check for success (return of 0)
if(!ret)
cerr << "Error in OscController::sendMessage -- lo_message_add_varargs failed.\n";
else
ret = (lo_send_message(transmitAddress_, totalPath, msg) == 0);
va_end(ap);
lo_message_free(msg);
free(totalPath);
return ret;
}
lo_message make_message(int i, char *s)
{
lo_message msg = lo_message_new();
lo_message_add_int32(msg, i);
lo_message_add_string(msg, s);
return msg;
}
static
int lo_send_varargs_internal(lo_address t, const char *file,
const int line, const char *path,
const char *types, va_list ap)
{
int ret;
lo_message msg = lo_message_new();
t->errnum = 0;
t->errstr = NULL;
ret = lo_message_add_varargs_internal(msg, types, ap, file, line);
if (ret) {
lo_message_free(msg);
t->errnum = ret;
if (ret == -1)
t->errstr = "unknown type";
else
t->errstr = "bad format/args";
return ret;
}
ret = lo_send_message(t, path, msg);
lo_message_free(msg);
return ret;
}
void mapper_monitor_link(mapper_monitor mon,
const char* source_device,
const char* dest_device,
mapper_db_link_t *props,
unsigned int props_flags)
{
if (props && (props_flags & LINK_NUM_SCOPES) && props->num_scopes &&
((props_flags & LINK_SCOPE_NAMES) || (props_flags & LINK_SCOPE_HASHES))) {
lo_message m = lo_message_new();
if (!m)
return;
lo_message_add_string(m, source_device);
lo_message_add_string(m, dest_device);
lo_message_add_string(m, "@scope");
int i;
if (props_flags & LINK_SCOPE_NAMES) {
for (i=0; i<props->num_scopes; i++) {
lo_message_add_string(m, props->scope_names[i]);
}
}
else if (props_flags & LINK_SCOPE_HASHES) {
for (i=0; i<props->num_scopes; i++) {
lo_message_add_int32(m, props->scope_hashes[i]);
}
}
lo_send_message(mon->admin->admin_addr, "/link", m);
free(m);
}
else
mapper_admin_send_osc( mon->admin, 0, "/link", "ss",
source_device, dest_device );
}
lo_message live_play_scene_message_t::createMessage()
{
// pic::logmsg() << "live_play_scene_message_t::createMessage() " << topic() <<"-" << scene_;
lo_message m=lo_message_new();
lo_message_add(m,"i",scene_);
return m;
}
int lo_send(lo_address t, const char *path, const char *types, ...)
#endif
{
va_list ap;
int ret;
#ifndef __GNUC__
const char *file = "";
int line = 0;
#endif
lo_message msg = lo_message_new();
t->errnum = 0;
t->errstr = NULL;
va_start(ap, types);
ret = lo_message_add_varargs_internal(msg, types, ap, file, line);
if (ret) {
lo_message_free(msg);
t->errnum = ret;
if (ret == -1) t->errstr = "unknown type";
else t->errstr = "bad format/args";
return ret;
}
ret = lo_send_message(t, path, msg);
lo_message_free(msg);
return ret;
}
//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);
}
static void sendOsc(const char *s, float *f,int n){
lo_message msg = lo_message_new();
for(int i=0;i<n;i++)
lo_message_add_float(msg,f[i]);
int ret = lo_send_message(lo,s,msg);
lo_message_free(msg);
}
std::vector<lo_message> PointerNode::getState () const
{
// inherit state from base class
std::vector<lo_message> ret = RayNode::getState();
lo_message msg;
msg = lo_message_new();
lo_message_add(msg, "si", "setGrabMode", getGrabMode());
ret.push_back(msg);
/*
msg = lo_message_new();
lo_message_add(msg, "ss", "setType", this->getType());
ret.push_back(msg);
msg = lo_message_new();
lo_message_add(msg, "si", "highlight", this->getHighlight());
ret.push_back(msg);
msg = lo_message_new();
lo_message_add(msg, "si", "manipulate", this->getManipulate());
ret.push_back(msg);
*/
return ret;
}
int lo_send_timestamped(lo_address t, lo_timetag ts,
const char *path, const char *types, ...)
#endif
{
va_list ap;
int ret;
lo_message msg = lo_message_new();
lo_bundle b = lo_bundle_new(ts);
#ifndef __GNUC__
const char *file = "";
int line = 0;
#endif
t->errnum = 0;
t->errstr = NULL;
va_start(ap, types);
ret = lo_message_add_varargs_internal(msg, types, ap, file, line);
if (t->errnum) {
lo_message_free(msg);
return t->errnum;
}
lo_bundle_add_message(b, path, msg);
ret = lo_send_bundle(t, b);
lo_message_free(msg);
lo_bundle_free(b);
return ret;
}
void veejay_bundle_sample_add( void *osc, int id, const char *word, const char *format, ... )
{
char osc_path[256];
oscclient_t *c = (oscclient_t*) osc;
if(!c->bundle)
{
c->bundle = lo_bundle_new( LO_TT_IMMEDIATE );
}
sprintf(osc_path, "/sample_%d/%s", id, word );
lo_message lmsg = lo_message_new();
lo_message_add_string(lmsg, c->window );
lo_message_add_string(lmsg, osc_path );
va_list ap;
if( format )
{
va_start( ap, format );
veejay_add_arguments_( lmsg, format, ap );
va_end(ap);
}
lo_bundle_add_message( c->bundle, "/update/widget", lmsg );
}
static
int lo_send_timestamped_varargs_internal(lo_address t, const char *file,
const int line, lo_timetag ts,
const char *path, const char *types,
va_list ap)
{
int ret;
lo_message msg = lo_message_new();
lo_bundle b = lo_bundle_new(ts);
t->errnum = 0;
t->errstr = NULL;
ret = lo_message_add_varargs_internal(msg, types, ap, file, line);
if (ret == 0) {
lo_bundle_add_message(b, path, msg);
ret = lo_send_bundle(t, b);
}
lo_message_free(msg);
lo_bundle_free(b);
return ret;
}
static
int lo_send_from_varargs_internal(lo_address to, lo_server from,
const char *file,
const int line, lo_timetag ts,
const char *path, const char *types,
va_list ap)
{
lo_bundle b = NULL;
int ret;
lo_message msg = lo_message_new();
if (ts.sec != LO_TT_IMMEDIATE.sec || ts.frac != LO_TT_IMMEDIATE.frac)
b = lo_bundle_new(ts);
// Clear any previous errors
to->errnum = 0;
to->errstr = NULL;
ret = lo_message_add_varargs_internal(msg, types, ap, file, line);
if (ret == 0) {
if (b) {
lo_bundle_add_message(b, path, msg);
ret = lo_send_bundle_from(to, from, b);
} else {
ret = lo_send_message_from(to, from, path, msg);
}
}
// Free-up memory
lo_message_free(msg);
if (b)
lo_bundle_free(b);
return ret;
}
void Client::send( const osc::Message &message )
{
lo_message msg = lo_message_new();
for ( size_t i = 0; i < message.getNumArgs(); i++ )
{
switch ( message.getArgType( i ) )
{
case 'i':
lo_message_add_int32( msg, message.getArg< int32_t >( i ) );
break;
case 'f':
lo_message_add_float( msg, message.getArg< float >( i ) );
break;
case 's':
lo_message_add_string( msg, message.getArg< std::string >( i ).c_str() );
break;
default:
break;
}
}
lo_send_message( mAddress, message.getAddressPattern().c_str(), msg );
lo_message_free( msg );
}
void OscTransmitter::sendMessage(const char * path, const char * type, ...)
{
va_list v;
va_start(v, type);
lo_message msg = lo_message_new();
lo_message_add_varargs(msg, type, v);
/*if(debugMessages_) {
cout << path << " " << type << ": ";
lo_arg **args = lo_message_get_argv(msg);
for(int i = 0; i < lo_message_get_argc(msg); i++) {
switch(type[i]) {
case 'i':
cout << args[i]->i << " ";
break;
case 'f':
cout << args[i]->f << " ";
break;
default:
cout << "? ";
}
}
cout << endl;
//lo_message_pp(msg);
}*/
sendMessage(path, type, msg);
lo_message_free(msg);
va_end(v);
}
lo_message live_arm_message_t::createMessage()
{
//pic::logmsg() << "live_arm_message_t::createMessage() " << topic() << " - " << track_;
lo_message m=lo_message_new();
lo_message_add(m,"i",track_);
lo_message_add(m,"i",(int) armed_); // enable/arm track
return m;
}
lo_message live_clip_info_message_t::createMessage()
{
// pic::logmsg() << "live_clip_info_message_t::createMessage() " << topic() << " - " << track_ << "," << clip_;
lo_message m=lo_message_new();
lo_message_add(m,"i",track_);
lo_message_add(m,"i",clip_);
return m;
}
std::vector<lo_message> GridNode::getState () const
{
// inherit state from base class
std::vector<lo_message> ret = ReferencedNode::getState();
lo_message msg;
msg = lo_message_new();
lo_message_add(msg, "si", "setSize", getSize());
ret.push_back(msg);
msg = lo_message_new();
osg::Vec4 v = this->getColor();
lo_message_add(msg, "sffff", "setColor", v.x(), v.y(), v.z(), v.w());
ret.push_back(msg);
return ret;
}
//=========================================================
void io_simple(char *path)
{
if(io_())
{
lo_message msgio=lo_message_new();
lo_send_message(loio, path, msgio);
lo_message_free(msgio);
}
}
// Generate OSC message with default format
void genOscMsg(lo_bundle *bundle, char *name, int buffIndex) {
if (handMode || posConfidence >= 0.5f)
{
lo_message msg = lo_message_new();
lo_message_add_string(msg, name);
if (!kitchenMode)
lo_message_add_int32(msg, userID);
for (int i = 0; i < nDimensions; i++)
lo_message_add_float(msg, jointCoords[i]);
lo_bundle_add_message(*bundle, "/joint", msg);
}
if (!kitchenMode && sendOrient && orientConfidence >= 0.5f)
{
lo_message msg = lo_message_new();
lo_message_add_string(msg, name);
if (!kitchenMode)
lo_message_add_int32(msg, userID);
// x data is in first column
lo_message_add_float(msg, jointOrients[0]);
lo_message_add_float(msg, jointOrients[0+3]);
lo_message_add_float(msg, jointOrients[0+6]);
// y data is in 2nd column
lo_message_add_float(msg, jointOrients[1]);
lo_message_add_float(msg, jointOrients[1+3]);
lo_message_add_float(msg, jointOrients[1+6]);
// z data is in 3rd column
lo_message_add_float(msg, jointOrients[2]);
lo_message_add_float(msg, jointOrients[2+3]);
lo_message_add_float(msg, jointOrients[2+6]);
lo_bundle_add_message(*bundle, "/orient", msg);
}
}
//=========================================================
void io_quit(char *token)
{
if(io_())
{
lo_message msgio=lo_message_new();
lo_message_add_string(msgio,token);
lo_send_message(loio, "/quit", msgio);
lo_message_free(msgio);
}
}
lo_message live_selection_message_t::createMessage()
{
// pic::logmsg() << "live_selection_message_t::createMessage() " << topic() << " - " << track_ << "," << clip_ << "," << width_ << "," << height_;
lo_message m=lo_message_new();
lo_message_add(m,"i",(int) track_);
lo_message_add(m,"i",(int) clip_);
lo_message_add(m,"i",(int) width_);
lo_message_add(m,"i",(int) height_);
return m;
}
void OscSender::sendMessage(const std::string &OSCpath, const char *types, va_list ap) const
{
lo_message msg = lo_message_new();
int err = lo_message_add_varargs(msg, types, ap);
if (!err)
sendMessage(OSCpath, msg);
else
std::cout << "ERROR (OscSender::sendMessage): " << err << std::endl;
}