beep.c

   1 /*  beep - just what it sounds like, makes the console beep - but with
   2  * precision control.  See the man page for details.
   3  *
   4  * Try beep -h for command line args
   5  *
   6  * This code is copyright (C) Johnathan Nightingale, 2000.
   7  *
   8  * This code may distributed only under the terms of the GNU Public License
   9  * which can be found at http://www.gnu.org/copyleft or in the file COPYING
  10  * supplied with this code.
  11  *
  12  * This code is not distributed with warranties of any kind, including implied
  13  * warranties of merchantability or fitness for a particular use or ability to
  14  * breed pandas in captivity, it just can't be done.
  15  *
  16  * Bug me, I like it:  http://johnath.com/  or johnath@johnath.com
  17  */
  18
  19 #include <fcntl.h>
  20 #include <getopt.h>
  21 #include <signal.h>
  22 #include <stdio.h>
  23 #include <stdlib.h>
  24 #include <string.h>
  25 #include <unistd.h>
  26 #include <sys/ioctl.h>
  27 #include <sys/types.h>
  28 #include <linux/kd.h>
  29
  30 /* I don't know where this number comes from, I admit that freely.  A
  31    wonderful human named Raine M. Ekman used it in a program that played
  32    a tune at the console, and apparently, it's how the kernel likes its
  33    sound requests to be phrased.  If you see Raine, thank him for me.
  34
  35    June 28, email from Peter Tirsek (peter at tirsek dot com):
  36
  37    This number represents the fixed frequency of the original PC XT's
  38    timer chip (the 8254 AFAIR), which is approximately 1.193 MHz. This
  39    number is divided with the desired frequency to obtain a counter value,
  40    that is subsequently fed into the timer chip, tied to the PC speaker.
  41    The chip decreases this counter at every tick (1.193 MHz) and when it
  42    reaches zero, it toggles the state of the speaker (on/off, or in/out),
  43    resets the counter to the original value, and starts over. The end
  44    result of this is a tone at approximately the desired frequency. :)
  45 */
  46 #ifndef CLOCK_TICK_RATE
  47 #define CLOCK_TICK_RATE 1193180
  48 #endif
  49
  50 #define VERSION_STRING "beep-1.2.2"
  51 char *copyright =
  52 "Copyright (C) Johnathan Nightingale, 2002.  "
  53 "Use and Distribution subject to GPL.  "
  54 "For information: http://www.gnu.org/copyleft/.";
  55
  56 /* Meaningful Defaults */
  57 #define DEFAULT_FREQ       440.0 /* Middle A */
  58 #define DEFAULT_LENGTH     200   /* milliseconds */
  59 #define DEFAULT_REPS       1
  60 #define DEFAULT_DELAY      100   /* milliseconds */
  61 #define DEFAULT_END_DELAY  NO_END_DELAY
  62 #define DEFAULT_STDIN_BEEP NO_STDIN_BEEP
  63
  64 /* Other Constants */
  65 #define NO_END_DELAY    0
  66 #define YES_END_DELAY   1
  67
  68 #define NO_STDIN_BEEP   0
  69 #define LINE_STDIN_BEEP 1
  70 #define CHAR_STDIN_BEEP 2
  71
  72 typedef struct beep_parms_t {
  73   float freq;     /* tone frequency (Hz)      */
  74   int length;     /* tone length    (ms)      */
  75   int reps;       /* # of repetitions         */
  76   int delay;      /* delay between reps  (ms) */
  77   int end_delay;  /* do we delay after last rep? */
  78   int stdin_beep; /* are we using stdin triggers?  We have three options:
  79                      - just beep and terminate (default)
  80                      - beep after a line of input
  81                      - beep after a character of input
  82                      In the latter two cases, pass the text back out again,
  83                      so that beep can be tucked appropriately into a text-
  84                      processing pipe.
  85                   */
  86   int verbose;    /* verbose output?          */
  87   struct beep_parms_t *next;  /* in case -n/--new is used. */
  88 } beep_parms_t;
  89
  90 /* Momma taught me never to use globals, but we need something the signal
  91    handlers can get at.*/
  92 int console_fd = -1;
  93
  94 /* If we get interrupted, it would be nice to not leave the speaker beeping in
  95    perpetuity. */
  96 void handle_signal(int signum) {
  97   switch(signum) {
  98   case SIGINT:
  99     if(console_fd >= 0) {
 100       /* Kill the sound, quit gracefully */
 101       ioctl(console_fd, KIOCSOUND, 0);
 102       close(console_fd);
 103       exit(signum);
 104     } else {
 105       /* Just quit gracefully */
 106       exit(signum);
 107     }
 108   }
 109 }
 110
 111 /* print usage and exit */
 112 void usage_bail(const char *executable_name) {
 113   printf("Usage:\n%s [-f freq] [-l length] [-r reps] [-d delay] "
 114          "[-D delay] [-s] [-c] [--verbose | --debug]\n",
 115          executable_name);
 116   printf("%s [Options...] [-n] [--new] [Options...] ... \n", executable_name);
 117   printf("%s [-h] [--help]\n", executable_name);
 118   printf("%s [-v] [-V] [--version]\n", executable_name);
 119   exit(1);
 120 }
 121
 122
 123 /* Parse the command line.  argv should be untampered, as passed to main.
 124  * Beep parameters returned in result, subsequent parameters in argv will over-
 125  * ride previous ones.
 126  *
 127  * Currently valid parameters:
 128  *  "-f <frequency in Hz>"
 129  *  "-l <tone length in ms>"
 130  *  "-r <repetitions>"
 131  *  "-d <delay in ms>"
 132  *  "-D <delay in ms>" (similar to -d, but delay after last repetition as well)
 133  *  "-s" (beep after each line of input from stdin, echo line to stdout)
 134  *  "-c" (beep after each char of input from stdin, echo char to stdout)
 135  *  "--verbose/--debug"
 136  *  "-h/--help"
 137  *  "-v/-V/--version"
 138  *  "-n/--new"
 139  *
 140  * March 29, 2002 - Daniel Eisenbud points out that c should be int, not char,
 141  * for correctness on platforms with unsigned chars.
 142  */
 143 void parse_command_line(int argc, char **argv, beep_parms_t *result) {
 144   int c;
 145
 146   struct option opt_list[6] = {{"help", 0, NULL, 'h'},
 147                                {"version", 0, NULL, 'V'},
 148                                {"new", 0, NULL, 'n'},
 149                                {"verbose", 0, NULL, 'X'},
 150                                {"debug", 0, NULL, 'X'},
 151                                {0,0,0,0}};
 152   while((c = getopt_long(argc, argv, "f:l:r:d:D:schvVn", opt_list, NULL))
 153         != EOF) {
 154     int argval = -1;    /* handle parsed numbers for various arguments */
 155     float argfreq = -1;
 156     switch(c) {
 157     case 'f':  /* freq */
 158       if(!sscanf(optarg, "%f", &argfreq) || (argfreq >= 20000 /* ack! */) ||
 159          (argfreq <= 0))
 160         usage_bail(argv[0]);
 161       else
 162         if (result->freq != 0)
 163           fprintf(stderr, "WARNING: multiple -f values given, only last "
 164             "one is used.\n");
 165         result->freq = argfreq;
 166       break;
 167     case 'l' : /* length */
 168       if(!sscanf(optarg, "%d", &argval) || (argval < 0))
 169         usage_bail(argv[0]);
 170       else
 171         result->length = argval;
 172       break;
 173     case 'r' : /* repetitions */
 174       if(!sscanf(optarg, "%d", &argval) || (argval < 0))
 175         usage_bail(argv[0]);
 176       else
 177         result->reps = argval;
 178       break;
 179     case 'd' : /* delay between reps - WITHOUT delay after last beep*/
 180       if(!sscanf(optarg, "%d", &argval) || (argval < 0))
 181         usage_bail(argv[0]);
 182       else {
 183         result->delay = argval;
 184         result->end_delay = NO_END_DELAY;
 185       }
 186       break;
 187     case 'D' : /* delay between reps - WITH delay after last beep */
 188       if(!sscanf(optarg, "%d", &argval) || (argval < 0))
 189         usage_bail(argv[0]);
 190       else {
 191         result->delay = argval;
 192         result->end_delay = YES_END_DELAY;
 193       }
 194       break;
 195     case 's' :
 196       result->stdin_beep = LINE_STDIN_BEEP;
 197       break;
 198     case 'c' :
 199       result->stdin_beep = CHAR_STDIN_BEEP;
 200       break;
 201     case 'v' :
 202     case 'V' : /* also --version */
 203       printf("%s\n",VERSION_STRING);
 204       exit(0);
 205       break;
 206     case 'n' : /* also --new - create another beep */
 207       if (result->freq == 0)
 208         result->freq = DEFAULT_FREQ;
 209       result->next = (beep_parms_t *)malloc(sizeof(beep_parms_t));
 210       result->next->freq       = 0;
 211       result->next->length     = DEFAULT_LENGTH;
 212       result->next->reps       = DEFAULT_REPS;
 213       result->next->delay      = DEFAULT_DELAY;
 214       result->next->end_delay  = DEFAULT_END_DELAY;
 215       result->next->stdin_beep = DEFAULT_STDIN_BEEP;
 216       result->next->verbose    = result->verbose;
 217       result->next->next       = NULL;
 218       result = result->next; /* yes, I meant to do that. */
 219       break;
 220     case 'X' : /* --debug / --verbose */
 221       result->verbose = 1;
 222       break;
 223     case 'h' : /* notice that this is also --help */
 224     default :
 225       usage_bail(argv[0]);
 226     }
 227   }
 228   if (result->freq == 0)
 229     result->freq = DEFAULT_FREQ;
 230 }
 231
 232 void play_beep(beep_parms_t parms) {
 233   int i; /* loop counter */
 234
 235   if(parms.verbose == 1)
 236       fprintf(stderr, "[DEBUG] %d times %d ms beeps (%d delay between, "
 237         "%d delay after) @ %.2f Hz\n",
 238         parms.reps, parms.length, parms.delay, parms.end_delay, parms.freq);
 239
 240   /* try to snag the console */
 241   if((console_fd = open("/dev/tty0", O_WRONLY)) == -1) {
 242     if((console_fd = open("/dev/vc/0", O_WRONLY)) == -1) {
 243       fprintf(stderr, "Could not open /dev/tty0 or /dev/vc/0 for writing.\n");
 244       printf("\a");  /* Output the only beep we can, in an effort to fall back on usefulness */
 245       perror("open");
 246       exit(1);
 247     }
 248   }
 249
 250   /* Beep */
 251   for (i = 0; i < parms.reps; i++) {                    /* start beep */
 252     if(ioctl(console_fd, KIOCSOUND, (int)(CLOCK_TICK_RATE/parms.freq)) < 0) {
 253       printf("\a");  /* Output the only beep we can, in an effort to fall back on usefulness */
 254       perror("ioctl");
 255     }
 256     /* Look ma, I'm not ansi C compatible! */
 257     usleep(1000*parms.length);                          /* wait...    */
 258     ioctl(console_fd, KIOCSOUND, 0);                    /* stop beep  */
 259     if(parms.end_delay || (i+1 < parms.reps))
 260        usleep(1000*parms.delay);                        /* wait...    */
 261   }                                                     /* repeat.    */
 262
 263   close(console_fd);
 264 }
 265
 266
 267
 268 int main(int argc, char **argv) {
 269   char sin[4096], *ptr;
 270
 271   beep_parms_t *parms = (beep_parms_t *)malloc(sizeof(beep_parms_t));
 272   parms->freq       = 0;
 273   parms->length     = DEFAULT_LENGTH;
 274   parms->reps       = DEFAULT_REPS;
 275   parms->delay      = DEFAULT_DELAY;
 276   parms->end_delay  = DEFAULT_END_DELAY;
 277   parms->stdin_beep = DEFAULT_STDIN_BEEP;
 278   parms->verbose    = 0;
 279   parms->next       = NULL;
 280
 281   signal(SIGINT, handle_signal);
 282   parse_command_line(argc, argv, parms);
 283
 284   /* this outermost while loop handles the possibility that -n/--new has been
 285      used, i.e. that we have multiple beeps specified. Each iteration will
 286      play, then free() one parms instance. */
 287   while(parms) {
 288     beep_parms_t *next = parms->next;
 289
 290     if(parms->stdin_beep) {
 291       /* in this case, beep is probably part of a pipe, in which case POSIX
 292          says stdin and out should be fuly buffered.  This however means very
 293          laggy performance with beep just twiddling it's thumbs until a buffer
 294          fills. Thus, kill the buffering.  In some situations, this too won't
 295          be enough, namely if we're in the middle of a long pipe, and the
 296          processes feeding us stdin are buffered, we'll have to wait for them,
 297          not much to  be done about that. */
 298       setvbuf(stdin, NULL, _IONBF, 0);
 299       setvbuf(stdout, NULL, _IONBF, 0);
 300       while(fgets(sin, 4096, stdin)) {
 301         if(parms->stdin_beep==CHAR_STDIN_BEEP) {
 302           for(ptr=sin;*ptr;ptr++) {
 303             putchar(*ptr);
 304             fflush(stdout);
 305             play_beep(*parms);
 306           }
 307         } else {
 308           fputs(sin, stdout);
 309           play_beep(*parms);
 310         }
 311       }
 312     } else {
 313       play_beep(*parms);
 314     }
 315
 316     /* Junk each parms struct after playing it */
 317     free(parms);
 318     parms = next;
 319   }
 320
 321   return EXIT_SUCCESS;
 322 }