/* * CDDL HEADER START * * The contents of this file are subject to the terms of the * Common Development and Distribution License (the "License"). * You may not use this file except in compliance with the License. * * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE * or http://www.opensolaris.org/os/licensing. * See the License for the specific language governing permissions * and limitations under the License. * * When distributing Covered Code, include this CDDL HEADER in each * file and include the License file at usr/src/OPENSOLARIS.LICENSE. * If applicable, add the following below this CDDL HEADER, with the * fields enclosed by brackets "[]" replaced with your own identifying * information: Portions Copyright [yyyy] [name of copyright owner] * * CDDL HEADER END */ /* * Copyright 2009 Sun Microsystems, Inc. All rights reserved. * Use is subject to license terms. */ /* * Copyright (c) 2018, Joyent, Inc. */ /* Command-line audio play utility */ #include #include #include #include #include #include #include #include #include /* All occurances of INT_MAX used to be ~0 (by MCA) */ #include #include #include #include #include #include #include #include #include #include #include #include /* localization stuff */ #define MGET(s) (char *)gettext(s) #if !defined(TEXT_DOMAIN) /* Should be defined by cc -D */ #define TEXT_DOMAIN "SYS_TEST" /* Use this only if it weren't */ #endif #define Error (void) fprintf /* Local variables */ static char *prog; static char prog_opts[] = "VEiv:d:?"; /* getopt() flags */ static char *Stdin; #define MAX_GAIN (100) /* maximum gain */ /* * This defines the tolerable sample rate error as a ratio between the * sample rates of the audio data and the audio device. */ #define SAMPLE_RATE_THRESHOLD (.01) #define BUFFER_LEN 10 /* seconds - for file i/o */ #define ADPCM_SIZE (1000*8) /* adpcm conversion output buf size */ #define SWAP_SIZE (8192) /* swap bytes conversion output buf size */ static unsigned Volume = INT_MAX; /* output volume */ static double Savevol; /* saved volume level */ static int Verbose = FALSE; /* verbose messages */ static int Immediate = FALSE; /* don't hang waiting for device */ static int Errdetect = FALSE; /* don't worry about underrun */ static char *Audio_dev = "/dev/audio"; static int NetEndian = TRUE; /* endian nature of the machine */ static int Audio_fd = -1; /* file descriptor for audio device */ static int Audio_ctlfd = -1; /* file descriptor for control device */ static Audio_hdr Save_hdr; /* saved audio header for device */ static Audio_hdr Dev_hdr; /* audio header for device */ static char *Ifile; /* current filename */ static Audio_hdr File_hdr; /* audio header for file */ static unsigned Decode = AUDIO_ENCODING_NONE; /* decode type, if any */ static unsigned char *buf = NULL; /* dynamically alloc'd */ static unsigned bufsiz = 0; /* size of output buffer */ static unsigned char adpcm_buf[ADPCM_SIZE + 32]; /* for adpcm conversion */ static unsigned char swap_buf[SWAP_SIZE + 32]; /* for byte swap conversion */ static unsigned char *inbuf; /* current input buffer pointer */ static unsigned insiz; /* current input buffer size */ /* * The decode_g72x() function is capable of decoding only one channel * at a time and so multichannel data must be decomposed (using demux() * function below ) into its constituent channels and each passed * separately to the decode_g72x() function. Encoded input channels are * stored in **in_ch_data and decoded output channels in **out_ch_data. * Once each channel has been decoded they are recombined (see mux() * function below) before being written to the audio device. For each * channel and adpcm state structure is created. */ /* adpcm state structures */ static struct audio_g72x_state *adpcm_state = NULL; static unsigned char **in_ch_data = NULL; /* input channels */ static unsigned char **out_ch_data = NULL; /* output channels */ static int out_ch_size; /* output channel size */ static char *Audio_path = NULL; /* path to search for audio files */ /* Global variables */ extern int getopt(int, char *const *, const char *); extern int optind; extern char *optarg; /* Local functions */ static void usage(void); static void sigint(int sig); static void open_audio(void); static int path_open(char *fname, int flags, mode_t mode, char *path); static int parse_unsigned(char *str, unsigned *dst, char *flag); static int reconfig(void); static void initmux(int unitsz, int unitsp); static void demux(int unitsz, int cnt); static void mux(char *); static void freemux(void); static void usage(void) { Error(stderr, MGET("Play an audio file -- usage:\n" "\t%s [-iV] [-v vol] [-d dev] [file ...]\n" "where:\n" "\t-i\tDon't hang if audio device is busy\n" "\t-V\tPrint verbose warning messages\n" "\t-v\tSet output volume (0 - %d)\n" "\t-d\tSpecify audio device (default: /dev/audio)\n" "\tfile\tList of files to play\n" "\t\tIf no files specified, read stdin\n"), prog, MAX_GAIN); exit(1); } static void sigint(int sig) { /* flush output queues before exiting */ if (Audio_fd >= 0) { (void) audio_flush_play(Audio_fd); /* restore saved parameters */ if (Volume != INT_MAX) (void) audio_set_play_gain(Audio_fd, &Savevol); if ((Audio_ctlfd >= 0) && (audio_cmp_hdr(&Save_hdr, &Dev_hdr) != 0)) { (void) audio_set_play_config(Audio_fd, &Save_hdr); } } exit(1); } /* Open the audio device and initalize it. */ static void open_audio(void) { int err; double vol; /* Return if already open */ if (Audio_fd >= 0) return; /* Try opening without waiting, first */ Audio_fd = open(Audio_dev, O_WRONLY | O_NONBLOCK); if ((Audio_fd < 0) && (errno == EBUSY)) { if (Immediate) { Error(stderr, MGET("%s: %s is busy\n"), prog, Audio_dev); exit(1); } if (Verbose) { Error(stderr, MGET("%s: waiting for %s..."), prog, Audio_dev); (void) fflush(stderr); } /* Now hang until it's open */ Audio_fd = open(Audio_dev, O_WRONLY); if (Verbose) Error(stderr, (Audio_fd < 0) ? "\n" : MGET("open\n")); } if (Audio_fd < 0) { Error(stderr, MGET("%s: error opening "), prog); perror(Audio_dev); exit(1); } /* Clear the non-blocking flag (in System V it persists after open) */ (void) fcntl(Audio_fd, F_SETFL, (fcntl(Audio_fd, F_GETFL, 0) & ~(O_NDELAY | O_NONBLOCK))); /* Get the device output encoding configuration */ if (audio_get_play_config(Audio_fd, &Dev_hdr) != AUDIO_SUCCESS) { Error(stderr, MGET("%s: %s is not an audio device\n"), prog, Audio_dev); exit(1); } /* If -v flag, set the output volume now */ if (Volume != INT_MAX) { vol = (double)Volume / (double)MAX_GAIN; (void) audio_get_play_gain(Audio_fd, &Savevol); err = audio_set_play_gain(Audio_fd, &vol); if (err != AUDIO_SUCCESS) { Error(stderr, MGET("%s: could not set output volume for %s\n"), prog, Audio_dev); exit(1); } } } /* Play a list of audio files. */ int main(int argc, char **argv) { int errorStatus = 0; int i; int c; int cnt; int file_type; int rem; int outsiz; int tsize; int len; int err; int ifd; int stdinseen; int regular; int swapBytes; int frame; char *outbuf; caddr_t mapaddr; struct stat st; char *cp; char ctldev[MAXPATHLEN]; (void) setlocale(LC_ALL, ""); (void) textdomain(TEXT_DOMAIN); /* Get the program name */ prog = strrchr(argv[0], '/'); if (prog == NULL) prog = argv[0]; else prog++; Stdin = MGET("(stdin)"); /* Check AUDIODEV environment for audio device name */ if (cp = getenv("AUDIODEV")) { Audio_dev = cp; } /* Parse the command line arguments */ err = 0; while ((i = getopt(argc, argv, prog_opts)) != EOF) { switch (i) { case 'v': if (parse_unsigned(optarg, &Volume, "-v")) { err++; } else if (Volume > MAX_GAIN) { Error(stderr, MGET("%s: invalid value " "for -v\n"), prog); err++; } break; case 'd': Audio_dev = optarg; break; case 'V': Verbose = TRUE; break; case 'E': Errdetect = TRUE; break; case 'i': Immediate = TRUE; break; case '?': usage(); /*NOTREACHED*/ } } if (err > 0) exit(1); argc -= optind; /* update arg pointers */ argv += optind; /* Validate and open the audio device */ err = stat(Audio_dev, &st); if (err < 0) { Error(stderr, MGET("%s: cannot stat "), prog); perror(Audio_dev); exit(1); } if (!S_ISCHR(st.st_mode)) { Error(stderr, MGET("%s: %s is not an audio device\n"), prog, Audio_dev); exit(1); } /* This should probably use audio_cntl instead of open_audio */ if ((argc <= 0) && isatty(fileno(stdin))) { Error(stderr, MGET("%s: No files and stdin is a tty.\n"), prog); exit(1); } /* Check on the -i status now. */ Audio_fd = open(Audio_dev, O_WRONLY | O_NONBLOCK); if ((Audio_fd < 0) && (errno == EBUSY)) { if (Immediate) { Error(stderr, MGET("%s: %s is busy\n"), prog, Audio_dev); exit(1); } } (void) close(Audio_fd); Audio_fd = -1; /* Try to open the control device and save the current format */ (void) snprintf(ctldev, sizeof (ctldev), "%sctl", Audio_dev); Audio_ctlfd = open(ctldev, O_RDWR); if (Audio_ctlfd >= 0) { /* * wait for the device to become available then get the * controls. We want to save the format that is left when the * device is in a quiescent state. So wait until then. */ Audio_fd = open(Audio_dev, O_WRONLY); (void) close(Audio_fd); Audio_fd = -1; if (audio_get_play_config(Audio_ctlfd, &Save_hdr) != AUDIO_SUCCESS) { (void) close(Audio_ctlfd); Audio_ctlfd = -1; } } /* store AUDIOPATH so we don't keep doing getenv() */ Audio_path = getenv("AUDIOPATH"); /* Set up SIGINT handler to flush output */ (void) signal(SIGINT, sigint); /* Set the endian nature of the machine. */ if ((ulong_t)1 != htonl((ulong_t)1)) { NetEndian = FALSE; } /* If no filenames, read stdin */ stdinseen = FALSE; if (argc <= 0) { Ifile = Stdin; } else { Ifile = *argv++; argc--; } /* Loop through all filenames */ do { /* Interpret "-" filename to mean stdin */ if (strcmp(Ifile, "-") == 0) Ifile = Stdin; if (Ifile == Stdin) { if (stdinseen) { Error(stderr, MGET("%s: stdin already processed\n"), prog); goto nextfile; } stdinseen = TRUE; ifd = fileno(stdin); } else { if ((ifd = path_open(Ifile, O_RDONLY, 0, Audio_path)) < 0) { Error(stderr, MGET("%s: cannot open "), prog); perror(Ifile); errorStatus++; goto nextfile; } } /* Check to make sure this is an audio file */ err = audio_read_filehdr(ifd, &File_hdr, &file_type, (char *)NULL, 0); if (err != AUDIO_SUCCESS) { Error(stderr, MGET("%s: %s is not a valid audio file\n"), prog, Ifile); errorStatus++; goto closeinput; } /* If G.72X adpcm, set flags for conversion */ if ((File_hdr.encoding == AUDIO_ENCODING_G721) && (File_hdr.samples_per_unit == 2) && (File_hdr.bytes_per_unit == 1)) { Decode = AUDIO_ENCODING_G721; File_hdr.encoding = AUDIO_ENCODING_ULAW; File_hdr.samples_per_unit = 1; File_hdr.bytes_per_unit = 1; adpcm_state = (struct audio_g72x_state *)malloc (sizeof (*adpcm_state) * File_hdr.channels); for (i = 0; i < File_hdr.channels; i++) { g721_init_state(&adpcm_state[i]); } } else if ((File_hdr.encoding == AUDIO_ENCODING_G723) && (File_hdr.samples_per_unit == 8) && (File_hdr.bytes_per_unit == 3)) { Decode = AUDIO_ENCODING_G723; File_hdr.encoding = AUDIO_ENCODING_ULAW; File_hdr.samples_per_unit = 1; File_hdr.bytes_per_unit = 1; adpcm_state = (struct audio_g72x_state *)malloc (sizeof (*adpcm_state) * File_hdr.channels); for (i = 0; i < File_hdr.channels; i++) { g723_init_state(&adpcm_state[i]); } } else { Decode = AUDIO_ENCODING_NONE; } /* Check the device configuration */ open_audio(); if (audio_cmp_hdr(&Dev_hdr, &File_hdr) != 0) { /* * The device does not match the input file. * Wait for any old output to drain, then attempt * to reconfigure the audio device to match the * input data. */ if (audio_drain(Audio_fd, FALSE) != AUDIO_SUCCESS) { /* Flush any remaining audio */ (void) ioctl(Audio_fd, I_FLUSH, FLUSHW); Error(stderr, MGET("%s: "), prog); perror(MGET("AUDIO_DRAIN error")); exit(1); } /* Flush any remaining audio */ (void) ioctl(Audio_fd, I_FLUSH, FLUSHW); if (!reconfig()) { errorStatus++; goto closeinput; } } /* try to do the mmaping - for regular files only ... */ err = fstat(ifd, &st); if (err < 0) { Error(stderr, MGET("%s: cannot stat "), prog); perror(Ifile); exit(1); } regular = (S_ISREG(st.st_mode)); /* If regular file, map it. Else, allocate a buffer */ mapaddr = 0; /* * This should compare to MAP_FAILED not -1, can't * find MAP_FAILED */ if (regular && ((mapaddr = mmap(0, st.st_size, PROT_READ, MAP_SHARED, ifd, 0)) != MAP_FAILED)) { (void) madvise(mapaddr, st.st_size, MADV_SEQUENTIAL); /* Skip the file header and set the proper size */ cnt = lseek(ifd, 0, SEEK_CUR); if (cnt < 0) { perror("lseek"); exit(1); } inbuf = (unsigned char *) mapaddr + cnt; len = cnt = st.st_size - cnt; } else { /* Not a regular file, or map failed */ /* mark is so. */ mapaddr = 0; /* Allocate buffer to hold 10 seconds of data */ cnt = BUFFER_LEN * File_hdr.sample_rate * File_hdr.bytes_per_unit * File_hdr.channels; if (bufsiz != cnt) { if (buf != NULL) { (void) free(buf); } buf = (unsigned char *) malloc(cnt); if (buf == NULL) { Error(stderr, MGET("%s: couldn't allocate %dK " "buf\n"), prog, bufsiz / 1000); exit(1); } inbuf = buf; bufsiz = cnt; } } /* Set buffer sizes and pointers for conversion, if any */ switch (Decode) { default: case AUDIO_ENCODING_NONE: insiz = bufsiz; outbuf = (char *)buf; break; case AUDIO_ENCODING_G721: insiz = ADPCM_SIZE / 2; outbuf = (char *)adpcm_buf; initmux(1, 2); break; case AUDIO_ENCODING_G723: insiz = (ADPCM_SIZE * 3) / 8; outbuf = (char *)adpcm_buf; initmux(3, 8); break; } /* * 8-bit audio isn't a problem, however 16-bit audio is. * If the file is an endian that is different from the machine * then the bytes will need to be swapped. * * Note: Because the G.72X conversions produce 8bit output, * they don't require a byte swap before display and so * this scheme works just fine. If a conversion is added * that produces a 16 bit result and therefore requires * byte swapping before output, then a mechanism * for chaining the two conversions will have to be built. * * Note: The following if() could be simplified, but then * it gets to be very hard to read. So it's left as is. */ if (File_hdr.bytes_per_unit == 2 && ((!NetEndian && file_type == FILE_AIFF) || (!NetEndian && file_type == FILE_AU) || (NetEndian && file_type == FILE_WAV))) { swapBytes = TRUE; } else { swapBytes = FALSE; } if (swapBytes) { /* Read in interal number of sample frames. */ frame = File_hdr.bytes_per_unit * File_hdr.channels; insiz = (SWAP_SIZE / frame) * frame; /* make the output buffer the swap buffer. */ outbuf = (char *)swap_buf; } /* * At this point, we're all ready to copy the data. */ if (mapaddr == 0) { /* Not mmapped, do it a buffer at a time. */ inbuf = buf; frame = File_hdr.bytes_per_unit * File_hdr.channels; rem = 0; while ((cnt = read(ifd, inbuf+rem, insiz-rem)) >= 0) { /* * We need to ensure only an integral number of * samples is ever written to the audio device. */ cnt = cnt + rem; rem = cnt % frame; cnt = cnt - rem; /* * If decoding adpcm, or swapping bytes do it * now. * * We treat the swapping like a separate * encoding here because the G.72X encodings * decode to single byte output samples. If * another encoding is added and it produces * multi-byte output samples this will have to * be changed. */ if (Decode == AUDIO_ENCODING_G721) { outsiz = 0; demux(1, cnt / File_hdr.channels); for (c = 0; c < File_hdr.channels; c++) { err = g721_decode(in_ch_data[c], cnt / File_hdr.channels, &File_hdr, (void*)out_ch_data[c], &tsize, &adpcm_state[c]); outsiz = outsiz + tsize; if (err != AUDIO_SUCCESS) { Error(stderr, MGET( "%s: error decoding g721\n"), prog); errorStatus++; break; } } mux(outbuf); cnt = outsiz; } else if (Decode == AUDIO_ENCODING_G723) { outsiz = 0; demux(3, cnt / File_hdr.channels); for (c = 0; c < File_hdr.channels; c++) { err = g723_decode(in_ch_data[c], cnt / File_hdr.channels, &File_hdr, (void*)out_ch_data[c], &tsize, &adpcm_state[c]); outsiz = outsiz + tsize; if (err != AUDIO_SUCCESS) { Error(stderr, MGET( "%s: error decoding g723\n"), prog); errorStatus++; break; } } mux(outbuf); cnt = outsiz; } else if (swapBytes) { swab((char *)inbuf, outbuf, cnt); } /* If input EOF, write an eof marker */ err = write(Audio_fd, outbuf, cnt); if (err < 0) { perror("write"); errorStatus++; break; } else if (err != cnt) { Error(stderr, MGET("%s: output error: "), prog); perror(""); errorStatus++; break; } if (cnt == 0) { break; } /* Move remainder to the front of the buffer */ if (rem != 0) { (void *)memcpy(inbuf, inbuf + cnt, rem); } } if (cnt < 0) { Error(stderr, MGET("%s: error reading "), prog); perror(Ifile); errorStatus++; } } else { /* We're mmaped */ if ((Decode != AUDIO_ENCODING_NONE) || swapBytes) { /* Transform data if we have to. */ for (i = 0; i <= len; i += cnt) { cnt = insiz; if ((i + cnt) > len) { cnt = len - i; } if (Decode == AUDIO_ENCODING_G721) { outsiz = 0; demux(1, cnt / File_hdr.channels); for (c = 0; c < File_hdr.channels; c++) { err = g721_decode( in_ch_data[c], cnt / File_hdr.channels, &File_hdr, (void*)out_ch_data[c], &tsize, &adpcm_state[c]); outsiz = outsiz + tsize; if (err != AUDIO_SUCCESS) { Error(stderr, MGET( "%s: error decoding " "g721\n"), prog); errorStatus++; break; } } mux(outbuf); } else if (Decode == AUDIO_ENCODING_G723) { outsiz = 0; demux(3, cnt / File_hdr.channels); for (c = 0; c < File_hdr.channels; c++) { err = g723_decode( in_ch_data[c], cnt / File_hdr.channels, &File_hdr, (void*)out_ch_data[c], &tsize, &adpcm_state[c]); outsiz = outsiz + tsize; if (err != AUDIO_SUCCESS) { Error(stderr, MGET( "%s: error " "decoding g723\n"), prog); errorStatus++; break; } } mux(outbuf); } else if (swapBytes) { swab((char *)inbuf, outbuf, cnt); outsiz = cnt; } inbuf += cnt; /* If input EOF, write an eof marker */ err = write(Audio_fd, (char *)outbuf, outsiz); if (err < 0) { perror("write"); errorStatus++; } else if (outsiz == 0) { break; } } } else { /* write the whole thing at once! */ err = write(Audio_fd, inbuf, len); if (err < 0) { perror("write"); errorStatus++; } if (err != len) { Error(stderr, MGET("%s: output error: "), prog); perror(""); errorStatus++; } err = write(Audio_fd, inbuf, 0); if (err < 0) { perror("write"); errorStatus++; } } } /* Free memory if decoding ADPCM */ switch (Decode) { case AUDIO_ENCODING_G721: case AUDIO_ENCODING_G723: freemux(); break; default: break; } closeinput:; if (mapaddr != 0) (void) munmap(mapaddr, st.st_size); (void) close(ifd); /* close input file */ if (Errdetect) { cnt = 0; (void) audio_set_play_error(Audio_fd, (unsigned int *)&cnt); if (cnt) { Error(stderr, MGET("%s: output underflow in %s\n"), Ifile, prog); errorStatus++; } } nextfile:; } while ((argc > 0) && (argc--, (Ifile = *argv++) != NULL)); /* * Though drain is implicit on close(), it's performed here * to ensure that the volume is reset after all output is complete. */ (void) audio_drain(Audio_fd, FALSE); /* Flush any remaining audio */ (void) ioctl(Audio_fd, I_FLUSH, FLUSHW); if (Volume != INT_MAX) (void) audio_set_play_gain(Audio_fd, &Savevol); if ((Audio_ctlfd >= 0) && (audio_cmp_hdr(&Save_hdr, &Dev_hdr) != 0)) { (void) audio_set_play_config(Audio_fd, &Save_hdr); } (void) close(Audio_fd); /* close output */ return (errorStatus); } /* * Try to reconfigure the audio device to match the file encoding. * If this fails, we should attempt to make the input data match the * device encoding. For now, we give up on this file. * * Returns TRUE if successful. Returns FALSE if not. */ static int reconfig(void) { int err; char msg[AUDIO_MAX_ENCODE_INFO]; Dev_hdr = File_hdr; err = audio_set_play_config(Audio_fd, &Dev_hdr); switch (err) { case AUDIO_SUCCESS: return (TRUE); case AUDIO_ERR_NOEFFECT: /* * Couldn't change the device. * Check to see if we're nearly compatible. * audio_cmp_hdr() returns >0 if only sample rate difference. */ if (audio_cmp_hdr(&Dev_hdr, &File_hdr) > 0) { double ratio; ratio = (double)abs((int) (Dev_hdr.sample_rate - File_hdr.sample_rate)) / (double)File_hdr.sample_rate; if (ratio <= SAMPLE_RATE_THRESHOLD) { if (Verbose) { Error(stderr, MGET("%s: WARNING: %s sampled at " "%d, playing at %d\n"), prog, Ifile, File_hdr.sample_rate, Dev_hdr.sample_rate); } return (TRUE); } Error(stderr, MGET("%s: %s sample rate %d not available\n"), prog, Ifile, File_hdr.sample_rate); return (FALSE); } (void) audio_enc_to_str(&File_hdr, msg); Error(stderr, MGET("%s: %s encoding not available: %s\n"), prog, Ifile, msg); return (FALSE); default: Error(stderr, MGET("%s: %s audio encoding type not available\n"), prog, Ifile); exit(1); } return (TRUE); } /* Parse an unsigned integer */ static int parse_unsigned(char *str, unsigned *dst, char *flag) { char x; if (sscanf(str, "%u%c", dst, &x) != 1) { Error(stderr, MGET("%s: invalid value for %s\n"), prog, flag); return (1); } return (0); } /* * Search for fname in path and open. Ignore path not opened O_RDONLY. * Note: in general path can be a list of ':' separated paths to search * through. */ static int path_open(char *fname, int flags, mode_t mode, char *path) { char fullpath[MAXPATHLEN]; /* full path of file */ char *buf; /* malloc off the tmp buff */ char *cp; struct stat st; if (!fname) { /* bogus */ return (-1); } /* * cases where we don't bother checking path: * - no path * - file not opened O_RDONLY * - not a relative path (i.e. starts with /, ./, or ../). */ if ((!path) || (flags != O_RDONLY) || (*fname == '/') || (strncmp(fname, "./", strlen("./")) == 0) || (strncmp(fname, "../", strlen("../")) == 0)) { return (open(fname, flags, mode)); } /* * Malloc off a buffer to hold the path variable. * This is NOT limited to MAXPATHLEN characters as * it may contain multiple paths. */ buf = malloc(strlen(path) + 1); /* * if first character is ':', but not the one following it, * skip over it - or it'll be interpreted as "./". it's OK * to have "::" since that does mean "./". */ if ((path[0] == ':') && (path[1] != ':')) { (void) strncpy(buf, path+1, strlen(path)); } else { (void) strncpy(buf, path, strlen(path)); } for (path = buf; path && *path; ) { if (cp = strchr(path, ':')) { *cp++ = '\0'; /* now pts to next path element */ } /* the safest way to create the path string :-) */ if (*path) { (void) strncpy(fullpath, path, MAXPATHLEN); (void) strncat(fullpath, "/", MAXPATHLEN); } else { /* a NULL path element means "./" */ (void) strncpy(fullpath, "./", MAXPATHLEN); } (void) strncat(fullpath, fname, MAXPATHLEN); /* see if there's a match */ if (stat(fullpath, &st) >= 0) { if (S_ISREG(st.st_mode)) { /* got a match! */ if (Verbose) { Error(stderr, MGET("%s: Found %s in path " "at %s\n"), prog, fname, fullpath); } return (open(fullpath, flags, mode)); } } /* go on to the next one */ path = cp; } /* * if we fall through with no match, just do a normal file open */ return (open(fname, flags, mode)); } /* * initmux() * * Description: * Allocates memory for carrying out demultiplexing/multiplexing. * * Arguments: * int unitsz Bytes per unit * int unitsp Samples per unit * * Returns: * void */ static void initmux(int unitsz, int unitsp) { int c; /* Channel */ int in_ch_size; /* Input channel size */ /* Size of each input channel */ in_ch_size = insiz / File_hdr.channels; /* Size of each output channel */ out_ch_size = in_ch_size * unitsp / unitsz; /* Allocate pointers to input channels */ in_ch_data = malloc(sizeof (unsigned char *) * File_hdr.channels); if (in_ch_data == NULL) { Error(stderr, MGET("%s: couldn't allocate %dK buf\n"), prog, sizeof (unsigned char *) * File_hdr.channels / 1000); exit(1); } /* Allocate input channels */ for (c = 0; c < File_hdr.channels; c++) { in_ch_data[c] = malloc(sizeof (unsigned char) * in_ch_size); if (in_ch_data[c] == NULL) { Error(stderr, MGET("%s: couldn't allocate %dK buf\n"), prog, in_ch_size / 1000); exit(1); } } /* Allocate pointers to output channels */ out_ch_data = malloc(sizeof (unsigned char *) * File_hdr.channels); if (out_ch_data == NULL) { Error(stderr, MGET("%s: couldn't allocate %dK buf\n"), prog, sizeof (unsigned char *) * File_hdr.channels / 1000); exit(1); } /* Allocate output channels */ for (c = 0; c < File_hdr.channels; c++) { out_ch_data[c] = malloc(sizeof (unsigned char) * out_ch_size); if (out_ch_data[c] == NULL) { Error(stderr, MGET("%s: couldn't allocate %dK buf\n"), prog, out_ch_size / 1000); exit(1); } } } /* * demux() * * Description: * Split a multichannel signal into separate channels. * * Arguments: * int unitsz Bytes per unit * int cnt Bytes to process * * Returns: * void */ static void demux(int unitsz, int cnt) { int c; /* Channel */ int s; /* Sample */ int b; /* Byte */ int tp; /* Pointer into current data */ int dp; /* Pointer into target data */ /* Split */ for (c = 0; c < File_hdr.channels; c++) { for (s = 0; s < cnt / unitsz; s++) { tp = s * unitsz; dp = (s * File_hdr.channels + c) * unitsz; for (b = 0; b < unitsz; b++) { in_ch_data[c][tp + b] = inbuf[dp + b]; } } } } /* * mux() * * Description: * Combine separate channels to produce a multichannel signal. * * Arguments: * char *outbuf Combined signal * * Returns: * void */ static void mux(char *outbuf) { int c; /* Channel */ int s; /* Sample */ /* Combine */ for (c = 0; c < File_hdr.channels; c++) { for (s = 0; s < out_ch_size; s++) { outbuf[File_hdr.channels * s + c] = out_ch_data[c][s]; } } } /* * freemux() * * Description: * Free memory used in multiplexing/demultiplexing. * * Arguments: * void * * Returns: * void */ static void freemux(void) { int c; /* Channel */ /* Free */ for (c = 0; c < File_hdr.channels; c++) { free(in_ch_data[c]); free(out_ch_data[c]); free(&adpcm_state[c]); } free(in_ch_data); free(out_ch_data); }