48 vrpn_int32 nCols, vrpn_int32 nRows,
51 , d_description_sent(false)
52 , d_frames_to_send(-1)
53 , d_dropped_due_to_throttle(0)
82 vrpn_float32 minVal, vrpn_float32 maxVal,
83 vrpn_float32 scale, vrpn_float32 offset)
95 "vrpn_Imager_Server::add_channel(): Scale was zero, set to 1\n");
108 const vrpn_uint16 cMin,
const vrpn_uint16 cMax,
const vrpn_uint16 rMin,
109 const vrpn_uint16 rMax,
const vrpn_uint16 dMin,
const vrpn_uint16 dMax,
110 const struct timeval *time)
114 char *msgbuf = (
char *)fbuf;
115 int buflen =
sizeof(fbuf);
116 struct timeval timestamp;
139 if ((rMax >=
d_nRows) || (rMin > rMax)) {
140 fprintf(stderr,
"vrpn_Imager_Server::send_begin_frame(): Invalid row "
145 if ((cMax >=
d_nCols) || (cMin > cMax)) {
146 fprintf(stderr,
"vrpn_Imager_Server::send_begin_frame(): Invalid "
147 "column range (%d..%d)\n",
151 if ((dMax >=
d_nDepth) || (dMin > dMax)) {
152 fprintf(stderr,
"vrpn_Imager_Server::send_begin_frame(): Invalid depth "
177 vrpn_int32 len =
sizeof(fbuf) - buflen;
182 fprintf(stderr,
"vrpn_Imager_Server::send_begin_frame(): cannot write "
183 "message: tossing\n");
191 const vrpn_uint16 cMin,
const vrpn_uint16 cMax,
const vrpn_uint16 rMin,
192 const vrpn_uint16 rMax,
const vrpn_uint16 dMin,
const vrpn_uint16 dMax,
193 const struct timeval *time)
197 char *msgbuf = (
char *)fbuf;
198 int buflen =
sizeof(fbuf);
199 struct timeval timestamp;
207 if ((rMax >=
d_nRows) || (rMin > rMax)) {
208 fprintf(stderr,
"vrpn_Imager_Server::send_end_frame(): Invalid row "
213 if ((cMax >=
d_nCols) || (cMin > cMax)) {
214 fprintf(stderr,
"vrpn_Imager_Server::send_end_frame(): Invalid column "
219 if ((dMax >=
d_nDepth) || (dMin > dMax)) {
220 fprintf(stderr,
"vrpn_Imager_Server::send_end_frame(): Invalid depth "
245 vrpn_int32 len =
sizeof(fbuf) - buflen;
250 fprintf(stderr,
"vrpn_Imager_Server::send_end_frame(): cannot write "
251 "message: tossing\n");
259 const struct timeval *time)
263 char *msgbuf = (
char *)fbuf;
264 int buflen =
sizeof(fbuf);
265 struct timeval timestamp;
281 vrpn_int32 len =
sizeof(fbuf) - buflen;
286 fprintf(stderr,
"vrpn_Imager_Server::send_discarded_frames(): cannot "
287 "write message: tossing\n");
321 vrpn_int16 chanIndex, vrpn_uint16 cMin, vrpn_uint16 cMax, vrpn_uint16 rMin,
322 vrpn_uint16 rMax,
const vrpn_uint8 *data, vrpn_uint32 colStride,
323 vrpn_uint32 rowStride, vrpn_uint16 nRows,
bool invert_rows,
324 vrpn_uint32 depthStride, vrpn_uint16 dMin, vrpn_uint16 dMax,
325 const struct timeval *time)
329 char *msgbuf =
reinterpret_cast<char *
>(fbuf);
330 int buflen =
sizeof(fbuf);
331 struct timeval timestamp;
342 if ((chanIndex < 0) || (chanIndex >=
d_nChannels)) {
343 fprintf(stderr,
"vrpn_Imager_Server::send_region_using_base_pointer(): "
344 "Invalid channel index (%d)\n",
348 if ((dMax >=
d_nDepth) || (dMin > dMax)) {
349 fprintf(stderr,
"vrpn_Imager_Server::send_region_using_base_pointer(): "
350 "Invalid depth range (%d..%d)\n",
354 if ((rMax >=
d_nRows) || (rMin > rMax)) {
355 fprintf(stderr,
"vrpn_Imager_Server::send_region_using_base_pointer(): "
356 "Invalid row range (%d..%d)\n",
360 if ((cMax >=
d_nCols) || (cMin > cMax)) {
361 fprintf(stderr,
"vrpn_Imager_Server::send_region_using_base_pointer(): "
362 "Invalid column range (%d..%d)\n",
366 if (
static_cast<unsigned>((rMax - rMin + 1) * (cMax - cMin + 1) *
368 fprintf(stderr,
"vrpn_Imager_Server::send_region_using_base_pointer(): "
369 "Region too large (%d,%d,%d to %d,%d,%d)\n",
370 cMin, rMin, dMin, cMax, rMax, dMax);
373 if (invert_rows && (
nRows < rMax)) {
374 fprintf(stderr,
"vrpn_Imager_Server::send_region_using_base_pointer(): "
375 "nRows must not be less than rMax\n");
396 fprintf(stderr,
"vrpn_Imager_Server::send_region_using_base_pointer(): "
397 "Compression not implemented\n");
423 int cols = cMax - cMin + 1;
424 int linelen = cols *
sizeof(data[0]);
425 if (colStride == 1) {
426 for (
unsigned d = dMin; d <= dMax; d++) {
427 for (
unsigned r = rMin; r <= rMax; r++) {
430 rActual = (
nRows - 1) - r;
435 if (buflen < linelen) {
439 &data[d * depthStride + rActual * rowStride + cMin],
447 if (buflen < (
int)(
sizeof(data[0]) * (dMax - dMin + 1) * (rMax - rMin + 1) *
448 (cMax - cMin + 1))) {
451 long rowStep = rowStride;
455 for (
unsigned d = dMin; d <= dMax; d++) {
457 const vrpn_uint8 *rowStart =
458 &data[d * depthStride + rMin * rowStride + cMin];
460 rowStart = &data[d * depthStride +
461 (
nRows - 1 - rMin) * rowStride + cMin];
463 const vrpn_uint8 *copyFrom = rowStart;
464 for (
unsigned r = rMin; r <= rMax; r++) {
465 for (
unsigned c = cMin; c <= cMax; c++) {
466 *
reinterpret_cast<vrpn_uint8 *
>(msgbuf) =
476 buflen -=
sizeof(data[0]) * (rMax - rMin + 1) * (cMax - cMin + 1);
482 vrpn_int32 len =
sizeof(fbuf) - buflen;
485 (
char *)(
void *)fbuf,
487 fprintf(stderr,
"vrpn_Imager_Server::send_region_using_base_pointer(): "
488 "cannot write message: tossing\n");
517 vrpn_int16 chanIndex, vrpn_uint16 cMin, vrpn_uint16 cMax, vrpn_uint16 rMin,
518 vrpn_uint16 rMax,
const vrpn_uint16 *data, vrpn_uint32 colStride,
519 vrpn_uint32 rowStride, vrpn_uint16 nRows,
bool invert_rows,
520 vrpn_uint32 depthStride, vrpn_uint16 dMin, vrpn_uint16 dMax,
521 const struct timeval *time)
525 char *msgbuf = (
char *)fbuf;
526 int buflen =
sizeof(fbuf);
527 struct timeval timestamp;
538 if ((chanIndex < 0) || (chanIndex >=
d_nChannels)) {
539 fprintf(stderr,
"vrpn_Imager_Server::send_region_using_base_pointer(): "
540 "Invalid channel index (%d)\n",
544 if ((dMax >=
d_nDepth) || (dMin > dMax)) {
545 fprintf(stderr,
"vrpn_Imager_Server::send_region_using_base_pointer(): "
546 "Invalid depth range (%d..%d)\n",
550 if ((rMax >=
d_nRows) || (rMin > rMax)) {
551 fprintf(stderr,
"vrpn_Imager_Server::send_region_using_base_pointer(): "
552 "Invalid row range (%d..%d)\n",
556 if ((cMax >=
d_nCols) || (cMin > cMax)) {
557 fprintf(stderr,
"vrpn_Imager_Server::send_region_using_base_pointer(): "
558 "Invalid column range (%d..%d)\n",
562 if (
static_cast<unsigned>((rMax - rMin + 1) * (cMax - cMin + 1) *
564 fprintf(stderr,
"vrpn_Imager_Server::send_region_using_base_pointer(): "
565 "Region too large (%d,%d,%d to %d,%d,%d)\n",
566 cMin, rMin, dMin, cMax, rMax, dMax);
569 if (invert_rows && (
nRows < rMax)) {
570 fprintf(stderr,
"vrpn_Imager_Server::send_region_using_base_pointer(): "
571 "nRows must not be less than rMax\n");
592 fprintf(stderr,
"vrpn_Imager_Server::send_region_using_base_pointer(): "
593 "Compression not implemented\n");
619 int cols = cMax - cMin + 1;
620 int linelen = cols *
sizeof(data[0]);
621 if (colStride == 1) {
622 for (
unsigned d = dMin; d <= dMax; d++) {
623 for (
unsigned r = rMin; r <= rMax; r++) {
626 rActual = (
nRows - 1) - r;
631 if (buflen < linelen) {
635 &data[d * depthStride + rActual * rowStride + cMin],
643 if (buflen < (
int)(
sizeof(data[0]) * (dMax - dMin + 1) * (rMax - rMin + 1) *
644 (cMax - cMin + 1) )) {
647 long rowStep = rowStride;
651 for (
unsigned d = dMin; d <= dMax; d++) {
653 const vrpn_uint16 *rowStart =
654 &data[d * depthStride + rMin * rowStride + cMin];
656 rowStart = &data[d * depthStride +
657 (
nRows - 1 - rMin) * rowStride + cMin];
659 const vrpn_uint16 *copyFrom = rowStart;
660 for (
unsigned r = rMin; r <= rMax; r++) {
661 for (
unsigned c = cMin; c <= cMax; c++) {
662 memcpy(msgbuf, copyFrom,
sizeof(*copyFrom));
672 buflen -=
sizeof(data[0]) * (rMax - rMin + 1) * (cMax - cMin + 1);
676 if (vrpn_big_endian) {
677 fprintf(stderr,
"XXX Imager Region needs swapping on Big-endian\n");
682 vrpn_int32 len =
sizeof(fbuf) - buflen;
687 fprintf(stderr,
"vrpn_Imager_Server::send_region_using_base_pointer(): "
688 "cannot write message: tossing\n");
717 vrpn_int16 chanIndex, vrpn_uint16 cMin, vrpn_uint16 cMax, vrpn_uint16 rMin,
718 vrpn_uint16 rMax,
const vrpn_float32 *data, vrpn_uint32 colStride,
719 vrpn_uint32 rowStride, vrpn_uint16 nRows,
bool invert_rows,
720 vrpn_uint32 depthStride, vrpn_uint16 dMin, vrpn_uint16 dMax,
721 const struct timeval *time)
725 char *msgbuf = (
char *)fbuf;
726 int buflen =
sizeof(fbuf);
727 struct timeval timestamp;
738 if ((chanIndex < 0) || (chanIndex >=
d_nChannels)) {
739 fprintf(stderr,
"vrpn_Imager_Server::send_region_using_base_pointer(): "
740 "Invalid channel index (%d)\n",
744 if ((dMax >=
d_nDepth) || (dMin > dMax)) {
745 fprintf(stderr,
"vrpn_Imager_Server::send_region_using_base_pointer(): "
746 "Invalid depth range (%d..%d)\n",
750 if ((rMax >=
d_nRows) || (rMin > rMax)) {
751 fprintf(stderr,
"vrpn_Imager_Server::send_region_using_base_pointer(): "
752 "Invalid row range (%d..%d)\n",
756 if ((cMax >=
d_nCols) || (cMin > cMax)) {
757 fprintf(stderr,
"vrpn_Imager_Server::send_region_using_base_pointer(): "
758 "Invalid column range (%d..%d)\n",
762 if (
static_cast<unsigned>((rMax - rMin + 1) * (cMax - cMin + 1) *
764 fprintf(stderr,
"vrpn_Imager_Server::send_region_using_base_pointer(): "
765 "Region too large (%d,%d,%d to %d,%d,%d)\n",
766 cMin, rMin, dMin, cMax, rMax, dMax);
769 if (invert_rows && (
nRows < rMax)) {
770 fprintf(stderr,
"vrpn_Imager_Server::send_region_using_base_pointer(): "
771 "nRows must not be less than rMax\n");
792 fprintf(stderr,
"vrpn_Imager_Server::send_region_using_base_pointer(): "
793 "Compression not implemented\n");
819 int cols = cMax - cMin + 1;
820 int linelen = cols *
sizeof(data[0]);
821 if (colStride == 1) {
822 for (
unsigned d = dMin; d <= dMax; d++) {
823 for (
unsigned r = rMin; r <= rMax; r++) {
826 rActual = (
nRows - 1) - r;
831 if (buflen < linelen) {
835 &data[d * depthStride + rActual * rowStride + cMin],
843 if (buflen < (
int)(
sizeof(data[0]) * (dMax - dMin + 1) * (rMax - rMin + 1) *
844 (cMax - cMin + 1))) {
847 long rowStep = rowStride;
851 for (
unsigned d = dMin; d <= dMax; d++) {
853 const vrpn_float32 *rowStart =
854 &data[d * depthStride + rMin * rowStride + cMin];
856 rowStart = &data[d * depthStride +
857 (
nRows - 1 - rMin) * rowStride + cMin];
859 const vrpn_float32 *copyFrom = rowStart;
860 for (
unsigned r = rMin; r <= rMax; r++) {
861 for (
unsigned c = cMin; c <= cMax; c++) {
862 memcpy(msgbuf, copyFrom,
sizeof(*copyFrom));
872 buflen -=
sizeof(data[0]) * (rMax - rMin + 1) * (cMax - cMin + 1);
876 if (vrpn_big_endian) {
877 fprintf(stderr,
"XXX Imager Region needs swapping on Big-endian\n");
882 vrpn_int32 len =
sizeof(fbuf) - buflen;
887 fprintf(stderr,
"vrpn_Imager_Server::send_region_using_base_pointer(): "
888 "cannot write message: tossing\n");
918 vrpn_int16 chanIndex, vrpn_uint16 cMin, vrpn_uint16 cMax, vrpn_uint16 rMin,
919 vrpn_uint16 rMax,
const vrpn_uint8 *data, vrpn_uint32 colStride,
920 vrpn_uint32 rowStride, vrpn_uint16 nRows,
bool invert_rows,
921 vrpn_uint32 depthStride, vrpn_uint16 dMin, vrpn_uint16 dMax,
922 const struct timeval *time)
931 const vrpn_uint8 *new_base =
932 data - (cMin + rowStride * rMin + depthStride * dMin);
934 chanIndex, cMin, cMax, rMin, rMax, new_base, colStride, rowStride,
935 nRows, invert_rows, depthStride, dMin, dMax, time)) {
939 fprintf(stderr,
"vrpn_Imager_Server::send_region_using_first_pointer():"
940 " Call to send using offset base_pointer failed.\n");
968 vrpn_int16 chanIndex, vrpn_uint16 cMin, vrpn_uint16 cMax, vrpn_uint16 rMin,
969 vrpn_uint16 rMax,
const vrpn_uint16 *data, vrpn_uint32 colStride,
970 vrpn_uint32 rowStride, vrpn_uint16 nRows,
bool invert_rows,
971 vrpn_uint32 depthStride, vrpn_uint16 dMin, vrpn_uint16 dMax,
972 const struct timeval *time)
981 const vrpn_uint16 *new_base =
982 data - (cMin + rowStride * rMin + depthStride * dMin);
984 chanIndex, cMin, cMax, rMin, rMax, new_base, colStride, rowStride,
985 nRows, invert_rows, depthStride, dMin, dMax, time)) {
989 fprintf(stderr,
"vrpn_Imager_Server::send_region_using_first_pointer():"
990 " Call to send using offset base_pointer failed.\n");
1018 vrpn_int16 chanIndex, vrpn_uint16 cMin, vrpn_uint16 cMax, vrpn_uint16 rMin,
1019 vrpn_uint16 rMax,
const vrpn_float32 *data, vrpn_uint32 colStride,
1020 vrpn_uint32 rowStride, vrpn_uint16 nRows,
bool invert_rows,
1021 vrpn_uint32 depthStride, vrpn_uint16 dMin, vrpn_uint16 dMax,
1022 const struct timeval *time)
1031 const vrpn_float32 *new_base =
1032 data - (cMin + rowStride * rMin + depthStride * dMin);
1034 chanIndex, cMin, cMax, rMin, rMax, new_base, colStride, rowStride,
1035 nRows, invert_rows, depthStride, dMin, dMax, time)) {
1039 fprintf(stderr,
"vrpn_Imager_Server::send_region_using_first_pointer():"
1040 " Call to send using offset base_pointer failed.\n");
1049 char *msgbuf = (
char *)fbuf;
1050 int buflen =
sizeof(fbuf);
1051 struct timeval timestamp;
1060 fprintf(stderr,
"vrpn_Imager_Server::send_description(): Can't pack "
1061 "message header, tossing\n");
1065 if (!
d_channels[i].buffer(&msgbuf, &buflen)) {
1066 fprintf(stderr,
"vrpn_Imager_Server::send_description(): Can't "
1067 "pack message channel, tossing\n");
1074 vrpn_int32 len =
sizeof(fbuf) - buflen;
1080 fprintf(stderr,
"vrpn_Imager_Server::send_description(): cannot write "
1081 "message: tossing\n");
1095 "vrpn_Imager_Server::set_resolution(): Invalid size (%d, %d, %d)\n",
1117 const char *bufptr = p.
buffer;
1121 vrpn_int32 frames_to_send;
1129 if (frames_to_send < 0) {
1163 , d_got_description(false)
1213 const char *bufptr = p.
buffer;
1241 const char *bufptr = p.
buffer;
1259 fprintf(stderr,
"vrpn_Imager_Remote::handle_region_message(): Can't "
1260 "unbuffer parameters!\n");
1270 fprintf(stderr,
"vrpn_Imager_Remote::handle_region_message(): "
1271 "Compression not implemented\n");
1293 const char *bufptr = p.
buffer;
1301 fprintf(stderr,
"vrpn_Imager_Remote::handle_begin_frame_message(): "
1302 "Can't unbuffer parameters!\n");
1319 const char *bufptr = p.
buffer;
1327 fprintf(stderr,
"vrpn_Imager_Remote::handle_end_frame_message(): Can't "
1328 "unbuffer parameters!\n");
1345 const char *bufptr = p.
buffer;
1351 fprintf(stderr,
"vrpn_Imager_Remote::handle_discarded_frames_message():"
1352 " Can't unbuffer parameters!\n");
1381 char *msgbuf = (
char *)fbuf;
1382 int buflen =
sizeof(fbuf);
1383 struct timeval timestamp;
1387 fprintf(stderr,
"vrpn_ImagerPose_Server::throttle_sender(): Can't pack "
1388 "message header, tossing\n");
1394 vrpn_int32 len =
sizeof(fbuf) - buflen;
1400 fprintf(stderr,
"vrpn_ImagerPose_Server::throttle_sender(): cannot "
1401 "write message: tossing\n");
1442 vrpn_uint8 *data, vrpn_uint32 colStride, vrpn_uint32 rowStride,
1443 vrpn_uint32 depthStride, vrpn_uint16 nRows,
bool invert_rows,
1444 unsigned repeat)
const
1447 if (colStride < repeat) {
1448 fprintf(stderr,
"vrpn_Imager_Region::decode_unscaled_region_using_base_"
1449 "pointer(): colStride must be >= repeat\n");
1453 if (invert_rows && (nRows <
d_rMax)) {
1454 fprintf(stderr,
"vrpn_Imager_Region::decode_unscaled_region_using_base_"
1455 "pointer(): nRows must not be less than _rMax\n");
1474 int linelen = cols *
sizeof(data[0]);
1475 if ((colStride == 1) && (repeat == 1)) {
1476 const vrpn_uint8 *msgbuf = (
const vrpn_uint8 *)
d_valBuf;
1481 rActual = (nRows - 1) - r;
1487 &data[d * depthStride + rActual * rowStride +
d_cMin],
1494 long rowStep = rowStride;
1498 const vrpn_uint8 *msgbuf = (
const vrpn_uint8 *)
d_valBuf;
1500 vrpn_uint8 *rowStart =
1501 &data[d * depthStride +
d_rMin * rowStride +
1504 rowStart = &data[d * depthStride +
1505 (nRows - 1 -
d_rMin) * rowStride +
1508 vrpn_uint8 *copyTo = rowStart;
1511 for (
unsigned rpt = 0; rpt < repeat; rpt++) {
1519 rowStart += rowStep;
1533 if (vrpn_big_endian) {
1534 fprintf(stderr,
"XXX Imager Region needs swapping on Big-endian\n");
1538 long rowStep = rowStride;
1542 const vrpn_float32 *msgbuf = (
const vrpn_float32 *)
d_valBuf;
1544 vrpn_uint8 *rowStart =
1545 &data[d * depthStride +
d_rMin * rowStride +
d_cMin * repeat];
1548 &data[d * depthStride + (nRows - 1 -
d_rMin) * rowStride +
1551 vrpn_uint8 *copyTo = rowStart;
1554 for (
unsigned rpt = 0; rpt < repeat; rpt++) {
1555 *(copyTo + rpt) =
static_cast<vrpn_uint8
>(
1559 copyTo += colStride;
1561 rowStart += rowStep;
1569 long rowStep = rowStride;
1573 const vrpn_uint16 *msgbuf = (
const vrpn_uint16 *)
d_valBuf;
1575 vrpn_uint8 *rowStart =
1576 &data[d * depthStride +
d_rMin * rowStride +
d_cMin * repeat];
1579 &data[d * depthStride + (nRows - 1 -
d_rMin) * rowStride +
1582 vrpn_uint8 *copyTo = rowStart;
1585 for (
unsigned rpt = 0; rpt < repeat; rpt++) {
1586 *(copyTo + rpt) =
static_cast<vrpn_uint8
>(
1591 copyTo += colStride;
1593 rowStart += rowStep;
1599 printf(
"vrpn_Imager_Region::decode_unscaled_region_using_base_pointer()"
1600 ": Transcoding not implemented yet for this type\n");
1611 vrpn_uint16 *data, vrpn_uint32 colStride, vrpn_uint32 rowStride,
1612 vrpn_uint32 depthStride, vrpn_uint16 nRows,
bool invert_rows,
1613 unsigned repeat)
const
1616 if (colStride < repeat) {
1617 fprintf(stderr,
"vrpn_Imager_Region::decode_unscaled_region_using_base_"
1618 "pointer(): colStride must be >= repeat\n");
1621 if (invert_rows && (nRows <
d_rMax)) {
1622 fprintf(stderr,
"vrpn_Imager_Region::decode_unscaled_region_using_base_"
1623 "pointer(): nRows must not be less than _rMax\n");
1644 int linelen = cols *
sizeof(data[0]);
1645 if ((colStride == 1) && (repeat == 1)) {
1646 const vrpn_uint16 *msgbuf = (
const vrpn_uint16 *)
d_valBuf;
1651 rActual = (nRows - 1) - r;
1657 &data[d * depthStride + rActual * rowStride +
d_cMin],
1664 long rowStep = rowStride;
1668 const vrpn_uint16 *msgbuf = (
const vrpn_uint16 *)
d_valBuf;
1670 vrpn_uint16 *rowStart =
1671 &data[d * depthStride +
d_rMin * rowStride +
1674 rowStart = &data[d * depthStride +
1675 (nRows - 1 -
d_rMin) * rowStride +
1678 vrpn_uint16 *copyTo = rowStart;
1681 for (
unsigned rpt = 0; rpt < repeat; rpt++) {
1689 rowStart += rowStep;
1705 long rowStep = rowStride;
1709 const vrpn_uint8 *msgbuf = (
const vrpn_uint8 *)
d_valBuf;
1711 vrpn_uint16 *rowStart =
1712 &data[d * depthStride +
d_rMin * rowStride +
d_cMin * repeat];
1715 &data[d * depthStride + (nRows - 1 -
d_rMin) * rowStride +
1718 vrpn_uint16 *copyTo = rowStart;
1721 for (
unsigned rpt = 0; rpt < repeat; rpt++) {
1724 (
static_cast<vrpn_uint16
>(*msgbuf) << 8);
1727 copyTo += colStride;
1729 rowStart += rowStep;
1735 fprintf(stderr,
"vrpn_Imager_Region::decode_unscaled_region_using_base_"
1736 "pointer(): XXX Transcoding this type not yet "
1742 if (vrpn_big_endian) {
1743 fprintf(stderr,
"XXX Imager Region needs swapping on Big-endian\n");
1751 vrpn_float32 *data, vrpn_uint32 colStride, vrpn_uint32 rowStride,
1752 vrpn_uint32 depthStride, vrpn_uint16 nRows,
bool invert_rows,
1753 unsigned repeat)
const
1756 if (colStride < repeat) {
1757 fprintf(stderr,
"vrpn_Imager_Region::decode_unscaled_region_using_base_"
1758 "pointer(): colStride must be >= repeat\n");
1765 printf(
"vrpn_Imager_Region::decode_unscaled_region_using_base_pointer()"
1766 ": Transcoding not implemented yet\n");
1769 if (invert_rows && (nRows <
d_rMax)) {
1770 fprintf(stderr,
"vrpn_Imager_Region::decode_unscaled_region_using_base_"
1771 "pointer(): nRows must not be less than _rMax\n");
1785 int linelen = cols *
sizeof(data[0]);
1786 if ((colStride == 1) && (repeat == 1)) {
1787 const vrpn_float32 *msgbuf = (
const vrpn_float32 *)
d_valBuf;
1792 rActual = (nRows - 1) - r;
1797 memcpy(&data[d * depthStride + rActual * rowStride +
d_cMin],
1804 long rowStep = rowStride;
1808 const vrpn_float32 *msgbuf = (
const vrpn_float32 *)
d_valBuf;
1810 vrpn_float32 *rowStart =
1811 &data[d * depthStride +
d_rMin * rowStride +
d_cMin * repeat];
1814 &data[d * depthStride + (nRows - 1 -
d_rMin) * rowStride +
1817 vrpn_float32 *copyTo = rowStart;
1820 for (
unsigned rpt = 0; rpt < repeat; rpt++) {
1821 *(copyTo + rpt) = *msgbuf;
1824 copyTo += colStride;
1826 rowStart += rowStep;
1833 if (vrpn_big_endian) {
1834 fprintf(stderr,
"XXX Imager Region needs swapping on Big-endian\n");
1866 vrpn_uint16 col, vrpn_uint16 row,
1870 if (center == NULL) {
1873 "vrpn_ImagerPose::compute_pixel_center(): NULL center pointer\n");
1878 if ((col >= image.
nCols()) || (row >= image.
nRows()) ||
1879 (depth >= image.
nDepth())) {
1880 fprintf(stderr,
"vrpn_ImagerPose::compute_pixel_center(): Pixel index "
1892 vrpn_float64 stepC = 1.0 / image.
nCols();
1893 vrpn_float64 stepR = 1.0 / image.
nRows();
1894 vrpn_float64 stepD = 1.0 / image.
nDepth();
1897 (0.5 + row) * stepR *
d_dRow[0] +
1898 (0.5 + depth) * stepD *
d_dDepth[0];
1900 (0.5 + row) * stepR *
d_dRow[1] +
1901 (0.5 + depth) * stepD *
d_dDepth[1];
1903 (0.5 + row) * stepR *
d_dRow[2] +
1904 (0.5 + depth) * stepD *
d_dDepth[2];
1910 const char *name,
const vrpn_float64 origin[3],
const vrpn_float64 dCol[3],
1911 const vrpn_float64 dRow[3],
const vrpn_float64 *dDepth,
vrpn_Connection *c)
1917 if (dDepth != NULL) {
1934 const vrpn_float64 dCol[3],
1935 const vrpn_float64 dRow[3],
1936 const vrpn_float64 *dDepth)
1941 if (dDepth != NULL) {
1951 char *msgbuf = (
char *)fbuf;
1952 int buflen =
sizeof(fbuf);
1953 struct timeval timestamp;
1969 fprintf(stderr,
"vrpn_ImagerPose_Server::send_description(): Can't "
1970 "pack message header, tossing\n");
1976 vrpn_int32 len =
sizeof(fbuf) - buflen;
1982 fprintf(stderr,
"vrpn_ImagerPose_Server::send_description(): cannot "
1983 "write message: tossing\n");
2012 const char *bufptr = p.
buffer;
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_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...
vrpn_int32 d_ping_message_id
Ask the server if they are there.
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.
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...
vrpn_ImagerPose_Remote(const char *name, vrpn_Connection *c=NULL)
static int VRPN_CALLBACK handle_description_message(void *userdata, vrpn_HANDLERPARAM p)
Handler for resolution and channel list message from the server.
virtual void mainloop(void)
Call this each time through the program's main loop.
vrpn_Callback_List< struct timeval > d_description_list
static int VRPN_CALLBACK handle_ping_message(void *userdata, vrpn_HANDLERPARAM p)
bool send_description(void)
Sends a description of the imager so the remote can process the region messages.
bool set_range(const vrpn_float64 origin[3], const vrpn_float64 dCol[3], const vrpn_float64 dRow[3], const vrpn_float64 *dDepth=NULL)
Set the range or units. Return true on success.
vrpn_ImagerPose_Server(const char *name, const vrpn_float64 origin[3], const vrpn_float64 dCol[3], const vrpn_float64 dRow[3], const vrpn_float64 *dDepth=NULL, vrpn_Connection *c=NULL)
virtual void mainloop(void)
Handle baseclass ping/pong messages.
vrpn_ImagerPose(const char *name, vrpn_Connection *c=NULL)
vrpn_int32 d_description_m_id
bool compute_pixel_center(vrpn_float64 *center, const vrpn_Imager &image, vrpn_uint16 col, vrpn_uint16 row, vrpn_uint16 depth=0)
This will return the location of the center of the specified.
virtual int register_types(void)
Register the types of messages this device sends/receives. Return 0 on success, -1 on fail.
Holds the description needed to convert from raw data to values for a channel.
ChannelCompression d_compression
bool unbuffer(const char **buffer)
Helper function to convert data for a sub-region of one channel of.
bool decode_unscaled_region_using_base_pointer(vrpn_uint8 *data, vrpn_uint32 colStride, vrpn_uint32 rowStride, vrpn_uint32 depthStride=0, vrpn_uint16 nRows=0, bool invert_rows=false, unsigned repeat=1) const
As efficiently as possible, pull the values out of the VRPN buffer and put them into the array whose ...
This is the class users deal with: it tells the format and the region data when it arrives.
static int VRPN_CALLBACK handle_begin_frame_message(void *userdata, vrpn_HANDLERPARAM p)
Handler for begin-frame message from the server.
static int VRPN_CALLBACK handle_discarded_frames_message(void *userdata, vrpn_HANDLERPARAM p)
Handler for discarded-frames message from the server.
vrpn_Callback_List< vrpn_IMAGERBEGINFRAMECB > d_begin_frame_list
const vrpn_Imager_Channel * channel(unsigned chanNum) const
Accessors for the member variables: can be queried in the handler for object changes.
virtual void mainloop(void)
XXX It could be nice to let the user specify separate callbacks for.
static int VRPN_CALLBACK handle_description_message(void *userdata, vrpn_HANDLERPARAM p)
Handler for resolution and channel list message from the server.
vrpn_Callback_List< vrpn_IMAGERENDFRAMECB > d_end_frame_list
vrpn_Callback_List< vrpn_IMAGERDISCARDEDFRAMESCB > d_discarded_frames_list
virtual bool throttle_sender(vrpn_int32 N)
Request that the server send at most N more frames until a new request is sent.
static int VRPN_CALLBACK handle_connection_dropped_message(void *userdata, vrpn_HANDLERPARAM p)
Handler for connection dropped message.
static int VRPN_CALLBACK handle_end_frame_message(void *userdata, vrpn_HANDLERPARAM p)
Handler for end-frame message from the server.
static int VRPN_CALLBACK handle_region_message(void *userdata, vrpn_HANDLERPARAM p)
Handler for region update message from the server.
vrpn_Imager_Remote(const char *name, vrpn_Connection *c=NULL)
vrpn_Callback_List< struct timeval > d_description_list
vrpn_Callback_List< vrpn_IMAGERREGIONCB > d_region_list
int add_channel(const char *name, const char *units="unsigned8bit", vrpn_float32 minVal=0, vrpn_float32 maxVal=255, vrpn_float32 scale=1, vrpn_float32 offset=0)
Add a channel to the server, returns index of the channel or -1 on failure.
vrpn_int32 d_frames_to_send
bool send_region_using_base_pointer(vrpn_int16 chanIndex, vrpn_uint16 cMin, vrpn_uint16 cMax, vrpn_uint16 rMin, vrpn_uint16 rMax, const vrpn_uint8 *data, vrpn_uint32 colStride, vrpn_uint32 rowStride, vrpn_uint16 nRows=0, bool invert_rows=false, vrpn_uint32 depthStride=0, vrpn_uint16 dMin=0, vrpn_uint16 dMax=0, const struct timeval *time=NULL)
Pack and send the region as efficiently as possible; strides are in steps of the element being sent.
bool set_resolution(vrpn_int32 nCols, vrpn_int32 nRows, vrpn_int32 nDepth=1)
Set the resolution to a different value than it had been before. Returns true on success.
vrpn_Imager_Server(const char *name, vrpn_Connection *c, vrpn_int32 nCols, vrpn_int32 nRows, vrpn_int32 nDepth=1)
static int VRPN_CALLBACK handle_throttle_message(void *userdata, vrpn_HANDLERPARAM p)
static int VRPN_CALLBACK handle_last_drop_message(void *userdata, vrpn_HANDLERPARAM p)
bool send_begin_frame(const vrpn_uint16 cMin, const vrpn_uint16 cMax, const vrpn_uint16 rMin, const vrpn_uint16 rMax, const vrpn_uint16 dMin=0, const vrpn_uint16 dMax=0, const struct timeval *time=NULL)
Servers must send begin/end frame pairs around contiguous sections of the image.
vrpn_uint16 d_dropped_due_to_throttle
bool send_end_frame(const vrpn_uint16 cMin, const vrpn_uint16 cMax, const vrpn_uint16 rMin, const vrpn_uint16 rMax, const vrpn_uint16 dMin=0, const vrpn_uint16 dMax=0, const struct timeval *time=NULL)
bool send_discarded_frames(const vrpn_uint16 count=0, const struct timeval *time=NULL)
bool send_description(void)
Sends a description of the imager so the remote can process the region messages.
bool send_region_using_first_pointer(vrpn_int16 chanIndex, vrpn_uint16 cMin, vrpn_uint16 cMax, vrpn_uint16 rMin, vrpn_uint16 rMax, const vrpn_uint8 *data, vrpn_uint32 colStride, vrpn_uint32 rowStride, vrpn_uint16 nRows=0, bool invert_rows=false, vrpn_uint32 depthStride=0, vrpn_uint16 dMin=0, vrpn_uint16 dMax=0, const struct timeval *time=NULL)
Pack and send the region as efficiently as possible; strides are in steps of the element being sent.
static int VRPN_CALLBACK handle_ping_message(void *userdata, vrpn_HANDLERPARAM p)
virtual void mainloop(void)
Handle baseclass ping/pong messages.
Base class for Imager class.
vrpn_int32 d_description_m_id
vrpn_int32 nDepth(void) const
vrpn_int32 d_regionf32_m_id
virtual int register_types(void)
Register the types of messages this device sends/receives. Return 0 on success, -1 on fail.
vrpn_int32 nCols(void) const
vrpn_Imager(const char *name, vrpn_Connection *c=NULL)
vrpn_int32 d_throttle_frames_m_id
vrpn_int32 d_begin_frame_m_id
vrpn_int32 d_regionu8_m_id
vrpn_int32 d_end_frame_m_id
vrpn_int32 d_regionu12in16_m_id
vrpn_int32 nRows(void) const
vrpn_int32 d_regionu16_m_id
vrpn_int32 d_discarded_frames_m_id
vrpn_Imager_Channel d_channels[vrpn_IMAGER_MAX_CHANNELS]
This structure is what is passed to a vrpn_Connection message callback.
const vrpn_Imager_Region * region
const char * vrpn_dropped_last_connection
const char * vrpn_dropped_connection
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_ANY_SENDER
vrpn_ANY_SENDER can be used to register callbacks on a given message type from any sender.
const int vrpn_CONNECTION_TCP_BUFLEN
const unsigned vrpn_IMAGER_MAX_REGIONf32
const vrpn_uint16 vrpn_IMAGER_VALTYPE_FLOAT32
const unsigned vrpn_IMAGER_MAX_REGIONu8
Set of constants to tell how many points you can put into a region depending on the type you are putt...
const vrpn_uint16 vrpn_IMAGER_VALTYPE_UINT16
const unsigned vrpn_IMAGER_MAX_REGIONu16
const vrpn_uint16 vrpn_IMAGER_VALTYPE_UINT8
const vrpn_uint16 vrpn_IMAGER_VALTYPE_UINT12IN16
const unsigned vrpn_IMAGER_MAX_CHANNELS
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.
void vrpn_strcpy(char(&to)[charCount], const char *pSrc)
Null-terminated-string copy function that both guarantees not to overrun the buffer and guarantees th...
#define vrpn_gettimeofday