/* $NetBSD: play.c,v 1.57.2.1 2024/03/12 12:41:39 martin Exp $ */ /* * Copyright (c) 1999, 2000, 2001, 2002, 2010, 2015, 2019, 2021 Matthew R. Green * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ #include #ifndef lint __RCSID("$NetBSD: play.c,v 1.57.2.1 2024/03/12 12:41:39 martin Exp $"); #endif #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "libaudio.h" typedef size_t (*convert)(void *inbuf, void *outbuf, size_t len); static void usage(void) __dead; static void play(char *); static void play_fd(const char *, int); static ssize_t audioctl_write_fromhdr(void *, size_t, int, off_t *, const char *, convert *); static void cleanup(int) __dead; static audio_info_t info; static int volume; static int balance; static int port; static int fflag; static int nflag; static int qflag; int verbose; static int sample_rate; static int encoding; static char *encoding_str; static int precision; static int channels; static char const *play_errstring = NULL; static size_t bufsize; static int audiofd = -1; static int exitstatus = EXIT_SUCCESS; int main(int argc, char *argv[]) { size_t len; int ch; int iflag = 0; const char *defdevice = _PATH_SOUND; const char *device = NULL; while ((ch = getopt(argc, argv, "b:B:C:c:d:e:fhinp:P:qs:Vv:")) != -1) { switch (ch) { case 'b': decode_int(optarg, &balance); if (balance < 0 || balance > 64) errx(1, "balance must be between 0 and 63"); break; case 'B': bufsize = strsuftoll("write buffer size", optarg, 1, UINT_MAX); break; case 'c': decode_int(optarg, &channels); if (channels < 0) errx(1, "channels must be positive"); break; case 'C': /* Ignore, compatibility */ break; case 'd': device = optarg; break; case 'e': encoding_str = optarg; break; case 'f': fflag = 1; break; case 'i': iflag++; break; case 'n': nflag++; break; case 'q': qflag++; break; case 'P': decode_int(optarg, &precision); if (precision != 4 && precision != 8 && precision != 16 && precision != 24 && precision != 32) errx(1, "precision must be between 4, 8, 16, 24 or 32"); break; case 'p': len = strlen(optarg); if (strncmp(optarg, "speaker", len) == 0) port |= AUDIO_SPEAKER; else if (strncmp(optarg, "headphone", len) == 0) port |= AUDIO_HEADPHONE; else if (strncmp(optarg, "line", len) == 0) port |= AUDIO_LINE_OUT; else errx(1, "port must be `speaker', `headphone', or `line'"); break; case 's': decode_int(optarg, &sample_rate); if (sample_rate < 0 || sample_rate > 48000 * 2) /* XXX */ errx(1, "sample rate must be between 0 and 96000"); break; case 'V': verbose++; break; case 'v': volume = atoi(optarg); if (volume < 0 || volume > 255) errx(1, "volume must be between 0 and 255"); break; /* case 'h': */ default: usage(); /* NOTREACHED */ } } argc -= optind; argv += optind; if (encoding_str) { encoding = audio_enc_to_val(encoding_str); if (encoding == -1) errx(1, "unknown encoding, bailing..."); } if (device == NULL && (device = getenv("AUDIODEVICE")) == NULL && (device = getenv("AUDIODEV")) == NULL) /* Sun compatibility */ device = defdevice; if (!nflag) { audiofd = open(device, O_WRONLY); if (audiofd < 0 && device == defdevice) { device = _PATH_SOUND0; audiofd = open(device, O_WRONLY); } if (audiofd < 0) err(1, "failed to open %s", device); if (ioctl(audiofd, AUDIO_GETINFO, &info) < 0) err(1, "failed to get audio info"); if (bufsize == 0) bufsize = info.play.buffer_size; } if (bufsize == 0) bufsize = 32 * 1024; signal(SIGINT, cleanup); signal(SIGTERM, cleanup); signal(SIGHUP, cleanup); if (*argv) do play(*argv++); while (*argv); else play_fd("standard input", STDIN_FILENO); cleanup(0); } static void cleanup(int signo) { if (audiofd != -1) { (void)ioctl(audiofd, AUDIO_FLUSH, NULL); (void)ioctl(audiofd, AUDIO_SETINFO, &info); close(audiofd); audiofd = -1; } if (signo != 0) { (void)raise_default_signal(signo); } exit(exitstatus); } #ifndef __vax__ static size_t float32_to_linear32(void *inbuf, void *outbuf, size_t len) { uint8_t *inbuf8 = inbuf, *end = inbuf8 + len; uint8_t *outbuf8 = outbuf; float f; int32_t i; while (inbuf8 + sizeof f <= end) { memcpy(&f, inbuf8, sizeof f); /* saturate */ if (f < -1.0) f = -1.0; if (f > 1.0) f = 1.0; /* Convert -1.0 to +1.0 into a 32 bit signed value */ i = f * (float)INT32_MAX; memcpy(outbuf8, &i, sizeof i); inbuf8 += sizeof f; outbuf8 += sizeof i; } return len; } static size_t float64_to_linear32(void *inbuf, void *outbuf, size_t len) { uint8_t *inbuf8 = inbuf, *end = inbuf8 + len; uint8_t *outbuf8 = outbuf; double f; int32_t i; while (inbuf8 + sizeof f <= end) { memcpy(&f, inbuf8, sizeof f); /* saturate */ if (f < -1.0) f = -1.0; if (f > 1.0) f = 1.0; /* Convert -1.0 to +1.0 into a 32 bit signed value */ i = f * ((1u << 31) - 1); memcpy(outbuf8, &i, sizeof i); inbuf8 += sizeof f; outbuf8 += sizeof i; } return len / 2; } #endif /* __vax__ */ static size_t audio_write(int fd, void *buf, size_t len, convert conv) { static void *convert_buffer; static size_t convert_buffer_size; if (nflag) return len; if (conv == NULL) return write(fd, buf, len); if (convert_buffer == NULL || convert_buffer_size < len) { free(convert_buffer); convert_buffer = malloc(len); if (convert_buffer == NULL) err(1, "malloc of convert buffer failed"); convert_buffer_size = len; } len = conv(buf, convert_buffer, len); return write(fd, convert_buffer, len); } static void play(char *file) { convert conv = NULL; struct stat sb; void *addr, *oaddr; off_t filesize; size_t sizet_filesize; off_t datasize = 0; ssize_t hdrlen; int fd; int nw; if (file[0] == '-' && file[1] == 0) { play_fd("standard input", STDIN_FILENO); return; } fd = open(file, O_RDONLY); if (fd < 0) { warn("could not open %s", file); exitstatus = EXIT_FAILURE; return; } if (fstat(fd, &sb) < 0) err(1, "could not fstat %s", file); filesize = sb.st_size; sizet_filesize = (size_t)filesize; /* * if the file is not a regular file, doesn't fit in a size_t, * or if we failed to mmap the file, try to read it instead, so * that filesystems, etc, that do not support mmap() work */ if (!S_ISREG(sb.st_mode) || ((off_t)sizet_filesize != filesize) || (oaddr = addr = mmap(0, sizet_filesize, PROT_READ, MAP_SHARED, fd, 0)) == MAP_FAILED) { play_fd(file, fd); close(fd); return; } /* * give the VM system a bit of a hint about the type * of accesses we will make. we don't care about errors. */ madvise(addr, sizet_filesize, MADV_SEQUENTIAL); /* * get the header length and set up the audio device, and * determine any conversion needed. */ if ((hdrlen = audioctl_write_fromhdr(addr, sizet_filesize, audiofd, &datasize, file, &conv)) < 0) { if (play_errstring) errx(1, "%s: %s", play_errstring, file); else errx(1, "unknown audio file: %s", file); } if (verbose) printf("header length: %zd\n", hdrlen); filesize -= hdrlen; addr = (char *)addr + hdrlen; if (filesize < datasize || datasize == 0) { if (filesize < datasize) warnx("bogus datasize: %ld", (u_long)datasize); datasize = filesize; } while ((uint64_t)datasize > bufsize) { nw = audio_write(audiofd, addr, bufsize, conv); if (nw == -1) err(1, "write failed"); if ((size_t)nw != bufsize) errx(1, "write failed"); addr = (char *)addr + bufsize; datasize -= bufsize; } nw = audio_write(audiofd, addr, datasize, conv); if (nw == -1) err(1, "final write failed"); if ((off_t)nw != datasize) errx(1, "final write failed"); if (!nflag && ioctl(audiofd, AUDIO_DRAIN) < 0 && !qflag) warn("audio drain ioctl failed"); if (munmap(oaddr, sizet_filesize) < 0) err(1, "munmap failed"); close(fd); } /* * play the file on the file descriptor fd */ static void play_fd(const char *file, int fd) { convert conv = NULL; char *buffer = malloc(bufsize); ssize_t hdrlen; int nr, nw; off_t datasize = 0; off_t dataout = 0; if (buffer == NULL) err(1, "malloc of read buffer failed"); nr = read(fd, buffer, bufsize); if (nr < 0) goto read_error; if (nr == 0) { if (fflag) { free(buffer); return; } err(1, "unexpected EOF"); } hdrlen = audioctl_write_fromhdr(buffer, nr, audiofd, &datasize, file, &conv); if (hdrlen < 0) { if (play_errstring) errx(1, "%s: %s", play_errstring, file); else errx(1, "unknown audio file: %s", file); } if (hdrlen > 0) { if (hdrlen > nr) /* shouldn't happen */ errx(1, "header seems really large: %lld", (long long)hdrlen); memmove(buffer, buffer + hdrlen, nr - hdrlen); nr -= hdrlen; } while (datasize == 0 || dataout < datasize) { if (datasize != 0 && dataout + nr > datasize) nr = datasize - dataout; nw = audio_write(audiofd, buffer, nr, conv); if (nw == -1) err(1, "audio device write failed"); if (nw != nr) errx(1, "audio device write failed"); dataout += nw; nr = read(fd, buffer, bufsize); if (nr == -1) goto read_error; if (nr == 0) break; } /* something to think about: no message given for dataout < datasize */ if (!nflag && ioctl(audiofd, AUDIO_DRAIN) < 0 && !qflag) warn("audio drain ioctl failed"); return; read_error: err(1, "read of standard input failed"); } /* * only support sun and wav audio files so far ... * * XXX this should probably be mostly part of libaudio, but it * uses the local "info" variable. blah... fix me! */ static ssize_t audioctl_write_fromhdr(void *hdr, size_t fsz, int fd, off_t *datasize, const char *file, convert *conv) { sun_audioheader *sunhdr; ssize_t hdr_len = 0; *conv = NULL; AUDIO_INITINFO(&info); sunhdr = hdr; if (ntohl(sunhdr->magic) == AUDIO_FILE_MAGIC) { if (audio_sun_to_encoding(ntohl(sunhdr->encoding), &info.play.encoding, &info.play.precision)) { if (!qflag) warnx("unknown unsupported Sun audio encoding" " format %d", ntohl(sunhdr->encoding)); if (fflag) goto set_audio_mode; return (-1); } info.play.sample_rate = ntohl(sunhdr->sample_rate); info.play.channels = ntohl(sunhdr->channels); hdr_len = ntohl(sunhdr->hdr_size); *datasize = (off_t)ntohl(sunhdr->data_size); goto set_audio_mode; } hdr_len = audio_wav_parse_hdr(hdr, fsz, &info.play.encoding, &info.play.precision, &info.play.sample_rate, &info.play.channels, datasize); switch (hdr_len) { case AUDIO_ESHORTHDR: case AUDIO_EWAVUNSUPP: case AUDIO_EWAVBADPCM: case AUDIO_EWAVNODATA: play_errstring = audio_errstring(hdr_len); /* FALL THROUGH */ case AUDIO_ENOENT: break; default: if (hdr_len < 1) break; goto set_audio_mode; } /* * if we don't know it, bail unless we are forcing. */ if (fflag == 0) return (-1); set_audio_mode: if (port) info.play.port = port; if (volume) info.play.gain = volume; if (balance) info.play.balance = balance; if (fflag) { if (sample_rate) info.play.sample_rate = sample_rate; if (channels) info.play.channels = channels; if (encoding) info.play.encoding = encoding; if (precision) info.play.precision = precision; hdr_len = 0; } info.mode = AUMODE_PLAY_ALL; if (verbose) { const char *enc = audio_enc_from_val(info.play.encoding); printf("%s: sample_rate=%d channels=%d " "datasize=%lld " "precision=%d%s%s\n", file, info.play.sample_rate, info.play.channels, (long long)*datasize, info.play.precision, enc ? " encoding=" : "", enc ? enc : ""); } #ifndef __vax__ if (info.play.encoding == AUDIO_ENCODING_LIBAUDIO_FLOAT32 || info.play.encoding == AUDIO_ENCODING_LIBAUDIO_FLOAT64) { const char *msg; if (info.play.encoding == AUDIO_ENCODING_LIBAUDIO_FLOAT32) { if (sizeof(float) * CHAR_BIT != 32) return -1; *conv = float32_to_linear32; msg = "32"; } else { if (sizeof(double) * CHAR_BIT != 64) return -1; *conv = float64_to_linear32; msg = "64"; } info.play.encoding = AUDIO_ENCODING_SLINEAR_LE; info.play.precision = 32; if (verbose) printf("%s: converting IEEE float%s to precision=%d " "encoding=%s\n", file, msg, info.play.precision, audio_enc_from_val(info.play.encoding)); } #endif /* __vax__ */ if (!nflag && ioctl(fd, AUDIO_SETINFO, &info) < 0) err(1, "failed to set audio info"); return (hdr_len); } static void usage(void) { fprintf(stderr, "Usage: %s [-hinqV] [options] files\n", getprogname()); fprintf(stderr, "Options:\n\t" "-B buffer size\n\t" "-b balance (0-63)\n\t" "-d audio device\n\t" "-f force settings\n\t" "\t-c forced channels\n\t" "\t-e forced encoding\n\t" "\t-P forced precision\n\t" "\t-s forced sample rate\n\t" "-i header information\n\t" "-p output port\n\t" "-v volume\n"); exit(EXIT_FAILURE); }