1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21 /* 22 * Copyright 2009 Sun Microsystems, Inc. All rights reserved. 23 * Use is subject to license terms. 24 */ 25 26 /* Command-line audio record utility */ 27 28 #include <stdio.h> 29 #include <libgen.h> 30 #include <errno.h> 31 #include <ctype.h> 32 #include <math.h> 33 #include <stdlib.h> 34 #include <unistd.h> 35 #include <string.h> 36 #include <strings.h> 37 #include <locale.h> 38 #include <fcntl.h> 39 #include <signal.h> 40 #include <limits.h> /* All occurances of INT_MAX used to be ~0 (by MCA) */ 41 #include <sys/types.h> 42 #include <sys/file.h> 43 #include <sys/stat.h> 44 #include <sys/param.h> 45 #include <stropts.h> 46 #include <poll.h> 47 #include <sys/ioctl.h> 48 #include <netinet/in.h> 49 50 #include <libaudio.h> 51 #include <audio_device.h> 52 53 #define irint(d) ((int)d) 54 55 /* localization stuff */ 56 #define MGET(s) (char *)gettext(s) 57 58 #if !defined(TEXT_DOMAIN) /* Should be defined by cc -D */ 59 #define TEXT_DOMAIN "SYS_TEST" /* Use this only if it weren't */ 60 #endif 61 62 #define Error (void) fprintf 63 64 /* Local variables */ 65 static char *prog; 66 static char prog_opts[] = "aft:v:d:i:e:s:c:T:?"; /* getopt() flags */ 67 static char *Stdout; 68 69 /* XXX - the input buffer size should depend on sample_rate */ 70 #define AUDIO_BUFSIZ (1024 * 64) 71 static unsigned char buf[AUDIO_BUFSIZ]; 72 static char swapBuf[AUDIO_BUFSIZ]; /* for byte swapping */ 73 74 75 #define MAX_GAIN (100) /* maximum gain */ 76 77 static char *Info = NULL; /* pointer to info data */ 78 static unsigned Ilen = 0; /* length of info data */ 79 static unsigned Volume = INT_MAX; /* record volume */ 80 static double Savevol; /* saved volume */ 81 static unsigned Sample_rate = 0; 82 static unsigned Channels = 0; 83 static unsigned Precision = 0; /* based on encoding */ 84 static unsigned Encoding = 0; 85 86 static int NetEndian = TRUE; /* endian nature of the machines */ 87 88 static int Append = FALSE; /* append to output file */ 89 static int Force = FALSE; /* ignore rate differences on append */ 90 static double Time = -1.; /* recording time */ 91 static unsigned Limit = AUDIO_UNKNOWN_SIZE; /* recording limit */ 92 static char *Audio_dev = "/dev/audio"; 93 94 static int Audio_fd = -1; 95 /* file descriptor for audio device */ 96 static Audio_hdr Dev_hdr; /* audio header for device */ 97 static Audio_hdr Save_hdr; /* saved audio device header */ 98 static char *Ofile; /* current filename */ 99 static int File_type = FILE_AU; /* audio file type */ 100 static int File_type_set = FALSE; /* file type specified as arg */ 101 static Audio_hdr File_hdr; /* audio header for file */ 102 static int Cleanup = FALSE; /* SIGINT sets this flag */ 103 static unsigned Size = 0; /* Size of output file */ 104 static unsigned Oldsize = 0; 105 /* Size of input file, if append */ 106 107 /* Global variables */ 108 extern int getopt(); 109 extern int optind; 110 extern char *optarg; 111 112 /* Local Functions */ 113 static void usage(void); 114 static void sigint(int sig); 115 static int parse_unsigned(char *str, unsigned *dst, char *flag); 116 static int parse_sample_rate(char *s, unsigned *rate); 117 118 119 static void 120 usage(void) 121 { 122 Error(stderr, MGET("Record an audio file -- usage:\n" 123 "\t%s [-af] [-v vol]\n" 124 "\t%.*s [-c channels] [-s rate] [-e encoding]\n" 125 "\t%.*s [-t time] [-i info] [-d dev] [-T au|wav|aif[f]] [file]\n" 126 "where:\n" 127 "\t-a\tAppend to output file\n" 128 "\t-f\tIgnore sample rate differences on append\n" 129 "\t-v\tSet record volume (0 - %d)\n" 130 "\t-c\tSpecify number of channels to record\n" 131 "\t-s\tSpecify rate in samples per second\n" 132 "\t-e\tSpecify encoding (ulaw | alaw | [u]linear | linear8 )\n" 133 "\t-t\tSpecify record time (hh:mm:ss.dd)\n" 134 "\t-i\tSpecify a file header information string\n" 135 "\t-d\tSpecify audio device (default: /dev/audio)\n" 136 "\t-T\tSpecify the audio file type (default: au)\n" 137 "\tfile\tRecord to named file\n" 138 "\t\tIf no file specified, write to stdout\n" 139 "\t\tDefault audio encoding is ulaw, 8khz, mono\n" 140 "\t\tIf -t is not specified, record until ^C\n"), 141 prog, 142 strlen(prog), " ", 143 strlen(prog), " ", 144 MAX_GAIN); 145 exit(1); 146 } 147 148 static void 149 sigint(int sig) 150 { 151 /* If this is the first ^C, set a flag for the main loop */ 152 if (!Cleanup && (Audio_fd >= 0)) { 153 /* flush input queues before exiting */ 154 Cleanup = TRUE; 155 if (audio_pause_record(Audio_fd) == AUDIO_SUCCESS) 156 return; 157 Error(stderr, MGET("%s: could not flush input buffer\n"), prog); 158 } 159 160 /* If double ^C, really quit */ 161 if (Audio_fd >= 0) { 162 if (Volume != INT_MAX) 163 (void) audio_set_record_gain(Audio_fd, &Savevol); 164 if (audio_cmp_hdr(&Save_hdr, &Dev_hdr) != 0) { 165 (void) audio_set_record_config(Audio_fd, &Save_hdr); 166 } 167 } 168 exit(1); 169 } 170 171 /* 172 * Record from the audio device to a file. 173 */ 174 int 175 main(int argc, char **argv) 176 { 177 int i; 178 int cnt; 179 int err; 180 int file_type; 181 int ofd; 182 int swapBytes = FALSE; 183 double vol; 184 struct stat st; 185 struct pollfd pfd; 186 char *cp; 187 188 (void) setlocale(LC_ALL, ""); 189 (void) textdomain(TEXT_DOMAIN); 190 191 /* Get the program name */ 192 prog = strrchr(argv[0], '/'); 193 if (prog == NULL) 194 prog = argv[0]; 195 else 196 prog++; 197 Stdout = MGET("(stdout)"); 198 199 /* first check AUDIODEV environment for audio device name */ 200 if (cp = getenv("AUDIODEV")) { 201 Audio_dev = cp; 202 } 203 204 /* Set the endian nature of the machine */ 205 if ((ulong_t)1 != htonl((ulong_t)1)) { 206 NetEndian = FALSE; 207 } 208 209 err = 0; 210 while ((i = getopt(argc, argv, prog_opts)) != EOF) { 211 switch (i) { 212 case 'v': 213 if (parse_unsigned(optarg, &Volume, "-v")) { 214 err++; 215 } else if (Volume > MAX_GAIN) { 216 Error(stderr, MGET("%s: invalid value for " 217 "-v\n"), prog); 218 err++; 219 } 220 break; 221 case 't': 222 Time = audio_str_to_secs(optarg); 223 if ((Time == HUGE_VAL) || (Time < 0.)) { 224 Error(stderr, MGET("%s: invalid value for " 225 "-t\n"), prog); 226 err++; 227 } 228 break; 229 case 'd': 230 Audio_dev = optarg; 231 break; 232 case 'f': 233 Force = TRUE; 234 break; 235 case 'a': 236 Append = TRUE; 237 break; 238 case 'i': 239 Info = optarg; /* set information string */ 240 Ilen = strlen(Info); 241 break; 242 case 's': 243 if (parse_sample_rate(optarg, &Sample_rate)) { 244 err++; 245 } 246 break; 247 case 'c': 248 if (strncmp(optarg, "mono", strlen(optarg)) == 0) { 249 Channels = 1; 250 } else if (strncmp(optarg, "stereo", 251 strlen(optarg)) == 0) { 252 Channels = 2; 253 } else if (parse_unsigned(optarg, &Channels, "-c")) { 254 err++; 255 } else if ((Channels != 1) && (Channels != 2)) { 256 Error(stderr, "%s: invalid value for -c\n", 257 prog); 258 err++; 259 } 260 break; 261 case 'e': 262 if (strncmp(optarg, "ulinear", strlen(optarg)) == 0) { 263 Encoding = AUDIO_ENCODING_LINEAR8; 264 Precision = 8; 265 } else if (strncmp(optarg, "linear8", 266 strlen("linear8")) == 0) { 267 Encoding = AUDIO_ENCODING_LINEAR; 268 Precision = 8; 269 } else if (strncmp(optarg, "ulaw", 270 strlen(optarg)) == 0) { 271 Encoding = AUDIO_ENCODING_ULAW; 272 Precision = 8; 273 } else if (strncmp(optarg, "alaw", 274 strlen(optarg)) == 0) { 275 Encoding = AUDIO_ENCODING_ALAW; 276 Precision = 8; 277 } else if ((strncmp(optarg, "linear", 278 strlen(optarg)) == 0) || (strncmp(optarg, "pcm", 279 strlen(optarg)) == 0)) { 280 Encoding = AUDIO_ENCODING_LINEAR; 281 Precision = 16; 282 } else { 283 Error(stderr, MGET("%s: invalid value for " 284 "-e\n"), prog); 285 err++; 286 } 287 break; 288 case 'T': 289 if (strncmp(optarg, "au", strlen(optarg)) == 0) { 290 File_type = FILE_AU; 291 } else if (strncmp(optarg, "wav", 292 strlen(optarg)) == 0) { 293 File_type = FILE_WAV; 294 } else if (strncmp(optarg, "aif", 295 strlen(optarg)) == 0) { 296 File_type = FILE_AIFF; 297 } else if (strncmp(optarg, "aiff", 298 strlen(optarg)) == 0) { 299 File_type = FILE_AIFF; 300 } else { 301 Error(stderr, MGET("%s: invalid value for " 302 "-T\n"), prog); 303 err++; 304 } 305 File_type_set = TRUE; 306 break; 307 case '?': 308 usage(); 309 /*NOTREACHED*/ 310 } 311 } 312 if (Append && (Info != NULL)) { 313 Error(stderr, MGET("%s: cannot specify -a and -i\n"), prog); 314 err++; 315 } 316 if (err > 0) 317 exit(1); 318 319 argc -= optind; /* update arg pointers */ 320 argv += optind; 321 322 /* Open the output file */ 323 if (argc <= 0) { 324 Ofile = Stdout; 325 } else { 326 Ofile = *argv++; 327 argc--; 328 329 /* Interpret "-" filename to mean stdout */ 330 if (strcmp(Ofile, "-") == 0) 331 Ofile = Stdout; 332 333 /* if -T not set then we use the file suffix */ 334 if (File_type_set == FALSE) { 335 char *file_name; 336 char *start; 337 338 /* get the file name without the path */ 339 file_name = basename(Ofile); 340 341 /* get the true suffix */ 342 start = strrchr(file_name, '.'); 343 344 /* if no '.' then there's no suffix */ 345 if (start) { 346 /* is this a .au file? */ 347 if (strcasecmp(start, ".au") == 0) { 348 File_type = FILE_AU; 349 } else if (strcasecmp(start, ".wav") == 0) { 350 File_type = FILE_WAV; 351 } else if (strcasecmp(start, ".aif") == 0) { 352 File_type = FILE_AIFF; 353 } else if (strcasecmp(start, ".aiff") == 0) { 354 File_type = FILE_AIFF; 355 } else { 356 /* the default is .au */ 357 File_type = FILE_AU; 358 } 359 } else { 360 /* no suffix, so default to .au */ 361 File_type = FILE_AU; 362 } 363 } 364 } 365 366 if (Ofile == Stdout) { 367 ofd = fileno(stdout); 368 Append = FALSE; 369 } else { 370 ofd = open(Ofile, 371 (O_RDWR | O_CREAT | (Append ? 0 : O_TRUNC)), 0666); 372 if (ofd < 0) { 373 Error(stderr, MGET("%s: cannot open "), prog); 374 perror(Ofile); 375 exit(1); 376 } 377 if (Append) { 378 /* 379 * Check to make sure we're appending to an audio file. 380 * It must be a regular file (if zero-length, simply 381 * write it from scratch). Also, its file header 382 * must match the input device configuration. 383 */ 384 if ((fstat(ofd, &st) < 0) || (!S_ISREG(st.st_mode))) { 385 Error(stderr, 386 MGET("%s: %s is not a regular file\n"), 387 prog, Ofile); 388 exit(1); 389 } 390 if (st.st_size == 0) { 391 Append = FALSE; 392 goto openinput; 393 } 394 395 err = audio_read_filehdr(ofd, &File_hdr, &file_type, 396 (char *)NULL, 0); 397 398 if (err != AUDIO_SUCCESS) { 399 Error(stderr, 400 MGET("%s: %s is not a valid audio file\n"), 401 prog, Ofile); 402 exit(1); 403 } 404 405 /* we need to make sure file types match */ 406 if (File_type_set == TRUE) { 407 /* specified by the command line, must match */ 408 if (File_type != file_type) { 409 Error(stderr, 410 MGET("%s: file types must match\n"), 411 prog); 412 exit(1); 413 } 414 } else { 415 /* not specified, so force */ 416 File_type = file_type; 417 } 418 419 /* 420 * Set the format state to the format 421 * in the file header. 422 */ 423 Sample_rate = File_hdr.sample_rate; 424 Channels = File_hdr.channels; 425 Encoding = File_hdr.encoding; 426 Precision = File_hdr.bytes_per_unit * 8; 427 428 /* make sure we support the encoding method */ 429 switch (Encoding) { 430 case AUDIO_ENCODING_LINEAR8: 431 case AUDIO_ENCODING_ULAW: 432 case AUDIO_ENCODING_ALAW: 433 case AUDIO_ENCODING_LINEAR: 434 break; 435 default: { 436 char msg[AUDIO_MAX_ENCODE_INFO]; 437 (void) audio_enc_to_str(&File_hdr, msg); 438 Error(stderr, 439 MGET("%s: Append is not supported " 440 "for "), prog); 441 Error(stderr, 442 MGET("this file encoding:\n\t" 443 "[%s]\n"), msg); 444 exit(1); 445 } 446 } 447 448 /* Get the current size, if possible */ 449 Oldsize = File_hdr.data_size; 450 if ((Oldsize == AUDIO_UNKNOWN_SIZE) && 451 ((err = (int)lseek(ofd, 0L, SEEK_CUR)) >= 0)) { 452 if (err < 0) { 453 Error(stderr, 454 MGET("%s: %s is not a valid audio " 455 "file\n"), prog, Ofile); 456 exit(1); 457 } 458 Oldsize = st.st_size - err; 459 } 460 /* Seek to end to start append */ 461 if ((int)lseek(ofd, st.st_size, SEEK_SET) < 0) { 462 Error(stderr, 463 MGET("%s: cannot find end of %s\n"), 464 prog, Ofile); 465 exit(1); 466 } 467 } 468 } 469 openinput: 470 /* Validate and open the audio device */ 471 err = stat(Audio_dev, &st); 472 if (err < 0) { 473 Error(stderr, MGET("%s: cannot open "), prog); 474 perror(Audio_dev); 475 exit(1); 476 } 477 if (!S_ISCHR(st.st_mode)) { 478 Error(stderr, MGET("%s: %s is not an audio device\n"), prog, 479 Audio_dev); 480 exit(1); 481 } 482 483 /* 484 * For the mixer environment we need to open the audio device before 485 * the control device. If successful we pause right away to keep 486 * from queueing up a bunch of useless data. 487 */ 488 Audio_fd = open(Audio_dev, O_RDONLY | O_NONBLOCK); 489 if (Audio_fd < 0) { 490 if (errno == EBUSY) { 491 Error(stderr, MGET("%s: %s is busy\n"), 492 prog, Audio_dev); 493 } else { 494 Error(stderr, MGET("%s: error opening "), prog); 495 perror(Audio_dev); 496 } 497 exit(1); 498 } 499 if (audio_pause_record(Audio_fd) != AUDIO_SUCCESS) { 500 Error(stderr, MGET("%s: not able to pause recording\n"), prog); 501 exit(1); 502 } 503 504 /* get the current settings */ 505 if (audio_get_record_config(Audio_fd, &Save_hdr) != AUDIO_SUCCESS) { 506 (void) close(Audio_fd); 507 Error(stderr, MGET("%s: %s is not an audio device\n"), 508 prog, Audio_dev); 509 exit(1); 510 } 511 /* make a copy into the working data structure */ 512 bcopy(&Save_hdr, &Dev_hdr, sizeof (Save_hdr)); 513 514 /* flush any queued audio data */ 515 if (audio_flush_record(Audio_fd) != AUDIO_SUCCESS) { 516 Error(stderr, MGET("%s: not able to flush recording\n"), prog); 517 exit(1); 518 } 519 520 if (Sample_rate != 0) { 521 Dev_hdr.sample_rate = Sample_rate; 522 } 523 if (Channels != 0) { 524 Dev_hdr.channels = Channels; 525 } 526 if (Precision != 0) { 527 Dev_hdr.bytes_per_unit = Precision / 8; 528 } 529 if (Encoding != 0) { 530 Dev_hdr.encoding = Encoding; 531 } 532 533 /* 534 * For .wav we always record 8-bit linear as unsigned. Thus we 535 * force unsigned linear to make life a lot easier on the user. 536 * 537 * For .aiff we set the default to 8-bit signed linear, not 538 * u-law, if Encoding isn't already set. 539 */ 540 if (File_type == FILE_WAV && 541 Dev_hdr.encoding == AUDIO_ENCODING_LINEAR && 542 Dev_hdr.bytes_per_unit == 1) { 543 /* force to unsigned */ 544 Dev_hdr.encoding = AUDIO_ENCODING_LINEAR8; 545 } else if (File_type == FILE_AIFF && Encoding == 0) { 546 Dev_hdr.encoding = AUDIO_ENCODING_LINEAR; 547 if (Precision == 0) { 548 Dev_hdr.bytes_per_unit = AUDIO_PRECISION_8 / 8; 549 } 550 } 551 552 if (audio_set_record_config(Audio_fd, &Dev_hdr) != AUDIO_SUCCESS) { 553 Error(stderr, MGET( 554 "%s: Audio format not supported by the audio device\n"), 555 prog); 556 exit(1); 557 } 558 559 if (audio_resume_record(Audio_fd) != AUDIO_SUCCESS) { 560 Error(stderr, MGET("%s: not able to resume recording\n"), prog); 561 exit(1); 562 } 563 564 /* If appending to an existing file, check the configuration */ 565 if (Append) { 566 char msg[AUDIO_MAX_ENCODE_INFO]; 567 568 switch (audio_cmp_hdr(&Dev_hdr, &File_hdr)) { 569 case 0: /* configuration matches */ 570 break; 571 case 1: /* all but sample rate matches */ 572 if (Force) { 573 Error(stderr, MGET("%s: WARNING: appending " 574 "%.3fkHz data to %s (%.3fkHz)\n"), prog, 575 ((double)Dev_hdr.sample_rate / 1000.), 576 Ofile, 577 ((double)File_hdr.sample_rate / 1000.)); 578 break; 579 } /* if not -f, fall through */ 580 /* FALLTHROUGH */ 581 default: /* encoding mismatch */ 582 (void) audio_enc_to_str(&Dev_hdr, msg); 583 Error(stderr, 584 MGET("%s: device encoding [%s]\n"), prog, msg); 585 (void) audio_enc_to_str(&File_hdr, msg); 586 Error(stderr, 587 MGET("\tdoes not match file encoding [%s]\n"), msg); 588 exit(1); 589 } 590 } else if (!isatty(ofd)) { 591 if (audio_write_filehdr(ofd, &Dev_hdr, File_type, Info, 592 Ilen) != AUDIO_SUCCESS) { 593 Error(stderr, 594 MGET("%s: error writing header for %s\n"), prog, 595 Ofile); 596 exit(1); 597 } 598 } 599 600 /* 601 * 8-bit audio isn't a problem, however 16-bit audio is. If the file 602 * is an endian that is different from the machine then the bytes 603 * will need to be swapped. 604 * 605 * Note: The following if() could be simplified, but then it gets 606 * to be very hard to read. So it's left as is. 607 */ 608 if (Dev_hdr.bytes_per_unit == 2 && 609 ((!NetEndian && File_type == FILE_AIFF) || 610 (!NetEndian && File_type == FILE_AU) || 611 (NetEndian && File_type == FILE_WAV))) { 612 swapBytes = TRUE; 613 } 614 615 /* If -v flag, set the record volume now */ 616 if (Volume != INT_MAX) { 617 vol = (double)Volume / (double)MAX_GAIN; 618 (void) audio_get_record_gain(Audio_fd, &Savevol); 619 err = audio_set_record_gain(Audio_fd, &vol); 620 if (err != AUDIO_SUCCESS) { 621 Error(stderr, 622 MGET("%s: could not set record volume for %s\n"), 623 prog, Audio_dev); 624 exit(1); 625 } 626 } 627 628 if (isatty(ofd)) { 629 Error(stderr, MGET("%s: No files and stdout is a tty\n"), 630 prog); 631 exit(1); 632 } 633 634 /* Set up SIGINT handler so that final buffers may be flushed */ 635 (void) signal(SIGINT, sigint); 636 637 /* 638 * At this point, we're (finally) ready to copy the data. 639 * Init a poll() structure, to use when there's nothing to read. 640 */ 641 if (Time > 0) 642 Limit = audio_secs_to_bytes(&Dev_hdr, Time); 643 pfd.fd = Audio_fd; 644 pfd.events = POLLIN; 645 while ((Limit == AUDIO_UNKNOWN_SIZE) || (Limit != 0)) { 646 /* Fill the buffer or read to the time limit */ 647 cnt = read(Audio_fd, (char *)buf, 648 ((Limit != AUDIO_UNKNOWN_SIZE) && (Limit < sizeof (buf)) ? 649 (int)Limit : sizeof (buf))); 650 651 if (cnt == 0) /* normally, eof can't happen */ 652 break; 653 654 /* If error, probably have to wait for input */ 655 if (cnt < 0) { 656 if (Cleanup) 657 break; /* done if ^C seen */ 658 switch (errno) { 659 case EAGAIN: 660 (void) poll(&pfd, 1L, -1); 661 break; 662 case EOVERFLOW: /* Possibly a Large File */ 663 Error(stderr, MGET("%s: error reading"), prog); 664 perror("Large File"); 665 exit(1); 666 default: 667 Error(stderr, MGET("%s: error reading"), prog); 668 perror(Audio_dev); 669 exit(1); 670 } 671 continue; 672 } 673 674 /* Swab the output if required. */ 675 if (swapBytes) { 676 swab((char *)buf, swapBuf, cnt); 677 err = write(ofd, swapBuf, cnt); 678 } else { 679 err = write(ofd, (char *)buf, cnt); 680 } 681 if (err < 0) { 682 Error(stderr, MGET("%s: error writing "), prog); 683 perror(Ofile); 684 exit(1); 685 } 686 if (err != cnt) { 687 Error(stderr, MGET("%s: error writing "), prog); 688 perror(Ofile); 689 break; 690 } 691 Size += cnt; 692 if (Limit != AUDIO_UNKNOWN_SIZE) 693 Limit -= cnt; 694 } 695 696 /* Attempt to rewrite the data_size field of the file header */ 697 if (!Append || (Oldsize != AUDIO_UNKNOWN_SIZE)) { 698 if (Append) 699 Size += Oldsize; 700 (void) audio_rewrite_filesize(ofd, File_type, Size, 701 Dev_hdr.channels, Dev_hdr.bytes_per_unit); 702 } 703 704 (void) close(ofd); /* close input file */ 705 706 707 /* Check for error during record */ 708 if (audio_get_record_error(Audio_fd, (unsigned *)&err) != AUDIO_SUCCESS) 709 Error(stderr, MGET("%s: error reading device status\n"), prog); 710 else if (err) 711 Error(stderr, MGET("%s: WARNING: Data overflow occurred\n"), 712 prog); 713 714 /* Reset record volume, encoding */ 715 if (Volume != INT_MAX) 716 (void) audio_set_record_gain(Audio_fd, &Savevol); 717 if (audio_cmp_hdr(&Save_hdr, &Dev_hdr) != 0) { 718 (void) audio_set_record_config(Audio_fd, &Save_hdr); 719 } 720 (void) close(Audio_fd); 721 return (0); 722 } 723 724 /* Parse an unsigned integer */ 725 static int 726 parse_unsigned(char *str, unsigned *dst, char *flag) 727 { 728 char x; 729 730 if (sscanf(str, "%u%c", dst, &x) != 1) { 731 Error(stderr, MGET("%s: invalid value for %s\n"), prog, flag); 732 return (1); 733 } 734 return (0); 735 } 736 737 /* 738 * set the sample rate. assume anything is ok. check later on to make sure 739 * the sample rate is valid. 740 */ 741 static int 742 parse_sample_rate(char *s, unsigned *rate) 743 { 744 char *cp; 745 double drate; 746 747 /* 748 * check if it's "cd" or "dat" or "voice". these also set 749 * the precision and encoding, etc. 750 */ 751 if (strcasecmp(s, "dat") == 0) { 752 drate = 48000.0; 753 } else if (strcasecmp(s, "cd") == 0) { 754 drate = 44100.0; 755 } else if (strcasecmp(s, "voice") == 0) { 756 drate = 8000.0; 757 } else { 758 /* just do an atof */ 759 drate = atof(s); 760 761 /* 762 * if the first non-digit is a "k" multiply by 1000, 763 * if it's an "h", leave it alone. anything else, 764 * return an error. 765 */ 766 767 /* 768 * XXX bug alert: could have multiple "." in string 769 * and mess things up. 770 */ 771 for (cp = s; *cp && (isdigit(*cp) || (*cp == '.')); cp++) 772 /* NOP */; 773 if (*cp != NULL) { 774 if ((*cp == 'k') || (*cp == 'K')) { 775 drate *= 1000.0; 776 } else if ((*cp != 'h') || (*cp != 'H')) { 777 /* bogus! */ 778 Error(stderr, 779 MGET("invalid sample rate: %s\n"), s); 780 return (1); 781 } 782 } 783 784 } 785 786 *rate = irint(drate); 787 return (0); 788 } 789