// static int vrpn_Mutex_Server::handle_requestMutex(void *userdata, vrpn_HANDLERPARAM p) { vrpn_Mutex_Server *me = (vrpn_Mutex_Server *)userdata; const char *b = p.buffer; vrpn_int32 remoteId; vrpn_unbuffer(&b, &remoteId); #ifdef VERBOSE fprintf(stderr, "vrpn_Mutex_Server::handle_request from %d.\n", remoteId); #endif if (me->d_state == FREE) { me->d_state = HELD; // BUG BUG BUG - how does the Mutex_Remote recognize that this grant // is for it, not for some other? me->sendGrantRequest(remoteId); return 0; } else { me->sendDenyRequest(remoteId); return 0; } }
int vrpn_Dial_Remote::handle_change_message(void *userdata, vrpn_HANDLERPARAM p) { vrpn_Dial_Remote *me = (vrpn_Dial_Remote *)userdata; vrpn_DIALCB cp; const char *bufptr = p.buffer; cp.msg_time = p.msg_time; vrpn_unbuffer(&bufptr, &cp.change); vrpn_unbuffer(&bufptr, &cp.dial); // Go down the list of callbacks that have been registered. // Fill in the parameter and call each. me->d_callback_list.call_handlers(cp); return 0; }
vrpn_int32 vrpn_Sound::decodeListenerVelocity(const char* buf, vrpn_float64 *velocity) { const char *mptr = buf; for (int i=0;i<4;i++) vrpn_unbuffer(&mptr, &velocity[i]); return 0; }
// If the client requests a value for the focus control, then try to set the // focus to the requested value. int vrpn_Nikon_Controls::handle_request_message(void *userdata, vrpn_HANDLERPARAM p) { const char *bufptr = p.buffer; vrpn_int32 chan_num; vrpn_int32 pad; vrpn_float64 value; vrpn_Nikon_Controls *me = (vrpn_Nikon_Controls *)userdata; // Read the parameters from the buffer vrpn_unbuffer(&bufptr, &chan_num); vrpn_unbuffer(&bufptr, &pad); vrpn_unbuffer(&bufptr, &value); // Set the position to the appropriate value, if the channel number is in the me->set_channel(chan_num, value); return 0; }
void vrpn_Shared_int32::decodeLamport (const char ** buffer, vrpn_int32 *, vrpn_int32 * newValue, timeval * when, vrpn_LamportTimestamp ** t) const { vrpn_uint32 size; vrpn_uint32 * array; unsigned int i; vrpn_unbuffer(buffer, newValue); vrpn_unbuffer(buffer, when); vrpn_unbuffer(buffer, &size); array = new vrpn_uint32 [size]; for (i = 0; i < size; i++) { vrpn_unbuffer(buffer, &array[i]); } *t = new vrpn_LamportTimestamp(size, array); delete array; }
//Decodes the client sound ID vrpn_int32 vrpn_Sound::decodeSoundID(const char* buf, vrpn_SoundID *id) { const char* mptr = buf; vrpn_unbuffer(&mptr, id); return 0; }
int vrpn_BaseClassUnique::decode_text_message_from_buffer (char *msg, vrpn_TEXT_SEVERITY *severity, vrpn_uint32 *level, const char *buf) { const char *bufptr = buf; vrpn_uint32 severity_as_uint; // Read the type, level and message vrpn_unbuffer( &bufptr, &severity_as_uint ); *severity = (vrpn_TEXT_SEVERITY)(severity_as_uint); vrpn_unbuffer( &bufptr, level ); // Negative length means "unpack until NULL" if (vrpn_unbuffer( &bufptr, msg, -(int)(vrpn_MAX_TEXT_LEN)) != 0) { return -1; } return 0; }
vrpn_int32 vrpn_Sound::decodeLoadModel_local(const char *buf, char **filename, const int payload) { const char *mptr = buf; *filename = new char[payload - sizeof(vrpn_SoundID)]; vrpn_unbuffer(&mptr, *filename, payload - sizeof(vrpn_SoundID)); return 0; }
int vrpn_Poser_Server::handle_change_message(void* userdata, vrpn_HANDLERPARAM p) { vrpn_Poser_Server* me = (vrpn_Poser_Server *)userdata; const char* params = (p.buffer); int i; vrpn_POSERCB cp; // Fill in the parameters to the poser from the message if (p.payload_len != (7 * sizeof(vrpn_float64)) ) { fprintf(stderr,"vrpn_Poser_Server: change message payload error\n"); fprintf(stderr," (got %d, expected %d)\n", p.payload_len, 7 * sizeof(vrpn_float64) ); return -1; } me->p_timestamp = p.msg_time; for (i = 0; i < 3; i++) { vrpn_unbuffer(¶ms, &me->p_pos[i]); } for (i = 0; i < 4; i++) { vrpn_unbuffer(¶ms, &me->p_quat[i]); } // Check the pose against the max and min values of the workspace for (i = 0; i < 3; i++) { if (me->p_pos[i] < me->p_pos_min[i]) { me->p_pos[i] = me->p_pos_min[i]; } else if (me->p_pos[i] > me->p_pos_max[i]) { me->p_pos[i] = me->p_pos_max[i]; } } ///Now pack the information in a way that user-routine will understand cp.msg_time = me->p_timestamp; memcpy(cp.pos,me->p_pos, sizeof(cp.pos)); memcpy(cp.quat,me->p_quat, sizeof(cp.quat)); // Go down the list of callbacks that have been registered. // Fill in the parameter and call each. me->d_callback_list.call_handlers(cp); return 0; }
int vrpn_Poser_Server::handle_relative_vel_change_message(void* userdata, vrpn_HANDLERPARAM p) { vrpn_Poser_Server* me = (vrpn_Poser_Server*)userdata; const char* params = (p.buffer); int i; // Fill in the parameters to the poser from the message if (p.payload_len != (8 * sizeof(vrpn_float64)) ) { fprintf(stderr,"vrpn_Poser_Server: velocity message payload error\n"); fprintf(stderr," (got %d, expected %d)\n", p.payload_len, 8 * sizeof(vrpn_float64) ); return -1; } me->p_timestamp = p.msg_time; vrpn_float64 dv[3], dq[4], di; for (i = 0; i < 3; i++) { vrpn_unbuffer( ¶ms, &(dv[i]) ); } for (i = 0; i < 4; i++) { vrpn_unbuffer( ¶ms, &(dq[i]) ); } vrpn_unbuffer(¶ms, &di); // apply the requested changes for( i = 0; i < 2; i++ ) me->p_vel[i] += dv[i]; q_mult( me->p_quat, dq, me->p_quat ); me->p_vel_quat_dt += di; // Check the velocity against the max and min values of the workspace for (i = 0; i < 3; i++) { if (me->p_vel[i] < me->p_vel_min[i]) { me->p_vel[i] = me->p_vel_min[i]; } else if (me->p_vel[i] > me->p_vel_max[i]) { me->p_vel[i] = me->p_vel_max[i]; } } return 0; }
int vrpn_Tracker_PhaseSpace::handle_update_rate_request(void *userdata, vrpn_HANDLERPARAM p) { #ifdef DEBUG printf("%s\n", __PRETTY_FUNCTION__); #endif vrpn_Tracker_PhaseSpace* thistracker = (vrpn_Tracker_PhaseSpace*)userdata; vrpn_float64 update_rate = 0; vrpn_unbuffer(&p.buffer,&update_rate); thistracker->setFrequency((float) update_rate); return 0; }
static int VRPN_CALLBACK client_msg_handler(void *userdata, vrpn_HANDLERPARAM p) { vrpn_Button_Filter * instance = (vrpn_Button_Filter *) userdata; const char *bufptr = p.buffer; vrpn_int32 event; vrpn_int32 buttonid; vrpn_unbuffer(&bufptr, &buttonid); vrpn_unbuffer(&bufptr, &event); if (event== vrpn_BUTTON_MOMENTARY) { if (buttonid == vrpn_ALL_ID) instance->set_all_momentary(); else instance->set_momentary(buttonid); }else if (event== vrpn_BUTTON_TOGGLE_OFF || event==vrpn_BUTTON_TOGGLE_ON ){ if (buttonid == vrpn_ALL_ID) instance->set_all_toggle(event); else instance->set_toggle(buttonid,event); } return 0; }
int vrpn_Tracker_PhaseSpace::handle_update_rate_request(void *userdata, vrpn_HANDLERPARAM p) { vrpn_Tracker_PhaseSpace* thistracker = (vrpn_Tracker_PhaseSpace*)userdata; if(thistracker->debug) { printf("[debug] vrpn_Tracker_PhaseSpace::handle_update_rate_request\n"); } vrpn_float64 update_rate = 0; vrpn_unbuffer(&p.buffer,&update_rate); thistracker->context.frequency((float) update_rate); return 0; }
// Static callback int VRPN_CALLBACK vrpn_XInputGamepad::handle_request_channels_message(void *selfPtr, vrpn_HANDLERPARAM data) { const char *bufptr = data.buffer; vrpn_int32 chan_num; vrpn_int32 pad; vrpn_XInputGamepad *me = (vrpn_XInputGamepad *) selfPtr; int i; // Read the parameters from the buffer vrpn_unbuffer(&bufptr, &chan_num); vrpn_unbuffer(&bufptr, &pad); if (chan_num > me->o_num_channel) { char msg[1024]; sprintf( msg, "Error: (handle_request_channels_message): channels above %d not active; " "bad request up to channel %d. Squelching.", me->o_num_channel, chan_num ); me->send_text_message( msg, data.msg_time, vrpn_TEXT_ERROR ); chan_num = me->o_num_channel; } if (chan_num < 0) { char msg[1024]; sprintf( msg, "Error: (handle_request_channels_message): invalid channel %d. Squelching.", chan_num ); me->send_text_message( msg, data.msg_time, vrpn_TEXT_ERROR ); return 0; } for (i = 0; i < chan_num; i++) { vrpn_float64 value; vrpn_unbuffer(&bufptr, &value); float magnitude = static_cast<float>(value); magnitude = (magnitude < 0) ? 0 : (magnitude > 1) ? 1 : magnitude; me->_motorSpeed[chan_num] = static_cast<WORD>(magnitude * 65535); } me->update_vibration(); return 0; }
int vrpn_Analog_Remote::handle_change_message(void *userdata, vrpn_HANDLERPARAM p) { const char* bufptr = p.buffer; vrpn_float64 numchannelD; //< Number of channels passed in a double (yuck!) vrpn_Analog_Remote* me = (vrpn_Analog_Remote* )userdata; vrpn_ANALOGCB cp; cp.msg_time = p.msg_time; vrpn_unbuffer(&bufptr, &numchannelD); cp.num_channel = (long)numchannelD; me->num_channel = cp.num_channel; for (vrpn_int32 i=0; i< cp.num_channel; i++) { vrpn_unbuffer(&bufptr, &cp.channel[i]); } // Go down the list of callbacks that have been registered. // Fill in the parameter and call each. me->d_callback_list.call_handlers(cp); return 0; }
/* static */ int vrpn_WiiMote::handle_request_channels_message(void* userdata, vrpn_HANDLERPARAM p) { const char* bufptr = p.buffer; vrpn_int32 num; vrpn_int32 pad; vrpn_WiiMote* me = (vrpn_WiiMote*)userdata; // Read the values from the buffer vrpn_unbuffer(&bufptr, &num); vrpn_unbuffer(&bufptr, &pad); if (num > me->o_num_channel) { char msg[1024]; sprintf( msg, "Error: (handle_request_channels_message): channels above %d not active; " "bad request up to channel %d. Squelching.", me->o_num_channel, num ); me->send_text_message( msg, p.msg_time, vrpn_TEXT_ERROR ); num = me->o_num_channel; } if (num < 0) { char msg[1024]; sprintf( msg, "Error: (handle_request_channels_message): invalid channel %d. Squelching.", num ); me->send_text_message( msg, p.msg_time, vrpn_TEXT_ERROR ); return 0; } // Pull only channel 0 from the buffer, no matter how many values we received. vrpn_float64 value; vrpn_unbuffer(&bufptr, &value); if (value >= 0.5) { wiiuse_rumble(me->wiimote->device, 1); } else { wiiuse_rumble(me->wiimote->device, 0); } return 0; }
// Handles a throttle request by passing it on down to the non-blocking // thread to deal with. int vrpn_Imager_Stream_Buffer::static_handle_throttle_message( void *userdata, vrpn_HANDLERPARAM p) { const char *bufptr = p.buffer; vrpn_Imager_Stream_Buffer *me = static_cast<vrpn_Imager_Stream_Buffer *>(userdata); // Get the requested number of frames from the buffer vrpn_int32 frames_to_send; if (vrpn_unbuffer(&bufptr, &frames_to_send)) { return -1; } me->d_shared_state.set_throttle_request(frames_to_send); return 0; }
vrpn_int32 vrpn_Sound::decodeLoadMaterial(const char* buf, vrpn_MaterialDef * material, vrpn_int32 *id) { const char *mptr = buf; vrpn_unbuffer(&mptr, id); vrpn_unbuffer(&mptr, material->material_name, MAX_MATERIAL_NAME_LENGTH); vrpn_unbuffer(&mptr, &material->transmittance_gain); vrpn_unbuffer(&mptr, &material->transmittance_highfreq); vrpn_unbuffer(&mptr, &material->reflectance_gain); vrpn_unbuffer(&mptr, &material->reflectance_highfreq); return 0; }
/* static */ int vrpn_Analog_Output_Remote::handle_report_num_channels( void *userdata, vrpn_HANDLERPARAM p ) { const char* bufptr = p.buffer; vrpn_int32 num; vrpn_Analog_Output_Remote* me = (vrpn_Analog_Output_Remote*)userdata; // Read the parameters from the buffer vrpn_unbuffer(&bufptr, &num); if( num >=0 && num <= vrpn_CHANNEL_MAX ) { me->o_num_channel = num; } else { fprintf( stderr, "vrpn_Analog_Output_Remote::handle_report_num_channels_message: " "Someone sent us a bogus number of channels: %d.\n", num ); } return 0; }
// static int vrpn_Mutex_Remote::handle_denyRequest(void *userdata, vrpn_HANDLERPARAM p) { vrpn_Mutex_Remote *me = (vrpn_Mutex_Remote *)userdata; const char *b = p.buffer; vrpn_int32 index; vrpn_unbuffer(&b, &index); #ifdef VERBOSE fprintf(stderr, "vrpn_Mutex_Remote::handle_denyRequest for %d.\n", index); #endif if (me->d_myIndex != index) { return 0; } me->d_state = HELD_REMOTELY; me->triggerDenyCallbacks(); return 0; }
void vrpn_RedundantController_Protocol::decode_set (const char ** buf, vrpn_uint32 * num, timeval * interval) { vrpn_unbuffer(buf, num); vrpn_unbuffer(buf, interval); }
int vrpn_Poser_Analog::handle_vel_change_message(void* userdata, vrpn_HANDLERPARAM p) { vrpn_Poser_Analog* me = (vrpn_Poser_Analog*)userdata; const char* params = (p.buffer); int i; bool outside_bounds = false; // Fill in the parameters to the poser from the message if (p.payload_len != (8 * sizeof(vrpn_float64)) ) { fprintf(stderr,"vrpn_Poser_Server: velocity message payload error\n"); fprintf(stderr," (got %d, expected %d)\n", p.payload_len, 8 * sizeof(vrpn_float64) ); return -1; } me->p_timestamp = p.msg_time; for (i = 0; i < 3; i++) { vrpn_unbuffer(¶ms, &me->p_vel[i]); } for (i = 0; i < 4; i++) { vrpn_unbuffer(¶ms, &me->p_vel_quat[i]); } vrpn_unbuffer(¶ms, &me->p_vel_quat_dt); // Check the velocity against the max and min values of the workspace for (i = 0; i < 3; i++) { if (me->p_vel[i] < me->p_vel_min[i]) { me->p_vel[i] = me->p_vel_min[i]; outside_bounds = true; } else if (me->p_vel[i] > me->p_vel_max[i]) { me->p_vel[i] = me->p_vel_max[i]; outside_bounds = true; } } // XXX Update the values now. if (me->d_act_as_tracker) { // Tell the client where we actually went (clipped position and orientation). // using sensor 0 as the one to use to report. me->d_sensor = 0; me->vel[0] = me->p_vel[0]; me->vel[1] = me->p_vel[1]; me->vel[2] = me->p_vel[2]; me->vel_quat[0] = me->p_vel_quat[0]; me->vel_quat[1] = me->p_vel_quat[1]; me->vel_quat[2] = me->p_vel_quat[2]; me->vel_quat[3] = me->p_vel_quat[3]; vrpn_gettimeofday(&me->vrpn_Tracker::timestamp, NULL); char msgbuf[1000]; vrpn_int32 len; len = me->vrpn_Tracker::encode_vel_to(msgbuf); if (me->d_connection->pack_message(len, me->vrpn_Tracker::timestamp, me->velocity_m_id, me->d_sender_id, msgbuf, vrpn_CONNECTION_LOW_LATENCY)) { fprintf(stderr,"vrpn_Poser_Analog::handle_vel_change_message(): can't write message: tossing\n"); return -1; } } return 0; }
void vrpn_Tracker_Crossbow::reset() { const char *cmd; unsigned char recv_buf[8]; struct timeval timeout; timeout.tv_sec = 1; timeout.tv_usec = 0; #if 0 // doesn't help // First, take the comm port offline for a second vrpn_close_commport(serial_fd); vrpn_SleepMsecs(1000); serial_fd = vrpn_open_commport(portname, baudrate); #endif vrpn_flush_output_buffer(serial_fd); vrpn_flush_input_buffer(serial_fd); // Try resetting by toggling the RTS line of the serial port vrpn_set_rts(serial_fd); vrpn_SleepMsecs(750); vrpn_clear_rts(serial_fd); vrpn_SleepMsecs(250); vrpn_gettimeofday(×tamp, NULL); vrpn_flush_input_buffer(serial_fd); cmd = "P"; vrpn_write_characters(serial_fd, reinterpret_cast<const unsigned char*> (cmd), 1); vrpn_SleepMsecs(50); // Sleep long enough to stop receiving data vrpn_flush_input_buffer(serial_fd); cmd = "RSv"; vrpn_write_characters(serial_fd, reinterpret_cast<const unsigned char*> (cmd), 3); vrpn_drain_output_buffer(serial_fd); if (vrpn_read_available_characters(serial_fd, recv_buf, 8, &timeout) != 8) { fprintf(stderr, "vrpn_Tracker_Crossbow::reset: Crossbow not responding to stimulus\n"); status = vrpn_TRACKER_FAIL; return; } if ((recv_buf[0] != 'H') || (recv_buf[1] != 255) || (recv_buf[7] != 255)) { fprintf(stderr, "vrpn_Tracker_Crossbow::reset: Crossbow gave unexpected ping response\n"); status = vrpn_TRACKER_FAIL; return; } if (recv_buf[6] != ((recv_buf[2] + recv_buf[3] + recv_buf[4] + recv_buf[5]) & 0xFF)) { fprintf(stderr, "vrpn_Tracker_Crossbow::reset: Crossbow gave invalid serial number checksum\n"); status = vrpn_TRACKER_FAIL; return; } const char *bufptr = reinterpret_cast<const char *>(&recv_buf[2]); vrpn_unbuffer(&bufptr, &device_serial); if (0) do { if (!vrpn_read_available_characters(serial_fd, recv_buf, 1, &timeout)) { fprintf(stderr, "vrpn_Tracker_Crossbow::reset: Crossbow not responding to stimulus\n"); status = vrpn_TRACKER_FAIL; return; } } while (*recv_buf != 255); int curSize = 4, curLen = 0; device_version = (char *) realloc(device_version, curSize * sizeof(char)); if (device_version == NULL) { fprintf(stderr, "vrpn_Tracker_Crossbow::reset: Out of memory\n"); status = vrpn_TRACKER_FAIL; return; } do { if (!vrpn_read_available_characters(serial_fd, recv_buf, 1, &timeout)) { fprintf(stderr, "vrpn_Tracker_Crossbow::reset: Crossbow not responding to stimulus\n"); status = vrpn_TRACKER_FAIL; return; } if (*recv_buf != '$') device_version[curLen++] = *recv_buf; if (curLen == curSize) device_version = (char *) realloc(device_version, curSize *= 2); } while (*recv_buf != '$'); // Now null-terminate the version string, expanding it one last time if necessary if (curLen == curSize) device_version = (char *) realloc(device_version, ++curSize); device_version[curLen] = 0; //printf("Serial %u\tVersion '%s'\n", device_serial, device_version); just_read_something = 0; status = vrpn_TRACKER_SYNCING; }
void vrpn_Shared_int32::decode (const char ** buffer, vrpn_int32 *, vrpn_int32 * newValue, timeval * when) const { vrpn_unbuffer(buffer, newValue); vrpn_unbuffer(buffer, when); }
void vrpn_Shared_String::decode (const char ** buffer, vrpn_int32 * len, char * newValue, timeval * when) const { vrpn_unbuffer(buffer, when); vrpn_unbuffer(buffer, newValue, *len - sizeof(*when)); newValue[*len - sizeof(*when)] = 0; }
// Retrieves a raw_packet from an incoming byte array, and even flips endianness as necessary. void vrpn_Tracker_Crossbow::unbuffer_packet(raw_packet &dest, unsigned char *buffer) { vrpn_unbuffer(&buffer, &dest.header); vrpn_unbuffer(&buffer, &dest.roll_angle); vrpn_unbuffer(&buffer, &dest.pitch_angle); vrpn_unbuffer(&buffer, &dest.yaw_rate); vrpn_unbuffer(&buffer, &dest.accel_x); vrpn_unbuffer(&buffer, &dest.accel_y); vrpn_unbuffer(&buffer, &dest.accel_z); vrpn_unbuffer(&buffer, &dest.timer); vrpn_unbuffer(&buffer, &dest.temp_voltage); vrpn_unbuffer(&buffer, &dest.part_number); vrpn_unbuffer(&buffer, &dest.status); vrpn_unbuffer(&buffer, &dest.checksum); }
int VRPN_AciCommand_transport_base::decode_AciCommand_from( AciCommand &cmd , const char *buf , size_t buflen ) { //-------------------------------------------------------------------- // Get the parameters for the command from the buffer. // *** Need to pack/unpack them in an order that will make them // aligned correctly. // *** This needs to match the encoding routine. const char *bufptr = buf; if (buflen < sizeof(cmd.slot)) { fprintf(stderr,"VRPN_AciCommand_transport_base::decode_AciCommand_from(): Not enough data\n"); return -1; } if (vrpn_unbuffer(&bufptr, &(cmd.slot))) { fprintf(stderr,"VRPN_AciCommand_transport_base::decode_AciCommand_from(): Can't unbuffer slot\n"); return -1; } if (buflen < sizeof(cmd.code)) { fprintf(stderr,"VRPN_AciCommand_transport_base::decode_AciCommand_from(): Not enough data\n"); return -1; } if (vrpn_unbuffer(&bufptr, &(cmd.code))) { fprintf(stderr,"VRPN_AciCommand_transport_base::decode_AciCommand_from(): Can't unbuffer code\n"); return -1; } if (buflen < sizeof(cmd.rc)) { fprintf(stderr,"VRPN_AciCommand_transport_base::decode_AciCommand_from(): Not enough data\n"); return -1; } if (vrpn_unbuffer(&bufptr, &(cmd.rc))) { fprintf(stderr,"VRPN_AciCommand_transport_base::decode_AciCommand_from(): Can't unbuffer rc\n"); return -1; } if ( (cmd.code >= MIN_CMD_DIRECTIVE) && (cmd.code <= MAX_CMD_DIRECTIVE) ) { // Nothing to do here -- there is no data for this type of command. } else if ( (cmd.code >= MIN_CMD_VALUE) && (cmd.code <= MAX_CMD_VALUE) ) { if (buflen < sizeof(cmd.data.value)) { fprintf(stderr,"VRPN_AciCommand_transport_base::decode_AciCommand_from(): Not enough data\n"); return -1; } if (vrpn_unbuffer(&bufptr, &(cmd.data.value))) { fprintf(stderr,"VRPN_AciCommand_transport_base::decode_AciCommand_from(): Can't unbuffer value\n"); return -1; } } else if ( (cmd.code >= MIN_CMD_KEY) && (cmd.code <= MAX_CMD_KEY) ) { if (buflen < sizeof(cmd.data.keyValue.key)) { fprintf(stderr,"VRPN_AciCommand_transport_base::decode_AciCommand_from(): Not enough data\n"); return -1; } if (vrpn_unbuffer(&bufptr, &(cmd.data.keyValue.key))) { fprintf(stderr,"VRPN_AciCommand_transport_base::decode_AciCommand_from(): Can't unbuffer key\n"); return -1; } if (buflen < sizeof(cmd.data.keyValue.value)) { fprintf(stderr,"VRPN_AciCommand_transport_base::decode_AciCommand_from(): Not enough data\n"); return -1; } if (vrpn_unbuffer(&bufptr, &(cmd.data.keyValue.value))) { fprintf(stderr,"VRPN_AciCommand_transport_base::decode_AciCommand_from(): Can't unbuffer count\n"); return -1; } } else if (cmd.code == CMD_LOCK) { if (buflen < sizeof(cmd.data.lock.guid)) { fprintf(stderr,"VRPN_AciCommand_transport_base::decode_AciCommand_from(): Not enough data\n"); return -1; } if (vrpn_unbuffer(&bufptr, &(cmd.data.lock.guid))) { fprintf(stderr,"VRPN_AciCommand_transport_base::decode_AciCommand_from(): Can't unbuffer guid\n"); return -1; } if (buflen < sizeof(cmd.data.lock.age)) { fprintf(stderr,"VRPN_AciCommand_transport_base::decode_AciCommand_from(): Not enough data\n"); return -1; } if (vrpn_unbuffer(&bufptr, &(cmd.data.lock.age))) { fprintf(stderr,"VRPN_AciCommand_transport_base::decode_AciCommand_from(): Can't unbuffer age\n"); return -1; } } else { fprintf(stderr,"VRPN_AciCommand_transport_base::handle_request_message(): Unrecognized command (%d)\n", cmd.code); return -1; } // Return the number of bytes read. return static_cast<int>(bufptr - buf); }
void vrpn_RedundantController_Protocol::decode_enable(const char **buf, vrpn_bool *on) { vrpn_unbuffer(buf, on); }
vrpn_int32 vrpn_Sound::decodeSoundDef(const char* buf, vrpn_SoundDef *sound, vrpn_SoundID *id, vrpn_int32 *repeat) { const char *mptr = buf; int i; vrpn_unbuffer(&mptr, repeat); vrpn_unbuffer(&mptr, id); for(i = 0; i < 3; i++) vrpn_unbuffer(&mptr, &(sound->pose.position[i])); for(i = 0; i < 4; i++) vrpn_unbuffer(&mptr, &(sound->pose.orientation[i])); for(i = 0; i < 4; i++) vrpn_unbuffer(&mptr, &(sound->velocity[i])); vrpn_unbuffer(&mptr, &(sound->volume)); vrpn_unbuffer(&mptr, &(sound->max_back_dist)); vrpn_unbuffer(&mptr, &(sound->min_back_dist)); vrpn_unbuffer(&mptr, &(sound->max_front_dist)); vrpn_unbuffer(&mptr, &(sound->min_front_dist)); vrpn_unbuffer(&mptr, &(sound->cone_inner_angle)); vrpn_unbuffer(&mptr, &(sound->cone_outer_angle)); vrpn_unbuffer(&mptr, &(sound->cone_gain)); vrpn_unbuffer(&mptr, &(sound->dopler_scale)); vrpn_unbuffer(&mptr, &(sound->equalization_val)); vrpn_unbuffer(&mptr, &(sound->pitch)); return 0; }
//Decodes the file and Client Index number vrpn_int32 vrpn_Sound::decodeSound_local(const char *buf, char **filename, vrpn_SoundID *id, vrpn_SoundDef * sound, const int payload) { const char *mptr = buf; int i; *filename = new char[payload - sizeof(vrpn_SoundID)- sizeof(vrpn_SoundDef)]; vrpn_unbuffer(&mptr, id); for(i = 0; i < 3; i++) vrpn_unbuffer(&mptr, &(sound->pose.position[i])); for(i = 0; i < 4; i++) vrpn_unbuffer(&mptr, &(sound->pose.orientation[i])); for(i = 0; i < 4; i++) vrpn_unbuffer(&mptr, &(sound->velocity[i])); vrpn_unbuffer(&mptr, &(sound->volume)); vrpn_unbuffer(&mptr, &(sound->max_back_dist)); vrpn_unbuffer(&mptr, &(sound->min_back_dist)); vrpn_unbuffer(&mptr, &(sound->max_front_dist)); vrpn_unbuffer(&mptr, &(sound->min_front_dist)); vrpn_unbuffer(&mptr, &(sound->cone_inner_angle)); vrpn_unbuffer(&mptr, &(sound->cone_outer_angle)); vrpn_unbuffer(&mptr, &(sound->cone_gain)); vrpn_unbuffer(&mptr, &(sound->dopler_scale)); vrpn_unbuffer(&mptr, &(sound->equalization_val)); vrpn_unbuffer(&mptr, &(sound->pitch)); vrpn_unbuffer(&mptr, *filename, payload - sizeof(vrpn_SoundID)- sizeof(vrpn_SoundDef)); return 0; }