home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 January / usenetsourcesnewsgroupsinfomagicjanuary1994.iso / sources / sun / volume3 / netfone next >
Text File  |  1991-10-25  |  38KB  |  1,356 lines
  1. Path: uunet!seismo!dimacs.rutgers.edu!aramis.rutgers.edu!athos.rutgers.edu!mcgrew
  2. From: mcgrew@athos.rutgers.edu (Charles Mcgrew)
  3. Newsgroups: comp.sources.sun
  4. Subject: v03i008:  netfone - speak over the network via sparcstations
  5. Message-ID: <Oct.25.11.58.35.1991.27806@athos.rutgers.edu>
  6. Date: 25 Oct 91 15:58:37 GMT
  7. Organization: Rutgers Univ., New Brunswick, N.J.
  8. Lines: 1345
  9. Approved: mcgrew@aramis.rutgers.edu
  10.  
  11. Submitted-by: John Walker <autodesk!throop!kelvin@uunet.uu.net>
  12. Posting-number: Volume 3, Issue 8
  13. Archive-name: netfone
  14.  
  15.  
  16. Chatting away over the network, courtesy of SPARCStations and your Ethernet
  17. or handy-dandy "via satellite" leased line....
  18.  
  19.                                NetFone
  20.                 Voice Communication Over Data Networks
  21.  
  22.                             by John Walker
  23.                  Revision 2  --  12th September 1991
  24.  
  25. The  phone  company never gives you a break!  You finally spring for a
  26. leased line so you can be right on the network  with  everybody  else,
  27. and you *still* have to pay every time you want to chat with somebody,
  28. even though you're both sitting in front of SPARCStations with digital
  29. audio capability, linked with a high-bandwidth network.
  30.  
  31. NetFone  uses  the  workstation  audio  chip  and  network  to   allow
  32. bidirectional  conversations  right  over  the  network.  Workstations
  33. linked by Ethernet can  generally  communicate  with  excellent  audio
  34. quality  and response.  Those linked by 56 Kb lines can also talk over
  35. the network, but with lower fidelity compressed audio that fits within
  36. the capacity of the data link.
  37.  
  38. Complete instructions for building, installing, and using NetFone  are
  39. given  in the manual page, netfone.1.  You can view the manual page on
  40. your screen with the command:
  41.  
  42.     make manpage
  43.  
  44. Building NetFone requires the audio library, "libaudio.a", supplied by
  45. Sun  in  SunOS 4.1.1 in /usr/demo/SOUND and the include files found in
  46. /usr/demo/SOUND/multimedia.  These  files  will  be  present  on  your
  47. workstation only if the "Demos" installation option was selected.  The
  48. multimedia support files from Sun appear to be in  a  rapid  state  of
  49. flux  and  you may need to change the directory names from which these
  50. files are accessed in the Makefile and/or adapt the source programs to
  51. accommodate changes made by Sun in subsequent versions of SunOS.
  52.  
  53. This program is in the public domain: "Do what thou wilt shall be  the
  54. whole  of  the  law".   I'd  appreciate receiving any bug fixes and/or
  55. enhancements,  which  I'll  incorporate  in  future  versions  of  the
  56. program.   Please leave the original attribution information intact so
  57. that credit and blame may be properly apportioned.
  58.  
  59. AUTHOR
  60.             John Walker
  61.             Autodesk SA
  62.             Avenue des Champs-Montants 14b
  63.             CH-2074 MARIN
  64.             Suisse/Schweiz/Svizzera/Svizra/Switzerland
  65.             Usenet: kelvin@Autodesk.com
  66.             Fax:    038/33 88 15
  67.             Voice:  038/33 76 33
  68.  
  69. ----------------------------- Cut here ----------------------- netfone.shar
  70. #! /bin/sh
  71. # This is a shell archive, meaning:
  72. # 1. Remove everything above the #! /bin/sh line.
  73. # 2. Save the resulting text in a file.
  74. # 3. Execute the file with /bin/sh (not csh) to create the files:
  75. #    README
  76. #    Makefile
  77. #    mike.c
  78. #    netfone.1
  79. #    soundbyte.c
  80. #    speaker.c
  81. # This archive created: Sat Sep 14 00:59:56 1991
  82. export PATH; PATH=/bin:$PATH
  83. echo shar: extracting "'README'" '(2296 characters)'
  84. if test -f 'README'
  85. then
  86.        echo shar: will not over-write existing file "'README'"
  87. else
  88. cat << \SHAR_EOF > 'README'
  89.  
  90.                                NetFone
  91.                 Voice Communication Over Data Networks
  92.  
  93.                             by John Walker
  94.                  Revision 2  --  12th September 1991
  95.  
  96. The  phone  company never gives you a break!  You finally spring for a
  97. leased line so you can be right on the network  with  everybody  else,
  98. and you *still* have to pay every time you want to chat with somebody,
  99. even though you're both sitting in front of SPARCStations with digital
  100. audio capability, linked with a high-bandwidth network.
  101.  
  102. NetFone  uses  the  workstation  audio  chip  and  network  to   allow
  103. bidirectional  conversations  right  over  the  network.  Workstations
  104. linked by Ethernet can  generally  communicate  with  excellent  audio
  105. quality  and response.  Those linked by 56 Kb lines can also talk over
  106. the network, but with lower fidelity compressed audio that fits within
  107. the capacity of the data link.
  108.  
  109. Complete instructions for building, installing, and using NetFone  are
  110. given  in the manual page, netfone.1.  You can view the manual page on
  111. your screen with the command:
  112.  
  113.     make manpage
  114.  
  115. Building NetFone requires the audio library, "libaudio.a", supplied by
  116. Sun  in  SunOS 4.1.1 in /usr/demo/SOUND and the include files found in
  117. /usr/demo/SOUND/multimedia.  These  files  will  be  present  on  your
  118. workstation only if the "Demos" installation option was selected.  The
  119. multimedia support files from Sun appear to be in  a  rapid  state  of
  120. flux  and  you may need to change the directory names from which these
  121. files are accessed in the Makefile and/or adapt the source programs to
  122. accommodate changes made by Sun in subsequent versions of SunOS.
  123.  
  124. This program is in the public domain: "Do what thou wilt shall be  the
  125. whole  of  the  law".   I'd  appreciate receiving any bug fixes and/or
  126. enhancements,  which  I'll  incorporate  in  future  versions  of  the
  127. program.   Please leave the original attribution information intact so
  128. that credit and blame may be properly apportioned.
  129.  
  130. AUTHOR
  131.             John Walker
  132.             Autodesk SA
  133.             Avenue des Champs-Montants 14b
  134.             CH-2074 MARIN
  135.             Suisse/Schweiz/Svizzera/Svizra/Switzerland
  136.             Usenet: kelvin@Autodesk.com
  137.             Fax:    038/33 88 15
  138.             Voice:  038/33 76 33
  139. SHAR_EOF
  140. fi # end of overwriting check
  141. echo shar: extracting "'Makefile'" '(1757 characters)'
  142. if test -f 'Makefile'
  143. then
  144.        echo shar: will not over-write existing file "'Makefile'"
  145. else
  146. cat << \SHAR_EOF > 'Makefile'
  147.  
  148. #    NetFone: Make file
  149.  
  150. #   Directory where the Sun sound utilities, including libaudio.a
  151. #   are installed.
  152. SOUND = /usr/demo/SOUND
  153.  
  154. #   Directory where the #include files for the Sun sound utilities
  155. #   are installed.
  156. MULTIMEDIA = $(SOUND)/multimedia
  157.  
  158. #   Internet socket port used by mike and speaker.  If you change this,
  159. #   you will not be able to exchange sound with users who've built
  160. #   NetFone with different values.
  161. INTERNET_PORT = 2074
  162.  
  163. #   Program name (shar will be $(PROG).shar)
  164. PROG =    netfone
  165.  
  166. #   Source files distributed in the .shar archive.
  167. SFILES = README Makefile mike.c netfone.1 soundbyte.c speaker.c
  168.  
  169. #   Special modes, if any, for C compilations.
  170. MODES = -O
  171.  
  172. CARGS = -I$(MULTIMEDIA) -DInternet_Port=$(INTERNET_PORT)
  173.  
  174. CFLAGS = $(MODES) $(CARGS)
  175.  
  176. all:    speaker mike
  177.  
  178. SPKROBJS = speaker.o soundbyte.o
  179.  
  180. speaker: $(SPKROBJS)
  181.     cc $(SPKROBJS) $(SOUND)/libaudio.a -lm -o speaker
  182.  
  183. MIKEOBJS = mike.o soundbyte.o
  184.  
  185. mike:    $(MIKEOBJS)
  186.     cc $(MIKEOBJS) -lm -o mike
  187.  
  188. speaker.o: speaker.c
  189.  
  190. mike.o: mike.c
  191.  
  192. manpage:
  193.     nroff -man netfone.1 | more
  194.  
  195. printman:
  196.     ptroff netfone.1 -man
  197.  
  198. shar:
  199.     shar -b -v $(SFILES) >$(PROG).shar
  200.  
  201. #   Note: the following LINT line feeds both main programs and the the
  202. #      subroutine file they share to LINT so  that  it  can    detect
  203. #      unused functions in the library, soundbyte.c This results in
  204. #      a harmless warning about the duplicate definition of main().
  205. #      NetFone  is  *not*  lint-free.   I  cannot  bring  myself to
  206. #      butcher the source to the extent that would be required.
  207. lint:
  208.     lint $(CARGS) mike.c speaker.c soundbyte.c
  209.  
  210. spell:
  211.     spell -b netfone.1 | fmt
  212.     spell -b README    | fmt
  213.  
  214. clean:
  215.     rm -f core *.out *.o *.bak *.shar speaker mike
  216.  
  217. backup:
  218.     mt -f $(TAPE) rew
  219.     tar cfbv $(TAPE) 126 *
  220.     mt -f $(TAPE) rew
  221. SHAR_EOF
  222. fi # end of overwriting check
  223. echo shar: extracting "'mike.c'" '(9498 characters)'
  224. if test -f 'mike.c'
  225. then
  226.        echo shar: will not over-write existing file "'mike.c'"
  227. else
  228. cat << \SHAR_EOF > 'mike.c'
  229. /*
  230.  
  231.     NetFone: Network sound transmission program
  232.  
  233.     Designed and implemented in July of 1991 by John Walker
  234.  
  235. */
  236.  
  237. #include <stdio.h>
  238. #include <fcntl.h>
  239. #include <sys/types.h>
  240. #include <sys/socket.h>
  241. #include <netinet/in.h>
  242. #include <netdb.h>
  243.  
  244. struct soundbuf {
  245.     int compression;
  246.     char sendinghost[16];
  247.     struct {
  248.         int buffer_len;
  249.         char buffer_val[8000];
  250.     } buffer;
  251. };
  252. typedef struct soundbuf soundbuf;
  253.  
  254. #define TRUE    1
  255. #define FALSE    0
  256.  
  257. static int sock;              /* Communication socket */
  258.  
  259. #define V    (void)
  260.  
  261. /*  Destination host descriptor.  */
  262.  
  263. struct destination {
  264.     struct destination *dnext;
  265.     char *server;
  266.     struct sockaddr_in name;
  267. };
  268.  
  269. static struct destination *dests = NULL, *dtail;
  270. static int compressing = FALSE;       /* Compress sound buffers */
  271. static int squelch = 0;           /* Squelch level if > 0 */
  272. static int ring = FALSE;          /* Force speaker & level on next pkt ? */
  273. static int agc = TRUE;              /* Automatic gain control active ? */
  274. static int rgain = 33;              /* Current recording gain level */
  275. static int debugging = FALSE;          /* Debugging enabled here and there ? */
  276. static char hostname[20];          /* Host name to send with packets */
  277. static int loopback = FALSE;          /* Remote loopback mode */
  278.  
  279. /*  ADDEST  --    Add destination host to host list.  */
  280.  
  281. static int addest(host)
  282.   char *host;
  283. {
  284.     struct destination *d;
  285.     struct hostent *hp, *gethostbyname();
  286.  
  287.     hp = gethostbyname(host);
  288.     if (hp == 0) {
  289.         fprintf(stderr, "%s: unknown host\n", host);
  290.     return FALSE;
  291.     }
  292.  
  293.     d = (struct destination *) malloc(sizeof(struct destination));
  294.     d->dnext = NULL;
  295.     d->server = host;
  296.     bcopy((char *) hp->h_addr, (char *) &(d->name.sin_addr), hp->h_length);
  297.     d->name.sin_family = AF_INET;
  298.     d->name.sin_port = htons(Internet_Port);
  299.     if (dests == NULL) {
  300.     dests = d;
  301.     } else {
  302.     dtail->dnext = d;
  303.     }
  304.     dtail = d;
  305.     return TRUE;
  306. }
  307.  
  308. /*  SENDMSG  --  Send a message to all active destinations.  */
  309.  
  310. static int sendmsg(sb)
  311.   struct soundbuf *sb;
  312. {
  313.     struct destination *d;
  314.  
  315.     for (d = dests; d != NULL; d = d->dnext) {
  316.     if (sendto(sock, sb, (sizeof(struct soundbuf)) - (8000 - sb->buffer.buffer_len),
  317.     0, (struct sockaddr *) &(d->name), sizeof d->name) < 0) {
  318.         perror("sending datagram message");
  319.     return FALSE;
  320.     }
  321.     }
  322.     return TRUE;
  323. }
  324.  
  325. /*  SENDFILE  --  Send a file or, if the file name is NULL or a
  326.           single period, send real-time sound input. */
  327.  
  328. static int sendfile(f)
  329.   char *f;
  330. { 
  331.     soundbuf netbuf;
  332. #define buf netbuf.buffer.buffer_val
  333.     int nread;
  334.     FILE *afile = NULL;
  335.  
  336.     strcpy(netbuf.sendinghost, hostname);
  337.     if (f != NULL && (strcmp(f, ".") != 0)) {
  338.         afile = fopen(f, "r");
  339.     if (afile == NULL) {
  340.             fprintf(stderr, "Unable to open sound file %s.\n", f);
  341.         return 2;
  342.     }
  343.     }
  344.  
  345.     /* Send a file */
  346.  
  347.     if (afile) {
  348.     while ((nread = fread(buf, 1, sizeof buf, afile)) > 0) {
  349.         netbuf.compression = FALSE | (ring ? 4 : 0);
  350.         ring = FALSE;
  351.         netbuf.compression |= debugging ? 2 : 0;
  352.         netbuf.compression |= loopback ? 16 : 0;
  353.         if (compressing) {
  354.         int i;
  355.  
  356.         nread /= 2;
  357.         for (i = 1; i < nread; i++) {
  358.             buf[i] = buf[i * 2];
  359.         }
  360.         netbuf.compression |= 1;
  361.         }
  362.         netbuf.buffer.buffer_len = nread;
  363.         if (!sendmsg(&netbuf)) {
  364.         fclose(afile);
  365.         return 1;
  366.         }
  367.         /* Horrible kludge.  Fake flow control by sleeping for about
  368.            long enough for the buffer to play. */
  369.  
  370.         usleep(950 * ((nread * (compressing ? 2 : 1)) / 8L));
  371.     }
  372.  
  373.     if (debugging) {
  374.             fprintf(stderr, "Sent sound file %s.\n", f);
  375.     }
  376.     fclose(afile);
  377.     } else {
  378.  
  379.     /* Send real-time sound. */
  380.  
  381.     if (!soundinit(O_RDONLY /* | O_NDELAY */ )) {
  382.             fprintf(stderr, "Unable to initialise audio.\n");
  383.         return 2;
  384.     }
  385.     if (agc) {
  386.         soundrecgain(rgain);      /* Set initial record level */
  387.     }
  388.     if (soundrecord()) {
  389.         while (TRUE) {
  390.         int soundel = soundgrab(buf, sizeof buf);
  391.         unsigned char *bs = (unsigned char *) buf;
  392.  
  393.         if (soundel > 0) {
  394.             register unsigned char *start = bs;
  395.             register int j;
  396.             int squelched = (squelch > 0);
  397.  
  398.             /* If entire buffer is less than squelch, ditch it. */
  399.  
  400.             if (squelch > 0) {
  401.             for (j = 0; j < soundel; j++) {
  402.                 if (((*start++ & 0x7F) ^ 0x7F) > squelch) {
  403.                 squelched = FALSE;
  404.                 break;
  405.                 }
  406.             }
  407.             }
  408.  
  409.             if (squelched) {
  410.             if (debugging) {
  411.                             printf("Entire buffer squelched.\n");
  412.             }
  413.             } else {
  414.             netbuf.compression = FALSE | (ring ? 4 : 0);
  415.             netbuf.compression |= debugging ? 2 : 0;
  416.             netbuf.compression |= loopback ? 16 : 0;
  417.  
  418.             /* If automatic gain control is enabled,
  419.                ride the gain pot to fill the dynamic range
  420.                optimally. */
  421.  
  422.             if (agc) {
  423.                 register unsigned char *start = bs;
  424.                 register int j;
  425.                 long msamp = 0;
  426.  
  427.                 for (j = 0; j < soundel; j++) {
  428.                 int tsamp = ((*start++ & 0x7F) ^ 0x7F);
  429.  
  430.                 msamp += tsamp;
  431.                 }
  432.                 msamp /= soundel;
  433.                 if (msamp < 0x30) {
  434.                 if (rgain < 100) {
  435.                     soundrecgain(++rgain);
  436.                 }
  437.                 } else if (msamp > 0x35) {
  438.                 if (rgain > 1) {
  439.                     soundrecgain(--rgain);
  440.                 }
  441.                 }
  442.             }
  443.  
  444.             ring = FALSE;
  445.             if (compressing) {
  446.                 int i;
  447.  
  448.                 soundel /= 2;
  449.                 for (i = 1; i < soundel; i++) {
  450.                 buf[i] = buf[i * 2];
  451.                 }
  452.                 netbuf.compression |= 1;
  453.             }
  454.             netbuf.buffer.buffer_len = soundel;
  455.             if (!sendmsg(&netbuf)) {
  456.                 return 1;
  457.             }
  458.             }
  459.         } else {
  460.             usleep(100000L);  /* Wait for some sound to arrive */
  461.         }
  462.         }
  463.     } else {
  464.             fprintf(stderr, "Unable to start recording.\n");
  465.         return 2;
  466.     }
  467.     }
  468.     return 0;
  469. }
  470.  
  471. /*  USAGE  --  Print how-to-call information.  */
  472.  
  473. static void usage()
  474. {
  475.     V fprintf(stderr, "mike  --  Sound transmission tool.\n");
  476.     V fprintf(stderr, "\n");
  477.     V fprintf(stderr, "Usage: mike hostname <options> [ file1 / . ]...\n");
  478.     V fprintf(stderr, "Options: (* indicates defaults)\n");
  479.     V fprintf(stderr, "           -C         Compress subsequent sound\n");
  480.     V fprintf(stderr, "           -D         Enable debug output\n");
  481.     V fprintf(stderr, "     *     -G         Automatic gain control\n");
  482.     V fprintf(stderr, "           -L         Remote loopback\n");
  483.     V fprintf(stderr, "           -M         Manual record gain control\n");
  484.     V fprintf(stderr, "     *     -N         Do not compress subsequent sound\n");
  485.     V fprintf(stderr, "           -Phostname Party line, add host to list\n");
  486.     V fprintf(stderr, "     *     -Q         Disable debug output\n");
  487.     V fprintf(stderr, "           -R         Ring--force volume, output to speaker\n");
  488.     V fprintf(stderr, "           -Sn        Squelch at level n (0-255)\n");
  489.     V fprintf(stderr, "           -U         Print this message\n");
  490.     V fprintf(stderr, "\n");
  491.     V fprintf(stderr, "par John Walker\n");
  492.     V fprintf(stderr, "    Autodesk SA Neuch\342tel\n");
  493.     V fprintf(stderr, "    Avenue des Champs-Montants 14b\n");
  494.     V fprintf(stderr, "    CH-2074 MARIN\n");
  495.     V fprintf(stderr, "    Suisse/Schweiz/Svizzera/Svizra/Switzerland\n");
  496.     V fprintf(stderr, "    Usenet: kelvin@Autodesk.com\n");
  497.     V fprintf(stderr, "    Fax:    038/33 88 15\n");
  498.     V fprintf(stderr, "    Voice:  038/33 76 33\n");
  499. }
  500.  
  501. /*  Main program.  */
  502.  
  503. main(argc, argv)
  504.   int argc;
  505.   char *argv[];
  506. {
  507.     int i, sentfile = 0;
  508.  
  509.     gethostname(hostname, sizeof hostname);
  510.  
  511.     /* Create the socket used to send data. */
  512.  
  513.     sock = socket(AF_INET, SOCK_DGRAM, 0);
  514.     if (sock < 0) {
  515.         perror("opening datagram socket");
  516.     return 1;
  517.     }
  518.  
  519.     /*    Process command line options.  */
  520.  
  521.     for (i = 1; i < argc; i++) {
  522.     char *op, opt;
  523.  
  524.     op = argv[i];
  525.         if (*op == '-') {
  526.         opt = *(++op);
  527.         if (islower(opt))
  528.         opt = toupper(opt);
  529.         switch (opt) {
  530.  
  531.                 case 'C':             /* -C  -- Compress sound samples */
  532.             compressing = TRUE;
  533.             break;
  534.  
  535.                 case 'D':             /* -D  --  Enable debug output  */
  536.             debugging = TRUE;
  537.             break;
  538.  
  539.                 case 'G':             /* -G  --  Automatic gain control */
  540.             agc = TRUE;
  541.             break;
  542.  
  543.                 case 'L':             /* -L  --  Remote loopback */
  544.             loopback = TRUE;
  545.             break;
  546.  
  547.                 case 'M':             /* -M  --  Manual record gain control */
  548.             agc = FALSE;
  549.             break;
  550.  
  551.                 case 'N':             /* -N  --  Do not compress sound samples */
  552.             compressing = FALSE;
  553.             break;
  554.  
  555.                 case 'P':             /* -Phost  --  Copy output to host  */
  556.             if (!addest(op + 1)) {
  557.             return 1;
  558.             }
  559.             break;
  560.  
  561.                 case 'Q':             /* -Q  --  Disable debug output  */
  562.             debugging = FALSE;
  563.             break;
  564.  
  565.                 case 'R':             /* -R  --  Ring: divert output to speaker */
  566.             ring = TRUE;
  567.             break;
  568.  
  569.                 case 'S':             /* -Sn  --  Squelch at level n */
  570.             if (strlen(op + 1) == 0) {
  571.             squelch = 50; /* Default squelch */
  572.             } else {
  573.             squelch = atoi(op + 1);
  574.             }
  575.             break;
  576.  
  577.                 case 'U':             /* -U  --  Print usage information */
  578.                 case '?':             /* -?  --  Print usage information */
  579.             usage();
  580.             return 0;
  581.         }
  582.     } else {
  583.         if (dests == NULL) {
  584.         if (!addest(op)) {
  585.             return 1;
  586.         }
  587.         } else {
  588.         int ok = sendfile(op);
  589.         if (ok != 0)
  590.             return ok;
  591.         sentfile++;
  592.         }
  593.     }
  594.     }
  595.  
  596.     if (dests == NULL) {
  597.     usage();
  598.     } else {
  599.     if (sentfile == 0) {
  600.         return sendfile(NULL);
  601.     }
  602.     }
  603.  
  604.     return 0;
  605. }
  606. SHAR_EOF
  607. fi # end of overwriting check
  608. echo shar: extracting "'netfone.1'" '(10566 characters)'
  609. if test -f 'netfone.1'
  610. then
  611.        echo shar: will not over-write existing file "'netfone.1'"
  612. else
  613. cat << \SHAR_EOF > 'netfone.1'
  614. '\" t
  615. .TH NETFONE 1 "12 SEP 1991"
  616. .UC 4
  617. .SH NAME
  618. mike, speaker \- Voice communication over a network
  619. .SH SYNOPSIS
  620. .B speaker
  621. .LP
  622. .B mike
  623. .I hostname
  624. [
  625. .B \-cdglmnqru
  626. ] [
  627. .BI \-p hostname
  628. ] [
  629. .BI \-s level
  630. ] [
  631. .I soundfile ...
  632. ]
  633. .SH DESCRIPTION
  634. .B netfone
  635. is an application that allows users with Sun SPARCStations connected
  636. by a network to converse, using the audio input and output facilities
  637. of the SPARCStation to digitise and later reconstruct the sound and
  638. the network to relay sound packets.  Audio files recorded with
  639. .BR record (6)
  640. or
  641. .BR soundtool (6)
  642. may be transmitted and played on remote workstations as well.
  643. Optional compression is provided, allowing conversations
  644. (albeit with lower quality audio) to take place over 56 Kb links as
  645. well as local Ethernet connections.
  646.  
  647. .B netfone 
  648. consists of two programs,
  649. .B mike
  650. and
  651. .BR speaker .
  652. The
  653. .B speaker
  654. program must be running on a workstation to allow it to receive
  655. sound sent with the
  656. .B mike
  657. program.  You can execute
  658. .B speaker
  659. in the background or install it as a standard daemon by
  660. adding the line:
  661.  
  662. .B "    speaker &"
  663.  
  664. to the end of your
  665. .B /etc/rc.local
  666. file.
  667.  
  668. You can send audio to workstation
  669. .I hostname
  670. running the
  671. .B speaker
  672. program with:
  673.  
  674. .BI "    mike " hostname
  675.  
  676. which sends real-time audio from the microphone jack, or:
  677.  
  678. .B "    mike "
  679. .I hostname
  680. .I soundfile
  681.  
  682. where
  683. .I soundfile
  684. is one or more files of prerecorded sound created with
  685. .BR soundtool (6)
  686. or
  687. .BR record (6).
  688. If
  689. .I soundfile
  690. is a single period, real-time audio from the microphone jack is
  691. selected.  This permits you to send one or more sound files, then
  692. switch to live audio all in a single command.
  693.  
  694. .BR mike " and " speaker
  695. are normally used in conjunction with the Sun program
  696. .BR gaintool (6)
  697. which allows interactive setting of the audio record and playback
  698. levels with a SunView tool.
  699. .B gaintool
  700. is supplied by Sun as part of the
  701. .I Demos
  702. installation option.
  703.  
  704. It's perfectly valid to send audio to a copy of
  705. .B speaker
  706. running on the same workstation as
  707. .BR mike .
  708. In fact, it's a very handy way to experiment.
  709.  
  710. .SH "BUILDING AND INSTALLING"
  711.  
  712. To install
  713. .B netfone
  714. on your Sun workstation, extract it from the
  715. archive in which it was delivered into a directory of its own.
  716. With this directory as the current directory, say:
  717.  
  718. .B "    make"
  719.  
  720. to build the programs.  You may wish to install the
  721. .B mike
  722. and
  723. .B speaker
  724. programs in a library directory so they will be generally accessible.
  725. This manual page, which may be displayed on the terminal with:
  726.  
  727. .B "    make manpage"
  728.  
  729. should be copied into your local manual page directory.
  730.  
  731. .SH OPTIONS
  732. .B speaker
  733. has no options and is totally non-interactive.  The following
  734. options may be specified on
  735. .BR mike .
  736. Options are processed left to right and sound files are sent with
  737. the modes specified by options to their left on the command line.
  738. .TP 10
  739. .B \-c
  740. Compress sound.
  741. .B mike
  742. normally transmits sound at the standard rate of
  743. 8000 samples per second.  When compression is enabled, this
  744. rate is halved to 4000 samples per second which reduces the bandwidth
  745. to that which can be accommodated by a 56 Kb line (which
  746. has a capacity of a little more than 6000 bytes per second).  The
  747. elided samples are reconstructed at the receiving end by
  748. .BR speaker .
  749. Compression reduces the audio quality, but the result is generally
  750. intelligible and certainly much better than the random pauses
  751. and lost words that occur if you try to send full bandwidth audio
  752. over a 56 Kb line.  Both sound files and real time audio may be
  753. compressed.  Compression of real time audio works best if the
  754. input audio signal is subjected to a 2 Khz low-pass filter; if
  755. higher frequency components are present they will cause aliasing
  756. in the sampling process, which can do strange things to the sound.
  757. Using a ``communications microphone'' rather than a full bandwidth
  758. microphone helps if you don't have access to a signal processor or
  759. equaliser to limit the bandwidth.
  760. .TP
  761. .B \-d
  762. Enables debug output from
  763. .I both
  764. the local copy of
  765. .B mike
  766. and the receiving copy of
  767. .BR speaker .
  768. .TP
  769. .B \-g
  770. Automatic gain control is enabled for real-time audio. The
  771. recording gain is dynamically adjusted to compensate for the
  772. amplitude of the sound received, using the maximum dynamic
  773. range without clipping.  If this switch is specified, the
  774. record gain cannot be manually set with
  775. .BR gaintool .
  776. Automatic gain control is on by default.
  777. .TP
  778. .B \-l
  779. Remote loopback is enabled.  Each packet received by
  780. .B speaker
  781. will be immediately transmitted back to a copy of
  782. .B speaker
  783. running on the originating machine.  You can use loopback to
  784. evaluate the quality of transmission over various kinds of
  785. communication links without the need to have a person at the
  786. other end.
  787. .TP
  788. .B \-m
  789. Manual gain control.  Allows you to manually set the recording level
  790. with
  791. .BR gaintool .
  792. .TP
  793. .B \-n
  794. Disables compression of sound.  This is the default; the switch
  795. permits canceling the effect of a previous
  796. .B \-c
  797. switch when sending multiple sound files with one
  798. .B mike
  799. command.
  800. .TP
  801. .BI \-p hostname
  802. Adds
  803. .I hostname
  804. to the list of hosts to which the sound is sent.  The first
  805. host is specified explicitly on the
  806. .B mike
  807. command line.  You may name additional hosts, all of which must be
  808. running
  809. .BR speaker ,
  810. to create a ``party line''.  The same sound will be sent to each
  811. host you name.  If you're on a 56 Kb line instead of an Ethernet,
  812. transmitting to multiple hosts will result in unacceptable delays
  813. and lost words; there simply isn't enough bandwidth to send duplicate
  814. packets.
  815. .TP
  816. .B \-q
  817. Quiet--disables debug output.  This is the default; the switch can be
  818. used to cancel the effect of a prior
  819. .B \-d
  820. switch.
  821. .TP
  822. .B \-r
  823. Ring.  This is used to get the attention of a user when you're
  824. trying to establish a connection.  The output, which the user may
  825. have diverted to the headphone jack, is forced to go to the
  826. workstation speaker and the playback volume is set to mid-level
  827. to guarantee audibility.  The receiving user may subsequently
  828. switch the output back to the headphones, if desired, with
  829. .BR gaintool .
  830. .TP
  831. .BI \-s level
  832. Squelch output whenever input volume is below the specified
  833. .IR level .
  834. The
  835. .I level
  836. specification is an arbitrary number from 1 to 255 with larger
  837. numbers denoting louder sound.  The default squelch value, if none
  838. is given on the
  839. .B \-s
  840. switch, is 50 which works reasonably well unless your computer room is
  841. very noisy (in which case you might want to avail yourself of a
  842. headset with a directional boom microphone).  Squelch interacts poorly
  843. with automatic gain control; if you wish to use squelch, specify the
  844. .B \-m
  845. switch and set the gain with
  846. .B gaintool
  847. for the best results.  Squelch is off by default, equivalent to a
  848. specification of
  849. .BR \-s0 .
  850. Enabling squelch allows multiple people to send sound to the same
  851. destination(s) and, as long as only one speaks at a time, for the
  852. result to be intelligible.  In order for this to work the recording
  853. and squelch levels must be set so that sound is sent only when you're
  854. talking.  Enabling debugging output with the
  855. .B \-d
  856. switch may help to determine the best settings.
  857. .TP
  858. .B \-u
  859. Prints how-to-call information.
  860. .SH FILES
  861. Audio is read and written from the
  862. .B /dev/audio
  863. device file.  The device will be busy for input whenever
  864. .B mike
  865. is running.  The
  866. .B speaker
  867. program acquires the audio device upon receiving sound, but automatically
  868. releases
  869. .B /dev/audio
  870. for output after 20 seconds elapse without any sound having been
  871. received.
  872. .SH BUGS
  873. .PP
  874. If sound from multiple sources arrives simultaneously at one machine,
  875. .B speaker
  876. interleaves the audio packet-by-packet.  This usually results in
  877. unintelligible gibberish, although it's normally adequate to allow
  878. ``butting into'' a conversation.  It might be possible to have
  879. .B speaker
  880. mix the sound into one output stream, but I haven't experimented
  881. with this approach.
  882. .PP
  883. No warning is given if the destination workstation is not running
  884. .BR speaker ;
  885. sound just disappears.
  886. .PP
  887. In order to deliver acceptable (or at least tolerable) performance across
  888. international satellite links,
  889. .BR mike " and " speaker
  890. use ``Internet datagram'' socket protocol which is essentially a
  891. ``fire and forget'' mechanism; neither flow control nor acknowledgement
  892. are provided.  Since sound most be delivered at the correct time in order
  893. to be intelligible, for real-time transmission there's little one can
  894. do anyway if data are lost.  Consequently, bogged down lines, transmission
  895. errors, etc., simply degrade or destroy the quality of the audio without
  896. providing explicit warnings at either end that anything's amiss.
  897. In addition, the lack of an end-to-end handshake deprives
  898. .B speaker
  899. of backpressure information to control the rate at which it dispatches
  900. packets when transmitting a sound file.  I fake flow control by calculating
  901. the time it will take to play each packet and causing
  902. .B speaker
  903. to
  904. .B usleep(\|) 
  905. that number of microseconds after sending it.  This is, of course,
  906. utterly beneath contempt, but it actually works quite nicely
  907. (at least as long as your machine isn't busy).  If you're motivated to
  908. replace all this datagram stuff with nice, clean RPC calls, don't bother.
  909. That's how I built the initial version of
  910. .BR netfone ,
  911. and although it ran OK on an Ethernet, it was a disaster on 56 Kb lines.
  912. .PP
  913. Acceptable performance over a 56 Kb line requires the line to be close
  914. to idle.  If file transfers or other bulk traffic are underway, you'll
  915. probably be disappointed.
  916. .PP
  917. SunOS 4.1 or above is required to build and use these programs.  As of
  918. this writing, Sun's multimedia support is in a state of rapid flux.
  919. You should expect changes from release to release which may require
  920. modifications to how these programs are built or within the programs
  921. themselves.  This version has been tested on SunOS 4.1.1.
  922. .PP
  923. .BR mike " and " speaker
  924. communicate using Internet port number 2074.  It is
  925. conceivable, although unlikely, that this might conflict with some other
  926. locally-developed network server.  You can change the port number by
  927. editing the
  928. .B Makefile
  929. to change the definition of ``INTERNET_PORT'' and rebuilding, but then your
  930. versions of
  931. .BR mike " and " speaker
  932. won't communicate with others that use the standard port number.
  933.  
  934. .ne 2
  935. .SH "SEE ALSO"
  936. .PD
  937. .BR audio (4),
  938. .BR gaintool (6),
  939. .BR rc (8),
  940. .BR record (6),
  941. .BR soundtool (6),
  942. .BR talk (1),
  943. .BR usleep (3)
  944.  
  945. .ne 10
  946. .SH AUTHOR
  947. .RS 5
  948. .nf
  949. John Walker
  950. Autodesk SA
  951. Avenue des Champs-Montants 14b
  952. CH-2074 MARIN
  953. Suisse/Schweiz/Svizzera/Svizra/Switzerland
  954. Usenet: kelvin@Autodesk.com
  955. Fax:    038/33 88 15
  956. Voice:  038/33 76 33
  957. .fi
  958. .RE
  959. SHAR_EOF
  960. fi # end of overwriting check
  961. echo shar: extracting "'soundbyte.c'" '(3658 characters)'
  962. if test -f 'soundbyte.c'
  963. then
  964.        echo shar: will not over-write existing file "'soundbyte.c'"
  965. else
  966. cat << \SHAR_EOF > 'soundbyte.c'
  967. /*
  968.  
  969.     NetFone: Sound interface functions
  970.  
  971.     Designed and implemented in July of 1991 by John Walker
  972.  
  973. */
  974.  
  975. #include <sys/types.h>
  976. #include <sys/dir.h>
  977. #include <sys/file.h>
  978.  
  979. #include <math.h>
  980. #include <fcntl.h>
  981. #include <errno.h>
  982. #include <stdio.h>
  983. #include <assert.h>
  984.  
  985. #include <sys/ioctl.h>
  986. #include <sun/audioio.h>
  987.  
  988. #define SoundFile       "/dev/audio"
  989. #define AUDIO_CTLDEV    "/dev/audioctl"
  990.  
  991. #define MAX_GAIN    100
  992.  
  993. #define TRUE  1
  994. #define FALSE 0
  995.  
  996. #define V     (void)
  997.  
  998. struct sound_buf {
  999.     struct sound_buf *snext;          /* Next sound buffer */
  1000.     int sblen;                  /* Length of this sound buffer */
  1001.     unsigned char sbtext[2];          /* Actual sampled sound */
  1002. };
  1003.  
  1004. /*  Local variables  */
  1005.  
  1006. static int audiof = -1;           /* Audio device file descriptor */
  1007. static int Audio_fd;              /* Audio control port */
  1008. static audio_info_t Audio_info;       /* Current configuration info */
  1009. static int recording = FALSE;          /* Recording in progress ? */
  1010.  
  1011. /*  Forward functions  */
  1012.  
  1013. void soundpoll();
  1014.  
  1015. /* Convert local gain into device parameters */
  1016.  
  1017. static unsigned scale_gain(g)
  1018.   unsigned g;
  1019. {
  1020.     return (AUDIO_MIN_GAIN + (unsigned)
  1021.     irint(((double) (AUDIO_MAX_GAIN - AUDIO_MIN_GAIN)) *
  1022.     ((double)g / (double)MAX_GAIN)));
  1023. }
  1024.  
  1025.  
  1026. /*  SOUNDINIT  --  Open the sound peripheral and initialise for
  1027.            access.  Return TRUE if successful, FALSE
  1028.            otherwise.  */
  1029.  
  1030. int soundinit(iomode)
  1031.   int iomode;
  1032. {
  1033.     assert(audiof == -1);
  1034.     if ((audiof = open(SoundFile, iomode)) >= 0) {
  1035.  
  1036.     if ((Audio_fd = open(AUDIO_CTLDEV, O_RDWR)) < 0) {
  1037.         perror(AUDIO_CTLDEV);
  1038.         return FALSE;
  1039.     }
  1040.     return TRUE;
  1041.     }
  1042.     return FALSE;
  1043. }
  1044.  
  1045. /*  SOUNDTERM  --  Close the sound device.  */
  1046.  
  1047. void soundterm()
  1048. {
  1049.     if (audiof >= 0) {
  1050.        V close(audiof);
  1051.        V close(Audio_fd);
  1052.        audiof = -1;
  1053.     }
  1054. }
  1055.  
  1056. /*  SOUNDRECORD  --  Begin recording of sound.    */
  1057.  
  1058. int soundrecord()
  1059. {
  1060.     assert(!recording);
  1061.     recording = TRUE;
  1062.     return recording;
  1063. }
  1064.  
  1065. /*  SOUNDPLAY  --  Begin playing a sound.  */
  1066.  
  1067. void soundplay(len, buf)
  1068.   int len;
  1069.   unsigned char *buf;
  1070. {
  1071.     int ios;
  1072.  
  1073.     assert(audiof != -1);
  1074.     while (TRUE) {
  1075.     ios = write(audiof, buf, len);
  1076.     if (ios == -1) {
  1077.         usleep(100000);
  1078.     } else {
  1079.         if (ios < len) {
  1080.         buf += ios;
  1081.         len -= ios;
  1082.         } else {
  1083.         break;
  1084.         }
  1085.     }
  1086.     }
  1087. }
  1088.  
  1089. /*  SOUNDPLAYVOL  --  Set playback volume from 0 (silence) to 100 (full on). */
  1090.  
  1091. void soundplayvol(value)
  1092.   int value;
  1093. {
  1094.     AUDIO_INITINFO(&Audio_info);
  1095.     Audio_info.play.gain = scale_gain(value);
  1096.     if (ioctl(Audio_fd, AUDIO_SETINFO, &Audio_info) < 0) {
  1097.         perror("Set play volume");
  1098.     }
  1099. }
  1100.  
  1101. /*  SOUNDRECGAIN  --  Set recording gain from 0 (minimum) to 100 (maximum).  */
  1102.  
  1103. void soundrecgain(value)
  1104.   int value;
  1105. {
  1106.     AUDIO_INITINFO(&Audio_info);
  1107.     Audio_info.record.gain = scale_gain(value);
  1108.     if (ioctl(Audio_fd, AUDIO_SETINFO, &Audio_info) < 0) {
  1109.         perror("Set record gain");
  1110.     }
  1111. }
  1112.  
  1113. /*  SOUNDDEST  --  Set destination for generated sound.  If "where"
  1114.            is 0, sound goes to the built-in speaker; if
  1115.            1, to the audio output jack. */
  1116.  
  1117. void sounddest(where)
  1118.   int where;
  1119. {
  1120.     AUDIO_INITINFO(&Audio_info);
  1121.     Audio_info.play.port = (where == 0 ? AUDIO_SPEAKER : AUDIO_HEADPHONE);
  1122.     if (ioctl(Audio_fd, AUDIO_SETINFO, &Audio_info) < 0) {
  1123.         perror("Set output port");
  1124.     }
  1125. }
  1126.  
  1127. /*  SOUNDGRAB  --  Return audio information in the record queue.  */
  1128.  
  1129. int soundgrab(buf, len)
  1130.     char *buf;
  1131.     int len;
  1132. {
  1133.     if (recording) {
  1134.     long read_size;
  1135.  
  1136.     if (ioctl(audiof, FIONREAD, &read_size) < 0) {
  1137.             perror("FIONREAD ioctl failed");
  1138.     } else {
  1139.         if (read_size > len)
  1140.         read_size = len;
  1141.         read(audiof, buf, read_size);
  1142.         return read_size;
  1143.     }
  1144.     }
  1145.     return 0;
  1146. }
  1147. SHAR_EOF
  1148. fi # end of overwriting check
  1149. echo shar: extracting "'speaker.c'" '(5225 characters)'
  1150. if test -f 'speaker.c'
  1151. then
  1152.        echo shar: will not over-write existing file "'speaker.c'"
  1153. else
  1154. cat << \SHAR_EOF > 'speaker.c'
  1155. /*
  1156.  
  1157.     NetFone: Network sound play server
  1158.  
  1159.     Designed and implemented in July of 1991 by John Walker.
  1160.  
  1161. */
  1162.  
  1163. #include <stdio.h>
  1164. #include <fcntl.h>
  1165. #include <assert.h>
  1166. #include <signal.h>
  1167. #include "ulaw2linear.h"
  1168. #include <sys/types.h>
  1169. #include <sys/socket.h>
  1170. #include <netinet/in.h>
  1171. #include <netdb.h>
  1172.  
  1173. struct soundbuf {
  1174.     int compression;
  1175.     char sendinghost[16];
  1176.     struct {
  1177.         int buffer_len;
  1178.         char buffer_val[8000];
  1179.     } buffer;
  1180. };
  1181. typedef struct soundbuf soundbuf;
  1182.  
  1183. #define TRUE    1
  1184. #define FALSE    0
  1185.  
  1186. static int audiok = FALSE;          /* Audio initialised flag */
  1187. static int audiotime = 0;          /* Audio timeout counter */
  1188. static int debugging = FALSE;          /* Debugging enabled */
  1189. static char echost[24] = "";          /* Last echo host */
  1190.  
  1191. #define TickTock    10              /* Alarm interval in seconds */
  1192.  
  1193. /*  RELEASE  --  Signal-catching function which releases the audio
  1194.                  device if we haven't received anything to play in
  1195.          the last minute. */
  1196.  
  1197. static void release()
  1198. {
  1199.     if (debugging) {
  1200.         fprintf(stderr, "Tick....\n");
  1201.     }
  1202.     if (++audiotime >= 2) {
  1203.     soundterm();
  1204.     audiok = FALSE;
  1205.     if (debugging) {
  1206.             fprintf(stderr, "Speaker releasing audio device.\n");
  1207.     }
  1208.     } else {
  1209.     alarm(TickTock);          /* Wind the cat */
  1210.     }
  1211. }
  1212.  
  1213. /*  PLAYBUFFER    --  Send next buffer to audio output. */
  1214.  
  1215. static void playbuffer(msg)
  1216.   soundbuf *msg;
  1217. {
  1218.     char *val;
  1219.     int len;
  1220.     char auxbuf[8002];
  1221.  
  1222.     debugging = (msg->compression & 2) ? TRUE : FALSE;
  1223.  
  1224.     if (!audiok) {
  1225.     if (!soundinit(O_WRONLY)) {
  1226.             perror("opening audio output device");
  1227.             return;                   /* Can't acquire sound device */
  1228.     }
  1229.     audiok = TRUE;
  1230.     if (debugging) {
  1231.             fprintf(stderr, "Speaker opening audio device.\n");
  1232.     }
  1233.     signal(SIGALRM, release);     /* Set signal to handle timeout */
  1234.     alarm(TickTock);          /* Set alarm clock to free audio device */
  1235.     audiotime = 0;              /* Reset timeout counter */
  1236.     }
  1237.  
  1238.     if (debugging) {
  1239.         printf("Playing %d%s bytes from %s.\n", msg->buffer.buffer_len,
  1240.                 (msg->compression & 1) ? " compressed" : "", msg->sendinghost);
  1241.     }
  1242.     len = msg->buffer.buffer_len;
  1243.     val = msg->buffer.buffer_val;
  1244.  
  1245.     /* If the 4 bit is on, use    the 8 bit to re-route the sound.  This
  1246.        is normally used to divert the sound to the speaker to  get  an
  1247.        individual's attention.  */
  1248.  
  1249.     if (msg->compression & 4) {
  1250.     sounddest((msg->compression & 8) ? 1 : 0);
  1251.     if (!(msg->compression & 8)) {
  1252.         soundplayvol(50);          /* Make sure volume high enough */
  1253.     }
  1254.     }
  1255.  
  1256.     /* If the buffer contains compressed sound samples, reconstruct an
  1257.        approximation of the original  sound  by  performing  a    linear
  1258.        interpolation between each pair of adjacent compressed samples.
  1259.        Note that since the samples are logarithmically scaled, we must
  1260.        transform  them    to  linear  before interpolating, then back to
  1261.        log before storing the calculated sample. */
  1262.  
  1263.     if (msg->compression & 1) {
  1264.     int i;
  1265.     register char *ab = auxbuf;
  1266.  
  1267.     assert(len < sizeof auxbuf);
  1268.     for (i = 0; i < len; i++) {
  1269.         *ab++ = i == 0 ? *val :
  1270.         (audio_s2u((audio_u2s(*val) + audio_u2s(val[-1])) / 2));
  1271.         *ab++ = *val++;
  1272.     }
  1273.     len *= 2;
  1274.     val = auxbuf;
  1275.     }
  1276.  
  1277.     audiotime = 0;              /* Reset timeout counter */
  1278.     soundplay(len, val);
  1279. }
  1280.  
  1281. /*  Main program  */
  1282.  
  1283. int main()
  1284. {
  1285.     int sock;
  1286.     struct sockaddr_in name;
  1287.     struct soundbuf sb;
  1288.  
  1289.     /* Create the socket from which to read */
  1290.  
  1291.     sock = socket(AF_INET, SOCK_DGRAM, 0);
  1292.     if (sock < 0) {
  1293.         perror("opening datagram socket");
  1294.     return 1;
  1295.     }
  1296.  
  1297.     /* Create name with wildcards. */
  1298.  
  1299.     name.sin_family = AF_INET;
  1300.     name.sin_addr.s_addr = INADDR_ANY;
  1301.     name.sin_port = Internet_Port;
  1302.     if (bind(sock, (struct sockaddr *) &name, sizeof name) < 0) {
  1303.         perror("binding datagram socket");
  1304.     return 1;
  1305.     }
  1306.  
  1307.     /* Read from the socket. */
  1308.  
  1309.     while (TRUE) {
  1310.     if (read(sock, &sb, sizeof sb) < 0) {
  1311.             perror("receiving datagram packet");
  1312.     }
  1313.  
  1314.     /* If  the packet requests loop-back,  immediately dispatch it
  1315.        back to the host who sent it to us.    To prevent an infinite
  1316.        loop-back  cycle,  we clear the loop-back bit in the header
  1317.        before sending the message.    We leave the  host  of    origin
  1318.        unchanged,  allowing  the  sender to identify the packet as
  1319.        one he originated. */
  1320.  
  1321.     if (sb.compression & 16) {
  1322.  
  1323.             /* If the host we're bouncing back the packet to isn't the
  1324.            same  as  the  last one we bounced to, look up its host
  1325.            identity and save it as the last host. */
  1326.  
  1327.         if (strcmp(sb.sendinghost, echost) != 0) {
  1328.         struct hostent *hp, *gethostbyname();
  1329.  
  1330.         hp = gethostbyname(sb.sendinghost);
  1331.         if (hp != 0) {
  1332.             bcopy((char *) hp->h_addr, (char *) &(name.sin_addr),
  1333.               hp->h_length);
  1334.             name.sin_family = AF_INET;
  1335.             name.sin_port = htons(Internet_Port);
  1336.             strcpy(echost, sb.sendinghost);
  1337.         } else {
  1338.             echost[0] = 0;
  1339.         }
  1340.         }
  1341.         sb.compression &= ~16;    /* Prevent infinite loopback */
  1342.         if (sendto(sock, &sb,
  1343.         (sizeof(struct soundbuf)) - (8000 - sb.buffer.buffer_len),
  1344.         0, (struct sockaddr *) &(name), sizeof name) < 0) {
  1345.                 perror("sending datagram message");
  1346.        }
  1347.     }
  1348.  
  1349.     playbuffer(&sb);
  1350.     }
  1351. }
  1352. SHAR_EOF
  1353. fi # end of overwriting check
  1354. #    End of shell archive
  1355. exit 0
  1356.