1/* $NetBSD: play.c,v 1.64 2024/03/04 06:29:35 mrg Exp $ */ 2 3/* 4 * Copyright (c) 1999, 2000, 2001, 2002, 2010, 2015, 2019, 2021 Matthew R. Green 5 * All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * 2. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 17 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 18 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 19 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 20 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 21 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 22 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED 23 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, 24 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 25 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 26 * SUCH DAMAGE. 27 */ 28#include <sys/cdefs.h> 29 30#ifndef lint 31__RCSID("$NetBSD: play.c,v 1.64 2024/03/04 06:29:35 mrg Exp $"); 32#endif 33 34#include <sys/param.h> 35#include <sys/audioio.h> 36#include <sys/ioctl.h> 37#include <sys/mman.h> 38#include <sys/stat.h> 39 40#include <err.h> 41#include <fcntl.h> 42#include <signal.h> 43#include <stdio.h> 44#include <stdlib.h> 45#include <string.h> 46#include <unistd.h> 47#include <util.h> 48 49#include <paths.h> 50 51#include "libaudio.h" 52 53typedef size_t (*convert)(void *inbuf, void *outbuf, size_t len); 54 55static void usage(void) __dead; 56static void play(char *); 57static void play_fd(const char *, int); 58static ssize_t audioctl_write_fromhdr(void *, size_t, int, 59 off_t *, const char *, 60 convert *); 61static void cleanup(int) __dead; 62 63static audio_info_t info; 64static int volume; 65static int balance; 66static int port; 67static int fflag; 68static int nflag; 69static int qflag; 70int verbose; 71static int sample_rate; 72static int encoding; 73static char *encoding_str; 74static int precision; 75static int channels; 76 77static char const *play_errstring = NULL; 78static size_t bufsize; 79static int audiofd = -1; 80static int exitstatus = EXIT_SUCCESS; 81 82int 83main(int argc, char *argv[]) 84{ 85 size_t len; 86 int ch; 87 int iflag = 0; 88 const char *defdevice = _PATH_SOUND; 89 const char *device = NULL; 90 91 while ((ch = getopt(argc, argv, "b:B:C:c:d:e:fhinp:P:qs:Vv:")) != -1) { 92 switch (ch) { 93 case 'b': 94 decode_int(optarg, &balance); 95 if (balance < 0 || balance > 64) 96 errx(1, "balance must be between 0 and 63"); 97 break; 98 case 'B': 99 bufsize = strsuftoll("write buffer size", optarg, 100 1, UINT_MAX); 101 break; 102 case 'c': 103 decode_int(optarg, &channels); 104 if (channels < 0) 105 errx(1, "channels must be positive"); 106 break; 107 case 'C': 108 /* Ignore, compatibility */ 109 break; 110 case 'd': 111 device = optarg; 112 break; 113 case 'e': 114 encoding_str = optarg; 115 break; 116 case 'f': 117 fflag = 1; 118 break; 119 case 'i': 120 iflag++; 121 break; 122 case 'n': 123 nflag++; 124 break; 125 case 'q': 126 qflag++; 127 break; 128 case 'P': 129 decode_int(optarg, &precision); 130 if (precision != 4 && precision != 8 && 131 precision != 16 && precision != 24 && 132 precision != 32) 133 errx(1, "precision must be between 4, 8, 16, 24 or 32"); 134 break; 135 case 'p': 136 len = strlen(optarg); 137 138 if (strncmp(optarg, "speaker", len) == 0) 139 port |= AUDIO_SPEAKER; 140 else if (strncmp(optarg, "headphone", len) == 0) 141 port |= AUDIO_HEADPHONE; 142 else if (strncmp(optarg, "line", len) == 0) 143 port |= AUDIO_LINE_OUT; 144 else 145 errx(1, 146 "port must be `speaker', `headphone', or `line'"); 147 break; 148 case 's': 149 decode_int(optarg, &sample_rate); 150 if (sample_rate < 0 || sample_rate > 48000 * 2) /* XXX */ 151 errx(1, "sample rate must be between 0 and 96000"); 152 break; 153 case 'V': 154 verbose++; 155 break; 156 case 'v': 157 volume = atoi(optarg); 158 if (volume < 0 || volume > 255) 159 errx(1, "volume must be between 0 and 255"); 160 break; 161 /* case 'h': */ 162 default: 163 usage(); 164 /* NOTREACHED */ 165 } 166 } 167 argc -= optind; 168 argv += optind; 169 170 if (encoding_str) { 171 encoding = audio_enc_to_val(encoding_str); 172 if (encoding == -1) 173 errx(1, "unknown encoding, bailing..."); 174 } 175 176 if (device == NULL && (device = getenv("AUDIODEVICE")) == NULL && 177 (device = getenv("AUDIODEV")) == NULL) /* Sun compatibility */ 178 device = defdevice; 179 180 if (!nflag) { 181 audiofd = open(device, O_WRONLY); 182 if (audiofd < 0 && device == defdevice) { 183 device = _PATH_SOUND0; 184 audiofd = open(device, O_WRONLY); 185 } 186 if (audiofd < 0) 187 err(1, "failed to open %s", device); 188 189 if (ioctl(audiofd, AUDIO_GETINFO, &info) < 0) 190 err(1, "failed to get audio info"); 191 if (bufsize == 0) 192 bufsize = info.play.buffer_size; 193 } 194 if (bufsize == 0) 195 bufsize = 32 * 1024; 196 197 signal(SIGINT, cleanup); 198 signal(SIGTERM, cleanup); 199 signal(SIGHUP, cleanup); 200 201 if (*argv) 202 do 203 play(*argv++); 204 while (*argv); 205 else 206 play_fd("standard input", STDIN_FILENO); 207 208 cleanup(0); 209} 210 211static void 212cleanup(int signo) 213{ 214 215 if (audiofd != -1) { 216 (void)ioctl(audiofd, AUDIO_FLUSH, NULL); 217 (void)ioctl(audiofd, AUDIO_SETINFO, &info); 218 close(audiofd); 219 audiofd = -1; 220 } 221 if (signo != 0) { 222 (void)raise_default_signal(signo); 223 } 224 exit(exitstatus); 225} 226 227#ifndef __vax__ 228static size_t 229float32_to_linear32(void *inbuf, void *outbuf, size_t len) 230{ 231 uint8_t *inbuf8 = inbuf, *end = inbuf8 + len; 232 uint8_t *outbuf8 = outbuf; 233 float f; 234 int32_t i; 235 236 while (inbuf8 + sizeof f <= end) { 237 memcpy(&f, inbuf8, sizeof f); 238 239 /* saturate */ 240 if (f < -1.0) 241 f = -1.0; 242 if (f > 1.0) 243 f = 1.0; 244 245 /* Convert -1.0 to +1.0 into a 32 bit signed value */ 246 i = f * (float)INT32_MAX; 247 248 memcpy(outbuf8, &i, sizeof i); 249 250 inbuf8 += sizeof f; 251 outbuf8 += sizeof i; 252 } 253 254 return len; 255} 256 257static size_t 258float64_to_linear32(void *inbuf, void *outbuf, size_t len) 259{ 260 uint8_t *inbuf8 = inbuf, *end = inbuf8 + len; 261 uint8_t *outbuf8 = outbuf; 262 double f; 263 int32_t i; 264 265 while (inbuf8 + sizeof f <= end) { 266 memcpy(&f, inbuf8, sizeof f); 267 268 /* saturate */ 269 if (f < -1.0) 270 f = -1.0; 271 if (f > 1.0) 272 f = 1.0; 273 274 /* Convert -1.0 to +1.0 into a 32 bit signed value */ 275 i = f * ((1u << 31) - 1); 276 277 memcpy(outbuf8, &i, sizeof i); 278 279 inbuf8 += sizeof f; 280 outbuf8 += sizeof i; 281 } 282 283 return len / 2; 284} 285#endif /* __vax__ */ 286 287static size_t 288audio_write(int fd, void *buf, size_t len, convert conv) 289{ 290 static void *convert_buffer; 291 static size_t convert_buffer_size; 292 293 if (nflag) 294 return len; 295 296 if (conv == NULL) 297 return write(fd, buf, len); 298 299 if (convert_buffer == NULL || convert_buffer_size < len) { 300 free(convert_buffer); 301 convert_buffer = malloc(len); 302 if (convert_buffer == NULL) 303 err(1, "malloc of convert buffer failed"); 304 convert_buffer_size = len; 305 } 306 len = conv(buf, convert_buffer, len); 307 return write(fd, convert_buffer, len); 308} 309 310static void 311play(char *file) 312{ 313 convert conv = NULL; 314 struct stat sb; 315 void *addr, *oaddr; 316 off_t filesize; 317 size_t sizet_filesize; 318 off_t datasize = 0; 319 ssize_t hdrlen; 320 int fd; 321 int nw; 322 323 if (file[0] == '-' && file[1] == 0) { 324 play_fd("standard input", STDIN_FILENO); 325 return; 326 } 327 328 fd = open(file, O_RDONLY); 329 if (fd < 0) { 330 warn("could not open %s", file); 331 exitstatus = EXIT_FAILURE; 332 return; 333 } 334 335 if (fstat(fd, &sb) < 0) 336 err(1, "could not fstat %s", file); 337 filesize = sb.st_size; 338 sizet_filesize = (size_t)filesize; 339 340 /* 341 * if the file is not a regular file, doesn't fit in a size_t, 342 * or if we failed to mmap the file, try to read it instead, so 343 * that filesystems, etc, that do not support mmap() work 344 */ 345 if (!S_ISREG(sb.st_mode) || 346 ((off_t)sizet_filesize != filesize) || 347 (oaddr = addr = mmap(0, sizet_filesize, PROT_READ, 348 MAP_SHARED, fd, 0)) == MAP_FAILED) { 349 play_fd(file, fd); 350 close(fd); 351 return; 352 } 353 354 /* 355 * give the VM system a bit of a hint about the type 356 * of accesses we will make. we don't care about errors. 357 */ 358 madvise(addr, sizet_filesize, MADV_SEQUENTIAL); 359 360 /* 361 * get the header length and set up the audio device, and 362 * determine any conversion needed. 363 */ 364 if ((hdrlen = audioctl_write_fromhdr(addr, 365 sizet_filesize, audiofd, &datasize, file, &conv)) < 0) { 366 if (play_errstring) 367 errx(1, "%s: %s", play_errstring, file); 368 else 369 errx(1, "unknown audio file: %s", file); 370 } 371 if (verbose) 372 printf("header length: %zd\n", hdrlen); 373 374 filesize -= hdrlen; 375 addr = (char *)addr + hdrlen; 376 if (filesize < datasize || datasize == 0) { 377 if (filesize < datasize) 378 warnx("bogus datasize: %ld", (u_long)datasize); 379 datasize = filesize; 380 } 381 382 while ((uint64_t)datasize > bufsize) { 383 nw = audio_write(audiofd, addr, bufsize, conv); 384 if (nw == -1) 385 err(1, "write failed"); 386 if ((size_t)nw != bufsize) 387 errx(1, "write failed"); 388 addr = (char *)addr + bufsize; 389 datasize -= bufsize; 390 } 391 nw = audio_write(audiofd, addr, datasize, conv); 392 if (nw == -1) 393 err(1, "final write failed"); 394 if ((off_t)nw != datasize) 395 errx(1, "final write failed"); 396 397 if (!nflag && ioctl(audiofd, AUDIO_DRAIN) < 0 && !qflag) 398 warn("audio drain ioctl failed"); 399 if (munmap(oaddr, sizet_filesize) < 0) 400 err(1, "munmap failed"); 401 402 close(fd); 403} 404 405/* 406 * play the file on the file descriptor fd 407 */ 408static void 409play_fd(const char *file, int fd) 410{ 411 convert conv = NULL; 412 char *buffer = malloc(bufsize); 413 ssize_t hdrlen; 414 int nr, nw; 415 off_t datasize = 0; 416 off_t dataout = 0; 417 418 if (buffer == NULL) 419 err(1, "malloc of read buffer failed"); 420 421 nr = read(fd, buffer, bufsize); 422 if (nr < 0) 423 goto read_error; 424 if (nr == 0) { 425 if (fflag) { 426 free(buffer); 427 return; 428 } 429 err(1, "unexpected EOF"); 430 } 431 hdrlen = audioctl_write_fromhdr(buffer, nr, audiofd, &datasize, file, &conv); 432 if (hdrlen < 0) { 433 if (play_errstring) 434 errx(1, "%s: %s", play_errstring, file); 435 else 436 errx(1, "unknown audio file: %s", file); 437 } 438 if (hdrlen > 0) { 439 if (hdrlen > nr) /* shouldn't happen */ 440 errx(1, "header seems really large: %lld", (long long)hdrlen); 441 memmove(buffer, buffer + hdrlen, nr - hdrlen); 442 nr -= hdrlen; 443 } 444 while (datasize == 0 || dataout < datasize) { 445 if (datasize != 0 && dataout + nr > datasize) 446 nr = datasize - dataout; 447 nw = audio_write(audiofd, buffer, nr, conv); 448 if (nw == -1) 449 err(1, "audio device write failed"); 450 if (nw != nr) 451 errx(1, "audio device write failed"); 452 dataout += nw; 453 nr = read(fd, buffer, bufsize); 454 if (nr == -1) 455 goto read_error; 456 if (nr == 0) 457 break; 458 } 459 /* something to think about: no message given for dataout < datasize */ 460 if (!nflag && ioctl(audiofd, AUDIO_DRAIN) < 0 && !qflag) 461 warn("audio drain ioctl failed"); 462 return; 463read_error: 464 err(1, "read of standard input failed"); 465} 466 467/* 468 * only support sun and wav audio files so far ... 469 * 470 * XXX this should probably be mostly part of libaudio, but it 471 * uses the local "info" variable. blah... fix me! 472 */ 473static ssize_t 474audioctl_write_fromhdr(void *hdr, size_t fsz, int fd, off_t *datasize, const char *file, convert *conv) 475{ 476 sun_audioheader *sunhdr; 477 ssize_t hdr_len = 0; 478 479 *conv = NULL; 480 481 AUDIO_INITINFO(&info); 482 sunhdr = hdr; 483 if (ntohl(sunhdr->magic) == AUDIO_FILE_MAGIC) { 484 if (audio_sun_to_encoding(ntohl(sunhdr->encoding), 485 &info.play.encoding, &info.play.precision)) { 486 if (!qflag) 487 warnx("unknown unsupported Sun audio encoding" 488 " format %d", ntohl(sunhdr->encoding)); 489 if (fflag) 490 goto set_audio_mode; 491 return (-1); 492 } 493 494 info.play.sample_rate = ntohl(sunhdr->sample_rate); 495 info.play.channels = ntohl(sunhdr->channels); 496 hdr_len = ntohl(sunhdr->hdr_size); 497 498 *datasize = (off_t)ntohl(sunhdr->data_size); 499 goto set_audio_mode; 500 } 501 502 hdr_len = audio_wav_parse_hdr(hdr, fsz, &info.play.encoding, 503 &info.play.precision, &info.play.sample_rate, &info.play.channels, 504 datasize); 505 506 switch (hdr_len) { 507 case AUDIO_ESHORTHDR: 508 case AUDIO_EWAVUNSUPP: 509 case AUDIO_EWAVBADPCM: 510 case AUDIO_EWAVNODATA: 511 play_errstring = audio_errstring(hdr_len); 512 /* FALL THROUGH */ 513 case AUDIO_ENOENT: 514 break; 515 default: 516 if (hdr_len < 1) 517 break; 518 goto set_audio_mode; 519 } 520 /* 521 * if we don't know it, bail unless we are forcing. 522 */ 523 if (fflag == 0) 524 return (-1); 525set_audio_mode: 526 if (port) 527 info.play.port = port; 528 if (volume) 529 info.play.gain = volume; 530 if (balance) 531 info.play.balance = balance; 532 if (fflag) { 533 if (sample_rate) 534 info.play.sample_rate = sample_rate; 535 if (channels) 536 info.play.channels = channels; 537 if (encoding) 538 info.play.encoding = encoding; 539 if (precision) 540 info.play.precision = precision; 541 hdr_len = 0; 542 } 543 info.mode = AUMODE_PLAY_ALL; 544 545 if (verbose) { 546 const char *enc = audio_enc_from_val(info.play.encoding); 547 548 printf("%s: sample_rate=%d channels=%d " 549 "datasize=%lld " 550 "precision=%d%s%s\n", file, 551 info.play.sample_rate, 552 info.play.channels, 553 (long long)*datasize, 554 info.play.precision, 555 enc ? " encoding=" : "", 556 enc ? enc : ""); 557 } 558 559#ifndef __vax__ 560 if (info.play.encoding == AUDIO_ENCODING_LIBAUDIO_FLOAT32 || 561 info.play.encoding == AUDIO_ENCODING_LIBAUDIO_FLOAT64) { 562 const char *msg; 563 564 if (info.play.encoding == AUDIO_ENCODING_LIBAUDIO_FLOAT32) { 565 if (sizeof(float) * CHAR_BIT != 32) 566 return -1; 567 *conv = float32_to_linear32; 568 msg = "32"; 569 } else { 570 if (sizeof(double) * CHAR_BIT != 64) 571 return -1; 572 *conv = float64_to_linear32; 573 msg = "64"; 574 } 575 info.play.encoding = AUDIO_ENCODING_SLINEAR_LE; 576 info.play.precision = 32; 577 if (verbose) 578 printf("%s: converting IEEE float%s to precision=%d " 579 "encoding=%s\n", file, msg, 580 info.play.precision, 581 audio_enc_from_val(info.play.encoding)); 582 } 583#endif /* __vax__ */ 584 585 if (!nflag && ioctl(fd, AUDIO_SETINFO, &info) < 0) 586 err(1, "failed to set audio info"); 587 588 return (hdr_len); 589} 590 591static void 592usage(void) 593{ 594 595 fprintf(stderr, "Usage: %s [-hinqV] [options] files\n", getprogname()); 596 fprintf(stderr, "Options:\n\t" 597 "-B buffer size\n\t" 598 "-b balance (0-63)\n\t" 599 "-d audio device\n\t" 600 "-f force settings\n\t" 601 "\t-c forced channels\n\t" 602 "\t-e forced encoding\n\t" 603 "\t-P forced precision\n\t" 604 "\t-s forced sample rate\n\t" 605 "-i header information\n\t" 606 "-p output port\n\t" 607 "-v volume\n"); 608 exit(EXIT_FAILURE); 609} 610