vrpn 07.35
Virtual Reality Peripheral Network
Loading...
Searching...
No Matches
vrpn_FunctionGenerator.C
Go to the documentation of this file.
1
2#include <stdio.h> // for fflush, fprintf, stderr
3#include <string.h> // for NULL, strlen, strcpy
4
6
7//#define DEBUG_VRPN_FUNCTION_GENERATOR
8
9const char* vrpn_FUNCTION_MESSAGE_TYPE_CHANNEL = "vrpn_FunctionGenerator channel";
10const char* vrpn_FUNCTION_MESSAGE_TYPE_CHANNEL_REQUEST = "vrpn_FunctionGenerator channel request";
11const char* vrpn_FUNCTION_MESSAGE_TYPE_ALL_CHANNEL_REQUEST = "vrpn_FunctionGenerator all channel request";
12const char* vrpn_FUNCTION_MESSAGE_TYPE_SAMPLE_RATE = "vrpn_FunctionGenerator sample rate";
13const char* vrpn_FUNCTION_MESSAGE_TYPE_START = "vrpn_FunctionGenerator start";
14const char* vrpn_FUNCTION_MESSAGE_TYPE_STOP = "vrpn_FunctionGenerator stop";
15const char* vrpn_FUNCTION_MESSAGE_TYPE_CHANNEL_REPLY = "vrpn_FunctionGenerator channel reply";
16const char* vrpn_FUNCTION_MESSAGE_TYPE_START_REPLY = "vrpn_FunctionGenerator start reply";
17const char* vrpn_FUNCTION_MESSAGE_TYPE_STOP_REPLY = "vrpn_FunctionGenerator stop reply";
18const char* vrpn_FUNCTION_MESSAGE_TYPE_SAMPLE_RATE_REPLY = "vrpn_FunctionGenerator sample rate reply";
19const char* vrpn_FUNCTION_MESSAGE_TYPE_INTERPRETER_REQUEST = "vrpn_FunctionGenerator interpreter-description request";
20const char* vrpn_FUNCTION_MESSAGE_TYPE_INTERPRETER_REPLY = "vrpn_FunctionGenerator interpreter-description reply";
21const char* vrpn_FUNCTION_MESSAGE_TYPE_ERROR = "vrpn_FunctionGenerator error report";
22
24
27//
28// class vrpn_FunctionGenerator_function_NULL
29
31generateValues( vrpn_float32* buf, vrpn_uint32 nValues,
32 vrpn_float32 startTime, vrpn_float32 sampleRate,
34{
35 for( vrpn_uint32 i = 0; i <= nValues - 1; i++ )
36 {
37 buf[i] = 0;
38 }
39 return startTime + nValues / sampleRate;
40}
41
42
44encode_to( char** , vrpn_int32& ) const
45{
46 return 0;
47}
48
49
51decode_from( const char** , vrpn_int32& )
52{
53 return 0;
54}
55
57clone( ) const
58{
60 try { ret = new vrpn_FunctionGenerator_function_NULL(); }
61 catch (...) { return NULL; }
62 return ret;
63}
64
65
66//
67// end vrpn_FunctionGenerator_function_NULL
70
71
74//
75// class vrpn_FunctionGenerator_function_script
78: script( NULL )
79{
80 try {
81 this->script = new char[1];
82 script[0] = '\0';
83 } catch (...) {}
84}
85
86
89 : script( NULL )
90{
91 try {
92 this->script = new char[strlen(script) + 1];
93 strcpy(this->script, script);
94 } catch (...) {}
95}
96
97
100 : script(NULL)
101{
102 try {
103 this->script = new char[strlen(s.script) + 1];
104 strcpy(this->script, s.script);
105 } catch (...) {}
106}
107
108
110{
111 if( script != NULL ) {
112 try {
113 delete[] script;
114 } catch (...) {
115 fprintf(stderr, "vrpn_FunctionGenerator_function_script::~vrpn_FunctionGenerator_function_script(): delete failed\n");
116 return;
117 }
118 script = NULL;
119 }
120}
121
123generateValues( vrpn_float32* buf, vrpn_uint32 nValues, vrpn_float32 startTime,
124 vrpn_float32 sampleRate, vrpn_FunctionGenerator_channel* /*channel*/ ) const
125{
126 for( vrpn_uint32 i = 0; i <= nValues - 1; i++ )
127 {
128 buf[i] = 0;
129 }
130 return startTime + nValues / sampleRate;
131};
132
133
135encode_to( char** buf, vrpn_int32& len ) const
136{
137 vrpn_uint32 length = static_cast<vrpn_uint32>(strlen( this->script ));
138 vrpn_int32 bytes = length + sizeof( vrpn_uint32 );
139 if( len < bytes )
140 {
141 fprintf( stderr, "vrpn_FunctionGenerator_function_script::encode_to: "
142 "payload error (wanted %d got %d).\n", bytes, len );
143 fflush( stderr );
144 return -1;
145 }
146 if( 0 > vrpn_buffer( buf, &len, length ) )
147 {
148 fprintf( stderr, "vrpn_FunctionGenerator_function_script::encode_to: "
149 "payload error (couldn't buffer length).\n" );
150 fflush( stderr );
151 return -1;
152 }
153 if( 0 > vrpn_buffer( buf, &len, this->script, length ) )
154 {
155 fprintf( stderr, "vrpn_FunctionGenerator_function_script::encode_to: "
156 "payload error (couldn't buffer script).\n" );
157 fflush( stderr );
158 return -1;
159 }
160 return bytes;
161}
162
163
165decode_from( const char** buf, vrpn_int32& len )
166{
167 vrpn_int32 newlen;
168 if( 0 > vrpn_unbuffer( buf, &newlen ) )
169 {
170 fprintf( stderr, "vrpn_FunctionGenerator_function_script::decode_from: "
171 "payload error (couldn't unbuffer length).\n" );
172 fflush( stderr );
173 return -1;
174 }
175 len -= sizeof( vrpn_uint32);
176
177 if( len < newlen )
178 {
179 fprintf( stderr, "vrpn_FunctionGenerator_function_script::decode_from: "
180 "payload error (wanted %d got %d).\n", newlen, len );
181 fflush( stderr );
182 return -1;
183 }
184
185 char* newscript = NULL;
186 try { newscript = new char[newlen + 1]; }
187 catch (...) {
188 fprintf(stderr, "vrpn_FunctionGenerator_function_script:: "
189 "Out of memory.\n");
190 fflush(stderr);
191 return -1;
192 }
193 if( 0 > vrpn_unbuffer( buf, newscript, newlen ) )
194 {
195 fprintf( stderr, "vrpn_FunctionGenerator_function_script::decode_from: "
196 "payload error (couldn't unbuffer).\n" );
197 try {
198 delete[] newscript;
199 } catch (...) {
200 fprintf(stderr, "vrpn_FunctionGenerator_function_script::decode_from(): delete failed\n");
201 return -1;
202 }
203 fflush( stderr );
204 return -1;
205 }
206 newscript[newlen] = '\0';
207 if (this->script != NULL) {
208 try {
209 delete[] this->script;
210 } catch (...) {
211 fprintf(stderr, "vrpn_FunctionGenerator_function_script::decode_from(): delete failed\n");
212 return -1;
213 }
214 }
215 this->script = newscript;
216 len -= newlen;
217 return newlen + sizeof( vrpn_uint32 );
218}
219
220
226
228getScript( ) const
229{
230 char* retval = NULL;
231 try {
232 retval = new char[strlen(this->script) + 1];
233 } catch (...) {
234 return NULL;
235 }
236 if (this->script) { strcpy(retval, this->script); }
237 return retval;
238}
239
240
242{
243 if( script == NULL ) return false;
244 if (this->script != NULL) {
245 try {
246 delete[] this->script;
247 } catch (...) {
248 fprintf(stderr, "vrpn_FunctionGenerator_function_script::setScript(): delete failed\n");
249 return false;
250 }
251 }
252 try {
253 this->script = new char[strlen(script) + 1];
254 strcpy(this->script, script);
255 } catch (...) { return false; }
256 return true;
257}
258
259//
260// end vrpn_FunctionGenerator_function_script
263
264
267//
268// class vrpn_FunctionGenerator_channel
269
276
277
283
284
286{
287 try {
288 delete function;
289 } catch (...) {
290 fprintf(stderr, "vrpn_FunctionGenerator_channel::~vrpn_FunctionGenerator_channel(): delete failed\n");
291 return;
292 }
293}
294
295
297{
298 try {
299 delete (this->function);
300 } catch (...) {
301 fprintf(stderr, "vrpn_FunctionGenerator_channel::setFunction(): delete failed\n");
302 return;
303 }
304 this->function = function->clone();
305}
306
307
309encode_to( char** buf, vrpn_int32& len ) const
310{
311 if( static_cast<unsigned>(len) < sizeof( vrpn_FunctionGenerator_function::FunctionCode ) )
312 {
313 fprintf( stderr, "vrpn_FunctionGenerator_channel::encode_to: "
314 "insufficient buffer space given (got %d, wanted %lud).\n",
315 len, static_cast<unsigned long>(sizeof( vrpn_FunctionGenerator_function::FunctionCode )) );
316 fflush( stderr );
317 return -1;
318 }
319 if( 0 > vrpn_buffer( buf, &len, (int) this->function->getFunctionCode() ) )
320 {
321 fprintf( stderr, "vrpn_FunctionGenerator_channel::encode_to: "
322 "unable to buffer function type.\n" );
323 fflush( stderr );
324 return -1;
325 }
326 return function->encode_to( buf, len );
327}
328
329
331decode_from( const char** buf, vrpn_int32& len )
332{
333 if( static_cast<unsigned>(len) < sizeof( vrpn_FunctionGenerator_function::FunctionCode ) )
334 {
335 fprintf( stderr, "vrpn_FunctionGenerator_channel::decode_from: "
336 "insufficient buffer space given (got %d, wanted %lud).\n",
337 len, static_cast<unsigned long>(sizeof( vrpn_FunctionGenerator_function::FunctionCode )) );
338 fflush( stderr );
339 return -1;
340 }
341 int myCode;
342 if( 0 > vrpn_unbuffer( buf, &myCode ) )
343 {
344 fprintf( stderr, "vrpn_FunctionGenerator_channel::decode_from: "
345 "unable to unbuffer function type.\n" );
346 fflush( stderr );
347 return -1;
348 }
349 // if we don't have the right function type, create a new
350 // one of the appropriate type and delete the old one
351 if( myCode != function->getFunctionCode() )
352 {
356 try {
357 switch( newCode )
358 {
361 break;
364 break;
365 default:
366 fprintf( stderr, "vrpn_FunctionGenerator_channel::decode_from: "
367 "unknown function type.\n" );
368 fflush( stderr );
369 return -1;
370 }
371 } catch (...) {
372 fprintf(stderr, "vrpn_FunctionGenerator_channel::decode_from: "
373 "Out of memory.\n");
374 fflush(stderr);
375 return -1;
376 }
377 try {
378 delete oldFunc;
379 } catch (...) {
380 fprintf(stderr, "vrpn_FunctionGenerator_channel::decode_from(): delete failed\n");
381 return -1;
382 }
383 }
384 return this->function->decode_from( buf, len );
385}
386
387//
388// end vrpn_FunctionGenerator_channel
391
392
395//
396// class vrpn_FunctionGenerator
397
399vrpn_FunctionGenerator( const char* name, vrpn_Connection * c )
400: vrpn_BaseClass( name, c ),
401 sampleRate( 0 ),
402 numChannels( 0 )
403{
405
406 unsigned i;
407 for( i = 0; i <= vrpn_FUNCTION_CHANNELS_MAX - 1; i++ )
408 {
410 }
411}
412
413
415{
416 unsigned i;
417 for( i = 0; i <= vrpn_FUNCTION_CHANNELS_MAX - 1; i++ )
418 {
419 try {
420 delete channels[i];
421 } catch (...) {
422 fprintf(stderr, "vrpn_FunctionGenerator::~vrpn_FunctionGenerator(): delete failed\n");
423 return;
424 }
425 }
426}
427
428
430getChannel( vrpn_uint32 channelNum )
431{
432 if( channelNum > vrpn_FUNCTION_CHANNELS_MAX - 1 )
433 return NULL;
434 return channels[channelNum];
435}
436
437
440{
441#ifdef DEBUG_VRPN_FUNCTION_GENERATOR
442 fprintf( stdout, "FG::register_types\n" );
443 fflush( stdout );
444#endif
452
459
461
469 || errorMessageID == -1 )
470 {
471 fprintf( stderr, "vrpn_FunctionGenerator::register_types: error registering types.\n" );
472 fflush( stderr );
473 return -1;
474 }
475 return 0;
476}
477
478//
479// end of vrpn_FunctionGenerator
480//
483
484
485
488//
489// vrpn_FunctionGenerator_Server
490//
491
493vrpn_FunctionGenerator_Server( const char* name, vrpn_uint32 numChannels, vrpn_Connection * c )
494: vrpn_FunctionGenerator( name, c )
495{
496 this->numChannels = numChannels;
497 // Check if we have a connection
498 if( d_connection == NULL )
499 {
500 fprintf( stderr, "vrpn_FunctionGenerator_Server: Can't get connection!\n" );
501 fflush( stderr );
502 return;
503 }
504
506 {
507 fprintf( stderr, "vrpn_FunctionGenerator_Server: can't register change channel request handler\n" );
508 fflush( stderr );
509 d_connection = NULL;
510 }
511
513 {
514 fprintf( stderr, "vrpn_FunctionGenerator_Server: can't register channel request handler\n" );
515 fflush( stderr );
516 d_connection = NULL;
517 }
518
520 {
521 fprintf( stderr, "vrpn_FunctionGenerator_Server: can't register all-channel request handler\n" );
522 fflush( stderr );
523 d_connection = NULL;
524 }
525
527 {
528 fprintf( stderr, "vrpn_FunctionGenerator_Server: can't register start request handler\n" );
529 fflush( stderr );
530 d_connection = NULL;
531 }
532
534 {
535 fprintf( stderr, "vrpn_FunctionGenerator_Server: can't register stop request handler\n" );
536 fflush( stderr );
537 d_connection = NULL;
538 }
539
541 {
542 fprintf( stderr, "vrpn_FunctionGenerator_Server: can't register sample-rate request handler\n" );
543 fflush( stderr );
544 d_connection = NULL;
545 }
546
548 {
549 fprintf( stderr, "vrpn_FunctionGenerator_Server: can't register interpreter request handler\n" );
550 fflush( stderr );
551 d_connection = NULL;
552 }
553}
554
555
561
562
564setNumChannels( vrpn_uint32 numChannels )
565{
568 this->numChannels = numChannels;
569 return this->numChannels;
570}
571
572
574mainloop( )
575{
576 // call the base class' server mainloop
578}
579
580
581//static
583handle_channel_message( void* userdata, vrpn_HANDLERPARAM p )
584{
585#ifdef DEBUG_VRPN_FUNCTION_GENERATOR
586 fprintf( stdout, "FG::handle_channel_message\n" );
587 fflush( stdout );
588#endif
590 vrpn_FunctionGenerator_channel* channel = NULL;
591 try { channel = new vrpn_FunctionGenerator_channel(); }
592 catch (...) { return -1; }
593 vrpn_uint32 channelNum = vrpn_FUNCTION_CHANNELS_MAX + 1; // an invalid number
594 if( 0 > me->decode_channel( p.buffer, p.payload_len, channelNum, *channel ) )
595 {
596 if( channelNum < vrpn_FUNCTION_CHANNELS_MAX )
597 {
598 // the decode function was able to decode the channel
599 // number, but must have had some problem decoding the channel.
600 // let the remotes know the channel didn't change
601 me->sendChannelReply( channelNum );
602 }
603 // else, we couldn't even decode the channel number
604 }
605
606 // let the server implementation see if this channel is acceptable
607 me->setChannel( channelNum, channel );
608 return 0;
609}
610
611
612//static
615{
616#ifdef DEBUG_VRPN_FUNCTION_GENERATOR
617 fprintf( stdout, "FG::handle_channelRequest_message\n" );
618 fflush( stdout );
619#endif
621 vrpn_uint32 channelNum = vrpn_FUNCTION_CHANNELS_MAX + 1; // an invalid number
622 if( 0 > me->decode_channel_request( p.buffer, p.payload_len, channelNum ) )
623 {
624 // the decode failed
625 fprintf( stderr, "vrpn_FunctionGenerator_Server::handle_channelRequest_message: "
626 "unable to decode channel number.\n" );
627 fflush( stderr );
628 return -1;
629 }
630 if( channelNum > vrpn_FUNCTION_CHANNELS_MAX )
631 {
632 fprintf( stderr, "vrpn_FunctionGenerator_Server::handle_channelRequest_message: "
633 "invalid channel number %d.\n", channelNum );
634 fflush( stderr );
635 return -1;
636 }
637 me->sendChannelReply( channelNum );
638
639 return 0;
640}
641
642
643//static
646{
647#ifdef DEBUG_VRPN_FUNCTION_GENERATOR
648 fprintf( stdout, "FG::handle_allChannelRequest_message\n" );
649 fflush( stdout );
650#endif
652 unsigned i;
653 for( i = 0; i < vrpn_FUNCTION_CHANNELS_MAX; i++ )
654 {
655 // XXX will this work as-is, or do we need to
656 // force buffers to be flushed periodically?
657 me->sendChannelReply( i );
658 }
659 return 0;
660}
661
662
663//static
666{
667#ifdef DEBUG_VRPN_FUNCTION_GENERATOR
668 fprintf( stdout, "FG::handle_start_message\n" );
669 fflush( stdout );
670#endif
672 me->start( );
673 return 0;
674}
675
676
677//static
680{
681#ifdef DEBUG_VRPN_FUNCTION_GENERATOR
682 fprintf( stdout, "FG::handle_stop_message\n" );
683 fflush( stdout );
684#endif
686 me->stop( );
687 return 0;
688}
689
690
691//static
694{
695#ifdef DEBUG_VRPN_FUNCTION_GENERATOR
696 fprintf( stdout, "FG::handle_sample_rate_message\n" );
697 fflush( stdout );
698#endif
700 vrpn_float32 rate = 0;
701 if( 0 > me->decode_sampleRate_request( p.buffer, p.payload_len, rate ) )
702 {
703 fprintf( stderr, "vrpn_FunctionGenerator_Server::handle_sample_rate_message: "
704 "unable to decode.\n" );
705 fflush( stderr );
706 me->sendSampleRateReply( );
707 return -1;
708 }
709 me->setSampleRate( rate );
710 return 0;
711}
712
713
714//static
717{
718#ifdef DEBUG_VRPN_FUNCTION_GENERATOR
719 fprintf( stdout, "FG::handle_interpreter_request_message\n" );
720 fflush( stdout );
721#endif
724 return 0;
725}
726
727
728
730sendChannelReply( vrpn_uint32 channelNum )
731{
732#ifdef DEBUG_VRPN_FUNCTION_GENERATOR
733 fprintf( stdout, "FG::sendChannelReply\n" );
734 fflush( stdout );
735#endif
737 if( this->d_connection )
738 {
739 int buflen = vrpn_CONNECTION_TCP_BUFLEN;
740 char* buf = &msgbuf[0];
741 if( 0 > this->encode_channel_reply( &buf, buflen, channelNum ) )
742 {
743 fprintf( stderr, "vrpn_FunctionGenerator_Server::sendChannelReply: "
744 "could not buffer message.\n" );
745 fflush( stderr );
746 return -1;
747 }
749 this->channelReplyMessageID, this->d_sender_id,
751 {
752 fprintf( stderr, "vrpn_FunctionGenerator_Server::sendChannelReply: "
753 "could not write message.\n" );
754 fflush( stderr );
755 return -1;
756 }
757 }
758 return 0;
759}
760
761
764{
765#ifdef DEBUG_VRPN_FUNCTION_GENERATOR
766 fprintf( stdout, "FG::sendSampleRateReply\n" );
767 fflush( stdout );
768#endif
770 if( this->d_connection )
771 {
772 int buflen = vrpn_CONNECTION_TCP_BUFLEN;
773 char* buf = &msgbuf[0];
774 if( this->encode_sampleRate_reply( &buf, buflen, sampleRate ) )
775 {
776 fprintf( stderr, "vrpn_FunctionGenerator_Server::sendSampleRateReply: "
777 "could not buffer message.\n" );
778 fflush( stderr );
779 return -1;
780 }
782 this->sampleRateReplyMessageID, this->d_sender_id,
784 {
785 fprintf( stderr, "vrpn_FunctionGenerator_Server::sendSampleRateReply: "
786 "could not write message.\n" );
787 fflush( stderr );
788 return -1;
789 }
790 }
791 return 0;
792}
793
794
796sendStartReply( vrpn_bool started )
797{
798#ifdef DEBUG_VRPN_FUNCTION_GENERATOR
799 fprintf( stdout, "FG::sendStartReply\n" );
800 fflush( stdout );
801#endif
803 if( this->d_connection )
804 {
805 int buflen = vrpn_CONNECTION_TCP_BUFLEN;
806 char* buf = &msgbuf[0];
807 if( 0 > this->encode_start_reply( &buf, buflen, started ) )
808 {
809 fprintf( stderr, "vrpn_FunctionGenerator_Server::sendStartReply: "
810 "could not buffer message.\n" );
811 fflush( stderr );
812 return -1;
813 }
815 this->startFunctionReplyMessageID, this->d_sender_id,
817 {
818 fprintf( stderr, "vrpn_FunctionGenerator_Server::sendStartReply: "
819 "could not write message.\n" );
820 fflush( stderr );
821 return -1;
822 }
823 }
824 return 0;
825}
826
827
829sendStopReply( vrpn_bool stopped )
830{
831#ifdef DEBUG_VRPN_FUNCTION_GENERATOR
832 fprintf( stdout, "FG::sendStopReply\n" );
833 fflush( stdout );
834#endif
836 if( this->d_connection )
837 {
838 int buflen = vrpn_CONNECTION_TCP_BUFLEN;
839 char* buf = &msgbuf[0];
840 if( 0 > this->encode_stop_reply( &buf, buflen, stopped ) )
841 {
842 fprintf( stderr, "vrpn_FunctionGenerator_Server::sendStopReply: "
843 "could not buffer message.\n" );
844 fflush( stderr );
845 return -1;
846 }
848 this->stopFunctionReplyMessageID, this->d_sender_id,
850 {
851 fprintf( stderr, "vrpn_FunctionGenerator_Server::sendStopReply: "
852 "could not write message.\n" );
853 fflush( stderr );
854 return -1;
855 }
856 }
857 return 0;
858}
859
860
863{
864#ifdef DEBUG_VRPN_FUNCTION_GENERATOR
865 fprintf( stdout, "FG::sendInterpreterDescription\n" );
866 fflush( stdout );
867#endif
869 if( this->d_connection )
870 {
871 int buflen = vrpn_CONNECTION_TCP_BUFLEN;
872 char* buf = &msgbuf[0];
873 if( 0 > this->encode_interpreterDescription_reply( &buf, buflen, getInterpreterDescription() ) )
874 {
875 fprintf( stderr, "vrpn_FunctionGenerator_Server::sendInterpreterDescription: "
876 "could not buffer message.\n" );
877 fflush( stderr );
878 return -1;
879 }
881 this->interpreterReplyMessageID, this->d_sender_id,
883 {
884 fprintf( stderr, "vrpn_FunctionGenerator_Server::sendInterpreterDescription: "
885 "could not write message.\n" );
886 fflush( stderr );
887 return -1;
888 }
889 }
890 return 0;
891}
892
893
895sendError( FGError error, vrpn_int32 channel )
896{
897#ifdef DEBUG_VRPN_FUNCTION_GENERATOR
898 fprintf( stdout, "FG::sendError\n" );
899 fflush( stdout );
900#endif
902 if( this->d_connection )
903 {
904 int buflen = vrpn_CONNECTION_TCP_BUFLEN;
905 char* buf = &msgbuf[0];
906 if( this->encode_error_report( &buf, buflen, error, channel ) )
907 {
908 fprintf( stderr, "vrpn_FunctionGenerator_Server::sendError: "
909 "could not buffer message.\n" );
910 fflush( stderr );
911 return -1;
912 }
914 this->errorMessageID, this->d_sender_id,
916 {
917 fprintf( stderr, "vrpn_FunctionGenerator_Server::sendError: "
918 "could not write message.\n" );
919 fflush( stderr );
920 return -1;
921 }
922 }
923 return 0;
924}
925
926//
927// end vrpn_FunctionGenerator_Server
928// (except for encode and decode functions)
931
932
933
934
937//
938// vrpn_FunctionGenerator_Remote
939//
940
942vrpn_FunctionGenerator_Remote( const char* name, vrpn_Connection * c )
943: vrpn_FunctionGenerator( name, c )
944{
945 // Check if we have a connection
946 if( d_connection == NULL )
947 {
948 fprintf( stderr, "vrpn_FunctionGenerator_Remote: Can't get connection!\n" );
949 fflush( stderr );
950 return;
951 }
952
954 {
955 fprintf( stderr, "vrpn_FunctionGenerator_Remote: can't register channel reply handler\n" );
956 fflush( stderr );
957 d_connection = NULL;
958 }
959
961 {
962 fprintf( stderr, "vrpn_FunctionGenerator_Remote: can't register start reply handler\n" );
963 fflush( stderr );
964 d_connection = NULL;
965 }
966
968 {
969 fprintf( stderr, "vrpn_FunctionGenerator_Remote: can't register stop reply handler\n" );
970 fflush( stderr );
971 d_connection = NULL;
972 }
973
975 {
976 fprintf( stderr, "vrpn_FunctionGenerator_Remote: can't register sample-rate reply handler\n" );
977 fflush( stderr );
978 d_connection = NULL;
979 }
980
982 {
983 fprintf( stderr, "vrpn_FunctionGenerator_Remote: can't register interpreter reply handler\n" );
984 fflush( stderr );
985 d_connection = NULL;
986 }
987
989 {
990 fprintf( stderr, "vrpn_FunctionGenerator_Remote: can't register error message handler\n" );
991 fflush( stderr );
992 d_connection = NULL;
993 }
994
995}
996
997
999setChannel( const vrpn_uint32 channelNum, const vrpn_FunctionGenerator_channel* channel )
1000{
1001#ifdef DEBUG_VRPN_FUNCTION_GENERATOR
1002 fprintf( stdout, "FG::setChannel\n" );
1003 fflush( stdout );
1004#endif
1005 vrpn_gettimeofday( &timestamp, NULL );
1006 if( this->d_connection )
1007 {
1008 int buflen = vrpn_CONNECTION_TCP_BUFLEN;
1009 char* buf = &msgbuf[0];
1010 if( 0 > this->encode_channel( &buf, buflen, channelNum, channel ) )
1011 {
1012 fprintf( stderr, "vrpn_FunctionGenerator_Remote::setChannel: "
1013 "could not buffer message.\n" );
1014 fflush( stderr );
1015 return -1;
1016 }
1018 this->channelMessageID, this->d_sender_id, msgbuf,
1020 {
1021 fprintf( stderr, "vrpn_FunctionGenerator_Remote::setChannel: "
1022 "could not write message.\n" );
1023 fflush( stderr );
1024 return -1;
1025 }
1026 }
1027 else
1028 {
1029 fprintf( stderr, "vrpn_FunctionGenerator_Remote::setChannel: "
1030 "no connection.\n" );
1031 fflush( stderr );
1032 return -1;
1033 }
1034 return 0;
1035}
1036
1037
1039requestChannel( const vrpn_uint32 channelNum )
1040{
1041#ifdef DEBUG_VRPN_FUNCTION_GENERATOR
1042 fprintf( stdout, "FG::requestChannel\n" );
1043 fflush( stdout );
1044#endif
1045 vrpn_gettimeofday( &timestamp, NULL );
1046 if( this->d_connection )
1047 {
1048 int buflen = vrpn_CONNECTION_TCP_BUFLEN;
1049 char* buf = &msgbuf[0];
1050 if( 0 > this->encode_channel_request( &buf, buflen, channelNum ) )
1051 {
1052 fprintf( stderr, "vrpn_FunctionGenerator_Remote::requestChannel: "
1053 "could not buffer message.\n" );
1054 fflush( stderr );
1055 return -1;
1056 }
1058 this->requestChannelMessageID, this->d_sender_id, msgbuf,
1060 {
1061 fprintf( stderr, "vrpn_FunctionGenerator_Remote::requestChannel: "
1062 "could not write message.\n" );
1063 fflush( stderr );
1064 return -1;
1065 }
1066 }
1067 else
1068 {
1069 fprintf( stderr, "vrpn_FunctionGenerator_Remote::requestChannel: "
1070 "no connection.\n" );
1071 fflush( stderr );
1072 return -1;
1073 }
1074 return 0;
1075}
1076
1077
1078
1081{
1082#ifdef DEBUG_VRPN_FUNCTION_GENERATOR
1083 fprintf( stdout, "FG::requestAllChannels\n" );
1084 fflush( stdout );
1085#endif
1086 vrpn_gettimeofday( &timestamp, NULL );
1087 if( this->d_connection )
1088 {
1089 int buflen = vrpn_CONNECTION_TCP_BUFLEN;
1090 char* buf = &msgbuf[0];
1091 // nothing to encode; the message type is the symbol
1093 this->requestAllChannelsMessageID, this->d_sender_id, buf,
1095 {
1096 fprintf( stderr, "vrpn_FunctionGenerator_Remote::requestAllChannels: "
1097 "could not write message.\n" );
1098 fflush( stderr );
1099 return -1;
1100 }
1101 }
1102 else
1103 {
1104 fprintf( stderr, "vrpn_FunctionGenerator_Remote::requestAllChannels: "
1105 "no connection.\n" );
1106 fflush( stderr );
1107 return -1;
1108 }
1109 return 0;
1110}
1111
1112
1114requestStart( )
1115{
1116#ifdef DEBUG_VRPN_FUNCTION_GENERATOR
1117 fprintf( stdout, "FG::requestStart\n" );
1118 fflush( stdout );
1119#endif
1120 vrpn_gettimeofday( &timestamp, NULL );
1121 if( this->d_connection )
1122 {
1123 int buflen = vrpn_CONNECTION_TCP_BUFLEN;
1124 char* buf = &msgbuf[0];
1125 // nothing to encode; the message type is the symbol
1127 this->startFunctionMessageID, this->d_sender_id, buf,
1129 {
1130 fprintf( stderr, "vrpn_FunctionGenerator_Remote::requestStart: "
1131 "could not write message.\n" );
1132 fflush( stderr );
1133 return -1;
1134 }
1135 }
1136 else
1137 {
1138 fprintf( stderr, "vrpn_FunctionGenerator_Remote::requestStart: "
1139 "no connection.\n" );
1140 fflush( stderr );
1141 return -1;
1142 }
1143 return 0;
1144}
1145
1146
1148requestStop( )
1149{
1150#ifdef DEBUG_VRPN_FUNCTION_GENERATOR
1151 fprintf( stdout, "FG::requestStop\n" );
1152 fflush( stdout );
1153#endif
1154 vrpn_gettimeofday( &timestamp, NULL );
1155 if( this->d_connection )
1156 {
1157 int buflen = vrpn_CONNECTION_TCP_BUFLEN;
1158 char* buf = &msgbuf[0];
1159 // nothing to encode; the message type is the symbol
1161 this->stopFunctionMessageID, this->d_sender_id, buf,
1163 {
1164 fprintf( stderr, "vrpn_FunctionGenerator_Remote::requestStop: "
1165 "could not write message.\n" );
1166 fflush( stderr );
1167 return -1;
1168 }
1169 }
1170 else
1171 {
1172 fprintf( stderr, "vrpn_FunctionGenerator_Remote::requestStop: "
1173 "no connection.\n" );
1174 fflush( stderr );
1175 return -1;
1176 }
1177 return 0;
1178}
1179
1180
1182requestSampleRate( vrpn_float32 rate )
1183{
1184#ifdef DEBUG_VRPN_FUNCTION_GENERATOR
1185 fprintf( stdout, "FG::requestSampleRate\n" );
1186 fflush( stdout );
1187#endif
1188 vrpn_gettimeofday( &timestamp, NULL );
1189 if( this->d_connection )
1190 {
1191 int buflen = vrpn_CONNECTION_TCP_BUFLEN;
1192 char* buf = &msgbuf[0];
1193 if( 0 > this->encode_sampleRate_request( &buf, buflen, rate ) )
1194 {
1195 fprintf( stderr, "vrpn_FunctionGenerator_Remote::requestSampleRate: "
1196 "could not buffer message.\n" );
1197 fflush( stderr );
1198 return -1;
1199 }
1201 this->sampleRateMessageID, this->d_sender_id, msgbuf,
1203 {
1204 fprintf( stderr, "vrpn_FunctionGenerator_Remote::requestSampleRate: "
1205 "could not write message.\n" );
1206 fflush( stderr );
1207 return -1;
1208 }
1209 }
1210 else
1211 {
1212 fprintf( stderr, "vrpn_FunctionGenerator_Remote::requestSampleRate: "
1213 "no connection.\n" );
1214 fflush( stderr );
1215 return -1;
1216 }
1217 return 0;
1218}
1219
1220
1223{
1224#ifdef DEBUG_VRPN_FUNCTION_GENERATOR
1225 fprintf( stdout, "FG::requestInterpreterDescription\n" );
1226 fflush( stdout );
1227#endif
1228 vrpn_gettimeofday( &timestamp, NULL );
1229 if( this->d_connection )
1230 {
1231 int buflen = vrpn_CONNECTION_TCP_BUFLEN;
1232 char* buf = &msgbuf[0];
1233 // nothing to encode; the message type is the symbol
1235 this->requestInterpreterMessageID, this->d_sender_id, buf,
1237 {
1238 fprintf( stderr, "vrpn_FunctionGenerator_Remote::requestInterpreterDescription: "
1239 "could not write message.\n" );
1240 fflush( stderr );
1241 return -1;
1242 }
1243 }
1244 else
1245 {
1246 fprintf( stderr, "vrpn_FunctionGenerator_Remote::requestInterpreterDescription: "
1247 "no connection.\n" );
1248 fflush( stderr );
1249 return -1;
1250 }
1251 return 0;
1252}
1253
1254
1256mainloop( )
1257{
1258 if( d_connection != NULL )
1259 {
1261 client_mainloop( );
1262 }
1263}
1264
1265
1272
1273
1280
1281
1288
1289
1296
1297
1304
1305
1312
1313
1320
1321
1328
1329
1336
1337
1344
1345
1352
1353
1360
1361
1362//static
1365{
1366#ifdef DEBUG_VRPN_FUNCTION_GENERATOR
1367 fprintf( stdout, "FG::handle_channelReply_message\n" );
1368 fflush( stdout );
1369#endif
1371 vrpn_uint32 channelNum = vrpn_FUNCTION_CHANNELS_MAX + 1; // an invalid number
1372 if( 0 > me->decode_channel_reply( p.buffer, p.payload_len, channelNum ) )
1373 {
1374 fprintf( stderr, "vrpn_FunctionGenerator_Remote::handle_channelReply_message: "
1375 "unable to decode.\n" );
1376 fflush( stderr );
1377 return -1;
1378 }
1379 if( channelNum >= vrpn_FUNCTION_CHANNELS_MAX )
1380 {
1381 fprintf( stderr, "vrpn_FunctionGenerator_Remote::handle_channelReply_message: "
1382 "invalid channel %d.\n", channelNum );
1383 fflush( stderr );
1384 return -1;
1385 }
1386
1388 cb.msg_time.tv_sec = p.msg_time.tv_sec;
1389 cb.msg_time.tv_usec = p.msg_time.tv_usec;
1390 cb.channelNum = channelNum;
1391 cb.channel = me->channels[channelNum];
1392
1394 return 0;
1395}
1396
1397
1398//static
1401{
1402#ifdef DEBUG_VRPN_FUNCTION_GENERATOR
1403 fprintf( stdout, "FG::handle_startReply_message\n" );
1404 fflush( stdout );
1405#endif
1407 vrpn_bool isStarted = false;
1408 if( 0 > me->decode_start_reply( p.buffer, p.payload_len, isStarted ) )
1409 {
1410 fprintf( stderr, "vrpn_FunctionGenerator_Remote::handle_startReply_message: "
1411 "unable to decode.\n" );
1412 fflush( stderr );
1413 return -1;
1414 }
1415
1417 cb.msg_time.tv_sec = p.msg_time.tv_sec;
1418 cb.msg_time.tv_usec = p.msg_time.tv_usec;
1419 cb.isStarted = isStarted;
1420
1422 return 0;
1423}
1424
1425
1426//static
1429{
1430#ifdef DEBUG_VRPN_FUNCTION_GENERATOR
1431 fprintf( stdout, "FG::handle_stopReply_message\n" );
1432 fflush( stdout );
1433#endif
1435 vrpn_bool isStopped = false;
1436 if( 0 > me->decode_stop_reply( p.buffer, p.payload_len, isStopped ) )
1437 {
1438 fprintf( stderr, "vrpn_FunctionGenerator_Remote::handle_stopReply_message: "
1439 "unable to decode.\n" );
1440 fflush( stderr );
1441 return -1;
1442 }
1443
1445 cb.msg_time.tv_sec = p.msg_time.tv_sec;
1446 cb.msg_time.tv_usec = p.msg_time.tv_usec;
1447 cb.isStopped = isStopped;
1448
1450 return 0;
1451}
1452
1453
1454//static
1457{
1458#ifdef DEBUG_VRPN_FUNCTION_GENERATOR
1459 fprintf( stdout, "FG::handle_sampleRateReply_message\n" );
1460 fflush( stdout );
1461#endif
1463 if( 0 > me->decode_sampleRate_reply( p.buffer, p.payload_len ) )
1464 {
1465 fprintf( stderr, "vrpn_FunctionGenerator_Remote::handle_sampleRateReply_message: "
1466 "unable to decode.\n" );
1467 fflush( stderr );
1468 return -1;
1469 }
1470
1472 cb.msg_time.tv_sec = p.msg_time.tv_sec;
1473 cb.msg_time.tv_usec = p.msg_time.tv_usec;
1474 cb.sampleRate = me->sampleRate;
1475
1477 return 0;
1478}
1479
1480
1481//static
1484{
1485#ifdef DEBUG_VRPN_FUNCTION_GENERATOR
1486 fprintf( stdout, "FG::handle_interpreterReply_message\n" );
1487 fflush( stdout );
1488#endif
1492 {
1493 fprintf( stderr, "vrpn_FunctionGenerator_Remote::handle_interpreterReply_message: "
1494 "unable to decode.\n" );
1495 fflush( stderr );
1496 return -1;
1497 }
1498
1499 cb.msg_time.tv_sec = p.msg_time.tv_sec;
1500 cb.msg_time.tv_usec = p.msg_time.tv_usec;
1501
1503 return 0;
1504}
1505
1506
1507// static
1509handle_error_message( void* userdata, vrpn_HANDLERPARAM p )
1510{
1511#ifdef DEBUG_VRPN_FUNCTION_GENERATOR
1512 fprintf( stdout, "FG::handle_error_message\n" );
1513 fflush( stdout );
1514#endif
1517 if( 0 > me->decode_error_reply( p.buffer, p.payload_len, cb.err, cb.channel ) )
1518 {
1519 fprintf( stderr, "vrpn_FunctionGenerator_Remote::handle_error_message: "
1520 "unable to decode.\n" );
1521 fflush( stderr );
1522 return -1;
1523 }
1524
1525 cb.msg_time.tv_sec = p.msg_time.tv_sec;
1526 cb.msg_time.tv_usec = p.msg_time.tv_usec;
1527
1528 me->error_list.call_handlers( cb );
1529 return 0;
1530}
1531
1532//
1533// end vrpn_FunctionGenerator_Remote
1534// (except for encode and decode functions)
1537
1538
1539
1542//
1543// encode and decode functions for
1544// vrpn_FunctionGenerator_Server and
1545// vrpn_FunctionGenerator_Remote
1546//
1547
1549encode_channel( char** buf, vrpn_int32& len, const vrpn_uint32 channelNum,
1550 const vrpn_FunctionGenerator_channel* channel )
1551{
1552#ifdef DEBUG_VRPN_FUNCTION_GENERATOR
1553 fprintf( stdout, "FG::encode_channel\n" );
1554 fflush( stdout );
1555#endif
1556 if( channelNum > vrpn_FUNCTION_CHANNELS_MAX )
1557 {
1558 fprintf( stderr, "vrpn_FunctionGenerator_Remote::encode_channel: "
1559 "invalid channel nubmer %d.\n", channelNum );
1560 fflush( stderr );
1561 return -1;
1562 }
1563 if( static_cast<unsigned>(len) < sizeof( vrpn_uint32 ) )
1564 {
1565 // the channel's encode_to function will check that the length is
1566 // sufficient for the channel's info, so just check that we can
1567 // at least encode the channel number.
1568 fprintf( stderr, "vrpn_FunctionGenerator_Remote::encode_channel: "
1569 "couldn't buffer (got %d, wanted at least %lud).\n",
1570 len, static_cast<unsigned long>(sizeof( vrpn_int32)) );
1571 fflush( stderr );
1572 return -1;
1573 }
1574 if( 0 > vrpn_buffer( buf, &len, channelNum ) )
1575 {
1576 fprintf( stderr, "vrpn_FunctionGenerator_Remote::encode_channel: "
1577 "message payload error (couldn't buffer channel number).\n" );
1578 fflush( stderr );
1579 return -1;
1580 }
1581 if( 0 > channel->encode_to( buf, len ) )
1582 {
1583 fprintf( stderr, "vrpn_FunctionGenerator_Remote::encode_channel: "
1584 "message payload error (couldn't buffer channel).\n" );
1585 fflush( stderr );
1586 return -1;
1587 }
1588 return 0;
1589}
1590
1591
1593decode_channel( const char* buf, const vrpn_int32 len, vrpn_uint32& channelNum,
1595{
1596#ifdef DEBUG_VRPN_FUNCTION_GENERATOR
1597 fprintf( stdout, "FG::decode_channel\n" );
1598 fflush( stdout );
1599#endif
1600 if( static_cast<unsigned>(len) < sizeof( vrpn_uint32 ) )
1601 {
1602 // the channel's decode_from function will check that the length is
1603 // sufficient for the channel's info, so just check that we can
1604 // at least decode the channel number.
1605 fprintf( stderr, "vrpn_FunctionGenerator_Server::decode_channel: "
1606 "channel message payload error (got %d, wanted at least %lud).\n",
1607 len, static_cast<unsigned long>(sizeof( vrpn_int32)) );
1608 fflush( stderr );
1609 return -1;
1610 }
1611 const char* mybuf = buf;
1612 vrpn_int32 mylen = len;
1613 vrpn_uint32 myNum = 0;
1614 if( 0 > vrpn_unbuffer( &mybuf, &myNum ) )
1615 {
1616 fprintf( stderr, "vrpn_FunctionGenerator_Server::decode_channel: "
1617 "message payload error (couldn't unbuffer)\n" );
1618 fflush( stderr );
1619 return -1;
1620 }
1621 mylen -= sizeof( myNum );
1622 channelNum = myNum;
1623 if( 0 > channel.decode_from( &mybuf, mylen ) )
1624 {
1625 fprintf( stderr, "vrpn_FunctionGenerator_Server::decode_channel: "
1626 "error while decoding channel %d\n", channelNum );
1627 fflush( stderr );
1628 return -1;
1629 }
1630
1631 return 0;
1632}
1633
1634
1636encode_channel_reply( char** buf, vrpn_int32& len, const vrpn_uint32 channelNum )
1637{
1638#ifdef DEBUG_VRPN_FUNCTION_GENERATOR
1639 fprintf( stdout, "FG::encode_channel_reply\n" );
1640 fflush( stdout );
1641#endif
1642 if( channelNum >= vrpn_FUNCTION_CHANNELS_MAX )
1643 {
1644 fprintf( stderr, "vrpn_FunctionGenerator_Server::encode_channel_reply: "
1645 "invalid channel\n" );
1646 fflush( stderr );
1647 return -1;
1648 }
1649 if( static_cast<unsigned>(len) < sizeof( vrpn_uint32 ) )
1650 {
1651 // the channel's encode_to function will check that the length is
1652 // sufficient for the channel's info, so just check that we can
1653 // at least encode the channel number.
1654 fprintf( stderr, "vrpn_FunctionGenerator_Server::encode_channel_reply: "
1655 "insufficient buffer space given (got %d, wanted %lud).\n",
1656 len, static_cast<unsigned long>(sizeof( vrpn_uint32)) );
1657 fflush( stderr );
1658 return -1;
1659 }
1660 if( 0 > vrpn_buffer( buf, &len, channelNum ) )
1661 {
1662 fprintf( stderr, "vrpn_FunctionGenerator_Server::encode_channel_reply: "
1663 "unable to buffer channel number.\n" );
1664 fflush( stderr );
1665 return -1;
1666 }
1667 if( 0 > channels[channelNum]->encode_to( buf, len ) )
1668 {
1669 fprintf( stderr, "vrpn_FunctionGenerator_Server::encode_channel_reply: "
1670 "unable to encode channel.\n" );
1671 fflush( stderr );
1672 return -1;
1673 }
1674 return 0;
1675}
1676
1677
1679decode_channel_reply( const char* buf, const vrpn_int32 len, vrpn_uint32& channelNum )
1680{
1681#ifdef DEBUG_VRPN_FUNCTION_GENERATOR
1682 fprintf( stdout, "FG::decode_channel_reply\n" );
1683 fflush( stdout );
1684#endif
1685 if( static_cast<unsigned>(len) < sizeof( vrpn_uint32 ) )
1686 {
1687 // the channel's decode_to function will check that the length is
1688 // sufficient for the channel's info, so just check that we can
1689 // at least decode the channel number.
1690 fprintf( stderr, "vrpn_FunctionGenerator_Remote::decode_channel_reply: "
1691 "insufficient buffer space given (got %d, wanted %lud).\n",
1692 len, static_cast<unsigned long>(sizeof( vrpn_uint32)) );
1693 fflush( stderr );
1694 return -1;
1695 }
1696 const char* mybuf = buf;
1697 vrpn_int32 mylen = len;
1698 vrpn_uint32 myNum = 0;
1699 if( 0 > vrpn_unbuffer( &mybuf, &myNum ) )
1700 {
1701 fprintf( stderr, "vrpn_FunctionGenerator_Remote::decode_channel_reply: "
1702 "unable to unbuffer channel number.\n" );
1703 fflush( stderr );
1704 return -1;
1705 }
1706 if( myNum >= vrpn_FUNCTION_CHANNELS_MAX )
1707 {
1708 fprintf( stderr, "vrpn_FunctionGenerator_Remote::decode_channel_reply: "
1709 "invalid channel: %d\n", myNum );
1710 fflush( stderr );
1711 return -1;
1712 }
1713 channelNum = myNum;
1714 mylen -= sizeof( vrpn_uint32 );
1715 return channels[channelNum]->decode_from( &mybuf, mylen );
1716}
1717
1718
1720encode_channel_request( char** buf, vrpn_int32& len, const vrpn_uint32 channelNum )
1721{
1722#ifdef DEBUG_VRPN_FUNCTION_GENERATOR
1723 fprintf( stdout, "FG::encode_channel_request\n" );
1724 fflush( stdout );
1725#endif
1726 if( static_cast<unsigned>(len) < sizeof( vrpn_uint32 ) )
1727 {
1728 fprintf( stderr, "vrpn_FunctionGenerator_Remote::encode_channel_request: "
1729 "channel message payload error (got %d, wanted at least %lud).\n",
1730 len, static_cast<unsigned long>(sizeof( vrpn_int32)) );
1731 fflush( stderr );
1732 return -1;
1733 }
1734 vrpn_int32 mylen = len;
1735 if( 0 > vrpn_buffer( buf, &mylen, channelNum ) )
1736 {
1737 fprintf( stderr, "vrpn_FunctionGenerator_Remote::encode_channel_request: "
1738 "unable to buffer channel %d", channelNum );
1739 fflush( stderr );
1740 return -1;
1741 }
1742 len = mylen;
1743 return 0;
1744}
1745
1746
1748decode_channel_request( const char* buf, const vrpn_int32 len, vrpn_uint32& channelNum )
1749{
1750#ifdef DEBUG_VRPN_FUNCTION_GENERATOR
1751 fprintf( stdout, "FG::decode_channel_request\n" );
1752 fflush( stdout );
1753#endif
1754 if( static_cast<unsigned>(len) < sizeof( vrpn_uint32 ) )
1755 {
1756 // the channel's encode_to function will check that the length is
1757 // sufficient for the channel's info, so just check that we can
1758 // at least encode the channel number.
1759 fprintf( stderr, "vrpn_FunctionGenerator_Server::decode_channel_request: "
1760 "channel message payload error (got %d, wanted at least %lud).\n",
1761 len, static_cast<unsigned long>(sizeof( vrpn_int32)) );
1762 fflush( stderr );
1763 return -1;
1764 }
1765 const char* mybuf = buf;
1766 if( 0 > vrpn_unbuffer( &mybuf, &channelNum ) )
1767 {
1768 fprintf( stderr, "vrpn_FunctionGenerator_Server::decode_channel_request: "
1769 "unable to unbuffer channel %d", channelNum );
1770 fflush( stderr );
1771 return -1;
1772 }
1773 return 0;
1774}
1775
1776
1778encode_sampleRate_request( char** buf, vrpn_int32& len, const vrpn_float32 sampleRate )
1779{
1780#ifdef DEBUG_VRPN_FUNCTION_GENERATOR
1781 fprintf( stdout, "FG::encode_sampleRate_request\n" );
1782 fflush( stdout );
1783#endif
1784 if( static_cast<unsigned>(len) < sizeof( vrpn_float32 ) )
1785 {
1786 fprintf( stderr, "vrpn_FunctionGenerator_Remote::encode_sampleRate_request: "
1787 "channel message payload error (got %d, wanted at least %lud).\n",
1788 len, static_cast<unsigned long>(sizeof( vrpn_float32)) );
1789 fflush( stderr );
1790 return -1;
1791 }
1792 vrpn_int32 mylen = len;
1793 if( 0 > vrpn_buffer( buf, &mylen, sampleRate ) )
1794 {
1795 fprintf( stderr, "vrpn_FunctionGenerator_Remote::encode_sampleRate_request: "
1796 "unable to buffer sample rate" );
1797 fflush( stderr );
1798 return -1;
1799 }
1800 len = mylen;
1801 return 0;
1802}
1803
1804
1806decode_sampleRate_request( const char* buf, const vrpn_int32 len, vrpn_float32& sampleRate )
1807{
1808#ifdef DEBUG_VRPN_FUNCTION_GENERATOR
1809 fprintf( stdout, "FG::decode_sampleRate_request\n" );
1810 fflush( stdout );
1811#endif
1812 if( static_cast<unsigned>(len) < sizeof( vrpn_float32 ) )
1813 {
1814 fprintf( stderr, "vrpn_FunctionGenerator_Server::decode_sampleRate_request: "
1815 "channel message payload error (got %d, wanted at least %lud).\n",
1816 len, static_cast<unsigned long>(sizeof( vrpn_float32)) );
1817 fflush( stderr );
1818 return -1;
1819 }
1820 const char* mybuf = buf;
1821 if( 0 > vrpn_unbuffer( &mybuf, &sampleRate ) )
1822 {
1823 fprintf( stderr, "vrpn_FunctionGenerator_Server::decode_sampleRate_request: "
1824 "unable to unbuffer sample rate" );
1825 fflush( stderr );
1826 return -1;
1827 }
1828 return 0;
1829}
1830
1831
1833encode_start_reply( char** buf, vrpn_int32& len, const vrpn_bool isStarted )
1834{
1835#ifdef DEBUG_VRPN_FUNCTION_GENERATOR
1836 fprintf( stdout, "FG::encode_start_reply\n" );
1837 fflush( stdout );
1838#endif
1839 if( static_cast<unsigned>(len) < sizeof( vrpn_bool ) )
1840 {
1841 fprintf( stderr, "vrpn_FunctionGenerator_Server::encode_start_reply: "
1842 "insufficient buffer space given (got %d, wanted %lud).\n",
1843 len, static_cast<unsigned long>(sizeof( vrpn_bool)) );
1844 fflush( stderr );
1845 return -1;
1846 }
1847 return vrpn_buffer( buf, &len, isStarted );
1848}
1849
1850
1852decode_start_reply( const char* buf, const vrpn_int32 len, vrpn_bool& isStarted )
1853{
1854#ifdef DEBUG_VRPN_FUNCTION_GENERATOR
1855 fprintf( stdout, "FG::decode_start_reply\n" );
1856 fflush( stdout );
1857#endif
1858 if( static_cast<unsigned>(len) < sizeof( vrpn_bool ) )
1859 {
1860 fprintf( stderr, "vrpn_FunctionGenerator_Remote::decode_start_reply: "
1861 "insufficient buffer space given (got %d, wanted %lud).\n",
1862 len, static_cast<unsigned long>(sizeof( vrpn_bool)) );
1863 fflush( stderr );
1864 return -1;
1865 }
1866 const char* mybuf = buf;
1867 if( 0 > vrpn_unbuffer( &mybuf, &isStarted ) )
1868 {
1869 fprintf( stderr, "vrpn_FunctionGenerator_Remote::decode_start_reply: "
1870 "unable to unbuffer stop condition.\n" );
1871 fflush( stderr );
1872 return -1;
1873 }
1874 return 0;
1875}
1876
1877
1879encode_stop_reply( char** buf, vrpn_int32& len, const vrpn_bool isStopped )
1880{
1881#ifdef DEBUG_VRPN_FUNCTION_GENERATOR
1882 fprintf( stdout, "FG::encode_stop_reply\n" );
1883 fflush( stdout );
1884#endif
1885 if( static_cast<unsigned>(len) < sizeof( vrpn_bool ) )
1886 {
1887 fprintf( stderr, "vrpn_FunctionGenerator_Server::encode_stop_reply: "
1888 "insufficient buffer space given (got %d, wanted %lud).\n",
1889 len, static_cast<unsigned long>(sizeof( vrpn_bool)) );
1890 fflush( stderr );
1891 return -1;
1892 }
1893 return vrpn_buffer( buf, &len, isStopped );
1894}
1895
1896
1898decode_stop_reply( const char* buf, const vrpn_int32 len, vrpn_bool& isStopped )
1899{
1900#ifdef DEBUG_VRPN_FUNCTION_GENERATOR
1901 fprintf( stdout, "FG::decode_stop_reply\n" );
1902 fflush( stdout );
1903#endif
1904 if( static_cast<unsigned>(len) < sizeof( vrpn_bool ) )
1905 {
1906 fprintf( stderr, "vrpn_FunctionGenerator_Remote::decode_stop_reply: "
1907 "insufficient buffer space given (got %d, wanted %lud).\n",
1908 len, static_cast<unsigned long>(sizeof( vrpn_bool)) );
1909 fflush( stderr );
1910 return -1;
1911 }
1912 if( 0 > vrpn_unbuffer( &buf, &isStopped ) )
1913 {
1914 fprintf( stderr, "vrpn_FunctionGenerator_Remote::decode_stop_reply: "
1915 "unable to unbuffer stop condition.\n" );
1916 fflush( stderr );
1917 return -1;
1918 }
1919 return 0;
1920}
1921
1922
1924encode_sampleRate_reply( char** buf, vrpn_int32& len, const vrpn_float32 sampleRate )
1925{
1926#ifdef DEBUG_VRPN_FUNCTION_GENERATOR
1927 fprintf( stdout, "FG::encode_sampleRate_reply\n" );
1928 fflush( stdout );
1929#endif
1930 if( static_cast<unsigned>(len) < sizeof( vrpn_float32 ) )
1931 {
1932 fprintf( stderr, "vrpn_FunctionGenerator_Server::encode_sampleRate_reply: "
1933 "insufficient buffer space given (got %d, wanted %lud).\n",
1934 len, static_cast<unsigned long>(sizeof( vrpn_float32)) );
1935 fflush( stderr );
1936 return -1;
1937 }
1938 return vrpn_buffer( buf, &len, sampleRate );
1939}
1940
1941
1943decode_sampleRate_reply( const char* buf, const vrpn_int32 len )
1944{
1945#ifdef DEBUG_VRPN_FUNCTION_GENERATOR
1946 fprintf( stdout, "FG::decode_sampleRate_reply\n" );
1947 fflush( stdout );
1948#endif
1949 if( static_cast<unsigned>(len) < sizeof( vrpn_float32 ) )
1950 {
1951 fprintf( stderr, "vrpn_FunctionGenerator_Remote::decode_sampleRate_reply: "
1952 "insufficient buffer space given (got %d, wanted %lud).\n",
1953 len, static_cast<unsigned long>(sizeof( vrpn_float32)) );
1954 fflush( stderr );
1955 return -1;
1956 }
1957 vrpn_float32 myRate = 0;
1958 if( 0 > vrpn_unbuffer( &buf, &myRate ) )
1959 {
1960 fprintf( stderr, "vrpn_FunctionGenerator_Remote::decode_sampleRate_reply: "
1961 "unable to unbuffer sample rate.\n" );
1962 fflush( stderr );
1963 return -1;
1964 }
1965 this->sampleRate = myRate;
1966 return 0;
1967}
1968
1969
1971encode_interpreterDescription_reply( char** buf, vrpn_int32& len, const char* desc )
1972{
1973#ifdef DEBUG_VRPN_FUNCTION_GENERATOR
1974 fprintf( stdout, "FG::encode_interpreterDescription_reply\n" );
1975 fflush( stdout );
1976#endif
1977 vrpn_int32 dlength = static_cast<vrpn_int32>(strlen( desc ));
1978 if( len < dlength + (vrpn_int32) sizeof( vrpn_int32 ) )
1979 {
1980 fprintf( stderr, "vrpn_FunctionGenerator_Server::encode_interpreterDescription_reply: "
1981 "insufficient buffer space given (got %d, wanted %lud).\n",
1982 len, dlength + static_cast<unsigned long>(sizeof( vrpn_int32 )) );
1983 fflush( stderr );
1984 return -1;
1985 }
1986 if( 0 > vrpn_buffer( buf, &len, dlength ) )
1987 {
1988 fprintf( stderr, "vrpn_FunctionGenerator_Server::encode_interpreterDescription_reply: "
1989 "unable to buffer description length.\n" );
1990 fflush( stderr );
1991 return -1;
1992 }
1993
1994 return vrpn_buffer( buf, &len, desc, dlength );
1995}
1996
1997
1999decode_interpreterDescription_reply( const char* buf, const vrpn_int32 len, char** desc )
2000{
2001#ifdef DEBUG_VRPN_FUNCTION_GENERATOR
2002 fprintf( stdout, "FG::decode_interpreterDescription_reply\n" );
2003 fflush( stdout );
2004#endif
2005 if( static_cast<unsigned>(len) < sizeof( vrpn_int32 ) )
2006 {
2007 fprintf( stderr, "vrpn_FunctionGenerator_Remote::decode_interpreterDescription_reply: "
2008 "insufficient buffer space given (got %d, wanted at least %lud).\n",
2009 len, static_cast<unsigned long>(sizeof( vrpn_int32)) );
2010 fflush( stderr );
2011 return -1;
2012 }
2013 vrpn_int32 dlength = 0;
2014 if( 0 > vrpn_unbuffer( &buf, &dlength ) )
2015 {
2016 fprintf( stderr, "vrpn_FunctionGenerator_Remote::decode_interpreterDescription_reply: "
2017 "unable to unbuffer description length.\n" );
2018 fflush( stderr );
2019 return -1;
2020 }
2021 try { *desc = new char[dlength + 1]; }
2022 catch (...) {
2023 fprintf(stderr, "vrpn_FunctionGenerator_Remote::decode_interpreterDescription_reply: "
2024 "Out of memory.\n");
2025 fflush(stderr);
2026 return -1;
2027 }
2028 int retval = vrpn_unbuffer( &buf, *desc, dlength );
2029 (*desc)[dlength] = '\0';
2030 return retval;
2031}
2032
2033
2035encode_error_report( char** buf, vrpn_int32& len, const FGError error, const vrpn_int32 channel )
2036{
2037#ifdef DEBUG_VRPN_FUNCTION_GENERATOR
2038 fprintf( stdout, "FG::encode_error_report\n" );
2039 fflush( stdout );
2040#endif
2041 if( static_cast<unsigned>(len) < sizeof( FGError ) + sizeof( vrpn_int32 ) )
2042 {
2043 fprintf( stderr, "vrpn_FunctionGenerator_Server::encode_error_report: "
2044 "insufficient buffer space given (got %d, wanted %lud).\n",
2045 len, static_cast<unsigned long>(sizeof( FGError) + sizeof( vrpn_int32 )) );
2046 fflush( stderr );
2047 return -1;
2048 }
2049 vrpn_int32 mylen = len;
2050 if( 0 > vrpn_buffer( buf, &mylen, error ) || 0 > vrpn_buffer( buf, &mylen, channel ) )
2051 {
2052 fprintf( stderr, "vrpn_FunctionGenerator_Server::encode_error_report: "
2053 "unable to buffer error & channel" );
2054 fflush( stderr );
2055 return -1;
2056 }
2057 len = mylen;
2058 return 0;
2059}
2060
2061
2063decode_error_reply( const char* buf, const vrpn_int32 len, FGError& error, vrpn_int32& channel )
2064{
2065#ifdef DEBUG_VRPN_FUNCTION_GENERATOR
2066 fprintf( stdout, "FG::decode_error_reply\n" );
2067 fflush( stdout );
2068#endif
2069 if( static_cast<unsigned>(len) < sizeof( FGError ) + sizeof( vrpn_int32 ) )
2070 {
2071 fprintf( stderr, "vrpn_FunctionGenerator_Remote::decode_error_reply: "
2072 "insufficient buffer space given (got %d, wanted %lud).\n",
2073 len, static_cast<unsigned long>(sizeof( FGError) + sizeof( vrpn_int32 )) );
2074 fflush( stderr );
2075 return -1;
2076 }
2077 int myError = NO_FG_ERROR;
2078 vrpn_int32 myChannel = -1;
2079 if( 0 > vrpn_unbuffer( &buf, &myError )
2080 || 0 > vrpn_unbuffer( &buf, &myChannel ) )
2081 {
2082 fprintf( stderr, "vrpn_FunctionGenerator_Remote::decode_error_reply: "
2083 "unable to unbuffer error & channel.\n" );
2084 fflush( stderr );
2085 return -1;
2086 }
2087 error = FGError( myError );
2088 channel = myChannel;
2089 return 0;
2090}
2091
2092
2093
2094//
2095// end encode & decode functions for
2096// vrpn_FunctionGenerator_Remote and
2097// vrpn_FunctionGenerator_Server
2099
int register_autodeleted_handler(vrpn_int32 type, vrpn_MESSAGEHANDLER handler, void *userdata, vrpn_int32 sender=vrpn_ANY_SENDER)
Registers a handler with the connection, and remembers to delete at destruction.
vrpn_Connection * d_connection
Connection that this object talks to.
void client_mainloop(void)
Handles functions that all clients should provide in their mainloop() (warning of no server,...
vrpn_MESSAGEHANDLER handler
vrpn_int32 d_sender_id
Sender ID registered with the connection.
void server_mainloop(void)
Handles functions that all servers should provide in their mainloop() (ping/pong, for example) Should...
Class from which all user-level (and other) classes that communicate with vrpn_Connections should der...
virtual int init(void)
Initialize things that the constructor can't. Returns 0 on success, -1 on failure.
int register_handler(void *userdata, HANDLER_TYPE handler)
Call this to add a handler to the list.
int unregister_handler(void *userdata, HANDLER_TYPE handler)
Call this to remove a handler from the list (if it exists)
void call_handlers(const CALLBACK_STRUCT &info)
This will pass the referenced parameter as a const to all the callbacks.
Generic connection class not specific to the transport mechanism.
virtual vrpn_int32 register_message_type(const char *name)
virtual int pack_message(vrpn_uint32 len, struct timeval time, vrpn_int32 type, vrpn_int32 sender, const char *buffer, vrpn_uint32 class_of_service)
Pack a message that will be sent the next time mainloop() is called. Turn off the RELIABLE flag if yo...
virtual int mainloop(const struct timeval *timeout=NULL)=0
Call each time through program main loop to handle receiving any incoming messages and sending any pa...
static int VRPN_CALLBACK handle_sampleRateReply_message(void *userdata, vrpn_HANDLERPARAM p)
virtual int register_sample_rate_reply_handler(void *userdata, vrpn_FUNCTION_SAMPLE_RATE_REPLY_HANDLER handler)
virtual int unregister_start_reply_handler(void *userdata, vrpn_FUNCTION_START_REPLY_HANDLER handler)
vrpn_int32 decode_channel_reply(const char *buf, const vrpn_int32 len, vrpn_uint32 &channelNum)
virtual int register_error_handler(void *userdata, vrpn_FUNCTION_ERROR_HANDLER handler)
virtual void mainloop()
Called once through each main loop iteration to handle updates. Remote object mainloop() should call ...
vrpn_FunctionGenerator_Remote(const char *name, vrpn_Connection *c=NULL)
vrpn_int32 encode_channel_request(char **buf, vrpn_int32 &len, const vrpn_uint32 channelNum)
virtual int unregister_channel_reply_handler(void *userdata, vrpn_FUNCTION_CHANGE_REPLY_HANDLER handler)
vrpn_int32 decode_stop_reply(const char *buf, const vrpn_int32 len, vrpn_bool &isStopped)
vrpn_Callback_List< vrpn_FUNCTION_ERROR_CB > error_list
static int VRPN_CALLBACK handle_error_message(void *userdata, vrpn_HANDLERPARAM p)
vrpn_int32 decode_start_reply(const char *buf, const vrpn_int32 len, vrpn_bool &isStarted)
vrpn_Callback_List< vrpn_FUNCTION_STOP_REPLY_CB > stop_reply_list
vrpn_int32 decode_error_reply(const char *buf, const vrpn_int32 len, FGError &error, vrpn_int32 &channel)
static int VRPN_CALLBACK handle_interpreterReply_message(void *userdata, vrpn_HANDLERPARAM p)
static int VRPN_CALLBACK handle_stopReply_message(void *userdata, vrpn_HANDLERPARAM p)
virtual int unregister_stop_reply_handler(void *userdata, vrpn_FUNCTION_STOP_REPLY_HANDLER handler)
vrpn_Callback_List< vrpn_FUNCTION_START_REPLY_CB > start_reply_list
vrpn_Callback_List< vrpn_FUNCTION_CHANNEL_REPLY_CB > channel_reply_list
virtual int unregister_interpreter_reply_handler(void *userdata, vrpn_FUNCTION_INTERPRETER_REPLY_HANDLER handler)
vrpn_Callback_List< vrpn_FUNCTION_INTERPRETER_REPLY_CB > interpreter_reply_list
virtual int unregister_error_handler(void *userdata, vrpn_FUNCTION_ERROR_HANDLER handler)
virtual int register_start_reply_handler(void *userdata, vrpn_FUNCTION_START_REPLY_HANDLER handler)
vrpn_Callback_List< vrpn_FUNCTION_SAMPLE_RATE_REPLY_CB > sample_rate_reply_list
virtual int unregister_sample_rate_reply_handler(void *userdata, vrpn_FUNCTION_SAMPLE_RATE_REPLY_HANDLER handler)
static int VRPN_CALLBACK handle_channelReply_message(void *userdata, vrpn_HANDLERPARAM p)
virtual int register_stop_reply_handler(void *userdata, vrpn_FUNCTION_STOP_REPLY_HANDLER handler)
vrpn_int32 decode_sampleRate_reply(const char *buf, const vrpn_int32 len)
int setChannel(const vrpn_uint32 channelNum, const vrpn_FunctionGenerator_channel *channel)
vrpn_int32 decode_interpreterDescription_reply(const char *buf, const vrpn_int32 len, char **desc)
static int VRPN_CALLBACK handle_startReply_message(void *userdata, vrpn_HANDLERPARAM p)
int requestChannel(const vrpn_uint32 channelNum)
virtual int register_interpreter_reply_handler(void *userdata, vrpn_FUNCTION_INTERPRETER_REPLY_HANDLER handler)
vrpn_int32 encode_channel(char **buf, vrpn_int32 &len, const vrpn_uint32 channelNum, const vrpn_FunctionGenerator_channel *channel)
int requestSampleRate(const vrpn_float32 rate)
vrpn_int32 encode_sampleRate_request(char **buf, vrpn_int32 &len, const vrpn_float32 sampleRate)
virtual int register_channel_reply_handler(void *userdata, vrpn_FUNCTION_CHANGE_REPLY_HANDLER handler)
virtual void setSampleRate(vrpn_float32 rate)=0
virtual const char * getInterpreterDescription()=0
vrpn_int32 decode_sampleRate_request(const char *buf, const vrpn_int32 len, vrpn_float32 &sampleRate)
virtual void mainloop()
Called once through each main loop iteration to handle updates. Remote object mainloop() should call ...
int sendError(FGError error, vrpn_int32 channel)
vrpn_int32 decode_channel(const char *buf, const vrpn_int32 len, vrpn_uint32 &channelNum, vrpn_FunctionGenerator_channel &channel)
static int VRPN_CALLBACK handle_allChannelRequest_message(void *userdata, vrpn_HANDLERPARAM p)
int sendChannelReply(vrpn_uint32 channelNum)
static int VRPN_CALLBACK handle_start_message(void *userdata, vrpn_HANDLERPARAM p)
vrpn_FunctionGenerator_Server(const char *name, vrpn_uint32 numChannels=vrpn_FUNCTION_CHANNELS_MAX, vrpn_Connection *c=NULL)
static int VRPN_CALLBACK handle_stop_message(void *userdata, vrpn_HANDLERPARAM p)
vrpn_int32 encode_stop_reply(char **buf, vrpn_int32 &len, const vrpn_bool isStopped)
vrpn_int32 encode_error_report(char **buf, vrpn_int32 &len, const FGError err, const vrpn_int32 channel)
vrpn_int32 encode_start_reply(char **buf, vrpn_int32 &len, const vrpn_bool isStarted)
vrpn_int32 encode_channel_reply(char **buf, vrpn_int32 &len, const vrpn_uint32 channelNum)
static int VRPN_CALLBACK handle_channel_message(void *userdata, vrpn_HANDLERPARAM p)
static int VRPN_CALLBACK handle_channelRequest_message(void *userdata, vrpn_HANDLERPARAM p)
vrpn_int32 encode_sampleRate_reply(char **buf, vrpn_int32 &len, const vrpn_float32 sampleRate)
static int VRPN_CALLBACK handle_sample_rate_message(void *userdata, vrpn_HANDLERPARAM p)
static int VRPN_CALLBACK handle_interpreter_request_message(void *userdata, vrpn_HANDLERPARAM p)
vrpn_uint32 setNumChannels(vrpn_uint32 numChannels)
vrpn_int32 decode_channel_request(const char *buf, const vrpn_int32 len, vrpn_uint32 &channelNum)
vrpn_int32 encode_interpreterDescription_reply(char **buf, vrpn_int32 &len, const char *desc)
virtual void setChannel(vrpn_uint32 channelNum, vrpn_FunctionGenerator_channel *channel)=0
void setFunction(vrpn_FunctionGenerator_function *function)
vrpn_int32 decode_from(const char **buf, vrpn_int32 &len)
vrpn_int32 encode_to(char **buf, vrpn_int32 &len) const
vrpn_FunctionGenerator_function * function
vrpn_int32 encode_to(char **buf, vrpn_int32 &len) const
vrpn_float32 generateValues(vrpn_float32 *buf, vrpn_uint32 nValues, vrpn_float32 startTime, vrpn_float32 sampleRate, vrpn_FunctionGenerator_channel *channel) const
vrpn_int32 decode_from(const char **buf, vrpn_int32 &len)
vrpn_FunctionGenerator_function * clone() const
virtual vrpn_float32 generateValues(vrpn_float32 *buf, vrpn_uint32 nValues, vrpn_float32 startTime, vrpn_float32 sampleRate, vrpn_FunctionGenerator_channel *channel) const
vrpn_FunctionGenerator_function * clone() const
vrpn_int32 encode_to(char **buf, vrpn_int32 &len) const
vrpn_int32 decode_from(const char **buf, vrpn_int32 &len)
virtual vrpn_FunctionGenerator_function * clone() const =0
virtual vrpn_int32 encode_to(char **buf, vrpn_int32 &len) const =0
virtual FunctionCode getFunctionCode() const =0
virtual vrpn_int32 decode_from(const char **buf, vrpn_int32 &len)=0
char msgbuf[vrpn_CONNECTION_TCP_BUFLEN]
vrpn_FunctionGenerator_channel * channels[vrpn_FUNCTION_CHANNELS_MAX]
vrpn_FunctionGenerator(const char *name, vrpn_Connection *c=NULL)
virtual int register_types()
Register the types of messages this device sends/receives. Return 0 on success, -1 on fail.
const vrpn_FunctionGenerator_channel * getChannel(vrpn_uint32 channelNum)
vrpn_FunctionGenerator_channel * channel
vrpn_FunctionGenerator::FGError err
This structure is what is passed to a vrpn_Connection message callback.
const char * buffer
struct timeval msg_time
#define VRPN_CALLBACK
const char * vrpn_got_connection
const vrpn_uint32 vrpn_CONNECTION_RELIABLE
Classes of service for messages, specify multiple by ORing them together Priority of satisfying these...
const int vrpn_CONNECTION_TCP_BUFLEN
const char * vrpn_FUNCTION_MESSAGE_TYPE_SAMPLE_RATE_REPLY
const char * vrpn_FUNCTION_MESSAGE_TYPE_CHANNEL_REPLY
const char * vrpn_FUNCTION_MESSAGE_TYPE_CHANNEL_REQUEST
const char * vrpn_FUNCTION_MESSAGE_TYPE_INTERPRETER_REQUEST
const char * vrpn_FUNCTION_MESSAGE_TYPE_ALL_CHANNEL_REQUEST
const char * vrpn_FUNCTION_MESSAGE_TYPE_SAMPLE_RATE
const char * vrpn_FUNCTION_MESSAGE_TYPE_CHANNEL
const char * vrpn_FUNCTION_MESSAGE_TYPE_ERROR
const char * vrpn_FUNCTION_MESSAGE_TYPE_INTERPRETER_REPLY
const char * vrpn_FUNCTION_MESSAGE_TYPE_START
const char * vrpn_FUNCTION_MESSAGE_TYPE_START_REPLY
const char * vrpn_FUNCTION_MESSAGE_TYPE_STOP_REPLY
const char * vrpn_FUNCTION_MESSAGE_TYPE_STOP
const vrpn_uint32 vrpn_FUNCTION_CHANNELS_MAX
void(VRPN_CALLBACK * vrpn_FUNCTION_CHANGE_REPLY_HANDLER)(void *userdata, const vrpn_FUNCTION_CHANNEL_REPLY_CB info)
const char * vrpn_FUNCTION_MESSAGE_TYPE_SAMPLE_RATE_REPLY
void(VRPN_CALLBACK * vrpn_FUNCTION_INTERPRETER_REPLY_HANDLER)(void *userdata, const vrpn_FUNCTION_INTERPRETER_REPLY_CB info)
const char * vrpn_FUNCTION_MESSAGE_TYPE_CHANNEL_REPLY
const char * vrpn_FUNCTION_MESSAGE_TYPE_CHANNEL_REQUEST
const char * vrpn_FUNCTION_MESSAGE_TYPE_INTERPRETER_REQUEST
const char * vrpn_FUNCTION_MESSAGE_TYPE_ALL_CHANNEL_REQUEST
const char * vrpn_FUNCTION_MESSAGE_TYPE_SAMPLE_RATE
const char * vrpn_FUNCTION_MESSAGE_TYPE_CHANNEL
void(VRPN_CALLBACK * vrpn_FUNCTION_SAMPLE_RATE_REPLY_HANDLER)(void *userdata, const vrpn_FUNCTION_SAMPLE_RATE_REPLY_CB info)
const char * vrpn_FUNCTION_MESSAGE_TYPE_ERROR
const char * vrpn_FUNCTION_MESSAGE_TYPE_INTERPRETER_REPLY
const char * vrpn_FUNCTION_MESSAGE_TYPE_START
const char * vrpn_FUNCTION_MESSAGE_TYPE_START_REPLY
const char * vrpn_FUNCTION_MESSAGE_TYPE_STOP_REPLY
void(VRPN_CALLBACK * vrpn_FUNCTION_ERROR_HANDLER)(void *userdata, const vrpn_FUNCTION_ERROR_CB info)
void(VRPN_CALLBACK * vrpn_FUNCTION_START_REPLY_HANDLER)(void *userdata, const vrpn_FUNCTION_START_REPLY_CB info)
void(VRPN_CALLBACK * vrpn_FUNCTION_STOP_REPLY_HANDLER)(void *userdata, const vrpn_FUNCTION_STOP_REPLY_CB info)
const char * vrpn_FUNCTION_MESSAGE_TYPE_STOP
VRPN_API int vrpn_unbuffer(const char **buffer, timeval *t)
Utility routine for taking a struct timeval from a buffer that was sent as a message.
VRPN_API int vrpn_buffer(char **insertPt, vrpn_int32 *buflen, const timeval t)
Utility routine for placing a timeval struct into a buffer that is to be sent as a message.
#define vrpn_gettimeofday
Definition vrpn_Shared.h:99