 @@ -1,244 +1,234 @@
-/*	$NetBSD: audio.c,v 1.19 2008/05/29 14:51:27 mrg Exp $	*/
+/*	$NetBSD: audio.c,v 1.20 2011/08/28 01:17:47 joerg Exp $	*/
 /*
  * Copyright (c) 1999 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.
  */
 /*
  * XXX this is slightly icky in places...
  */
 #include <sys/cdefs.h>
 #ifndef lint
-__RCSID("$NetBSD: audio.c,v 1.19 2008/05/29 14:51:27 mrg Exp $");
+__RCSID("$NetBSD: audio.c,v 1.20 2011/08/28 01:17:47 joerg Exp $");
 #endif
 #include <sys/types.h>
 #include <sys/audioio.h>
 #include <sys/ioctl.h>
 #include <sys/time.h>
 #include <ctype.h>
 #include <err.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include "libaudio.h"
 /* what format am i? */
-struct {
+static const struct {
 	const char *fname;
 	int fno;
 } formats[] = {
 	{ "sunau",		AUDIO_FORMAT_SUN },
 	{ "au",			AUDIO_FORMAT_SUN },
 	{ "sun",		AUDIO_FORMAT_SUN },
 	{ "wav",		AUDIO_FORMAT_WAV },
 	{ "wave",		AUDIO_FORMAT_WAV },
 	{ "riff",		AUDIO_FORMAT_WAV },
 	{ "no",			AUDIO_FORMAT_NONE },
 	{ "none",		AUDIO_FORMAT_NONE },
 	{ NULL, -1 }
 };
 int
-audio_format_from_str(str)
+audio_format_from_str(char *str)
 	char *str;
+{
 	int	i;
 	for (i = 0; formats[i].fname; i++)
 		if (strcasecmp(formats[i].fname, str) == 0)
 			break;
 	return (formats[i].fno);
+}
 /* back and forth between encodings */
-struct {
+static const struct {
 	const char *ename;
 	int eno;
 } encs[] = {
 	{ AudioEmulaw,		AUDIO_ENCODING_ULAW },
 	{ "ulaw",		AUDIO_ENCODING_ULAW },
 	{ AudioEalaw, 		AUDIO_ENCODING_ALAW },
 	{ AudioEslinear,	AUDIO_ENCODING_SLINEAR },
 	{ "linear",		AUDIO_ENCODING_SLINEAR },
 	{ AudioEulinear,	AUDIO_ENCODING_ULINEAR },
 	{ AudioEadpcm,		AUDIO_ENCODING_ADPCM },
 	{ "ADPCM",		AUDIO_ENCODING_ADPCM },
 	{ AudioEslinear_le,	AUDIO_ENCODING_SLINEAR_LE },
 	{ "linear_le",		AUDIO_ENCODING_SLINEAR_LE },
 	{ AudioEulinear_le,	AUDIO_ENCODING_ULINEAR_LE },
 	{ AudioEslinear_be,	AUDIO_ENCODING_SLINEAR_BE },
 	{ "linear_be",		AUDIO_ENCODING_SLINEAR_BE },
 	{ AudioEulinear_be,	AUDIO_ENCODING_ULINEAR_BE },
 	{ AudioEmpeg_l1_stream,	AUDIO_ENCODING_MPEG_L1_STREAM },
 	{ AudioEmpeg_l1_packets,AUDIO_ENCODING_MPEG_L1_PACKETS },
 	{ AudioEmpeg_l1_system,	AUDIO_ENCODING_MPEG_L1_SYSTEM },
 	{ AudioEmpeg_l2_stream,	AUDIO_ENCODING_MPEG_L2_STREAM },
 	{ AudioEmpeg_l2_packets,AUDIO_ENCODING_MPEG_L2_PACKETS },
 	{ AudioEmpeg_l2_system,	AUDIO_ENCODING_MPEG_L2_SYSTEM },
 	{ NULL, -1 }
 };
 const char *
-audio_enc_from_val(val)
+audio_enc_from_val(int val)
 	int	val;
+{
 	int	i;
 	for (i = 0; encs[i].ename; i++)
 		if (encs[i].eno == val)
 			break;
 	return (encs[i].ename);
+}
 int
-audio_enc_to_val(enc)
+audio_enc_to_val(const char *enc)
 	const	char *enc;
+{
 	int	i;
 	for (i = 0; encs[i].ename; i++)
 		if (strcmp(encs[i].ename, enc) == 0)
 			break;
 	if (encs[i].ename)
 		return (encs[i].eno);
 	else
 		return (AUDIO_ENOENT);
+}
 void
-decode_int(arg, intp)
+decode_int(const char *arg, int *intp)
 	const char *arg;
 	int *intp;
+{
 	char	*ep;
 	int	ret;
 	ret = (int)strtoul(arg, &ep, 10);
 	if (ep[0] == '\0') {
 		*intp = ret;
 		return;
+	}
 	errx(1, "argument `%s' not a valid integer", arg);
+}
 void
-decode_time(arg, tvp)
+decode_time(const char *arg, struct timeval *tvp)
 	const char *arg;
 	struct timeval *tvp;
+{
 	char	*s, *colon, *dot;
 	char	*copy = strdup(arg);
 	int	first;
 	if (copy == NULL)
 		err(1, "could not allocate a copy of %s", arg);
 	tvp->tv_sec = tvp->tv_usec = 0;
 	s = copy;
 	/* handle [hh:]mm:ss.dd */
 	if ((colon = strchr(s, ':')) != NULL) {
 		*colon++ = '\0';
 		decode_int(s, &first);
 		tvp->tv_sec = first * 60;	/* minutes */
 		s = colon;
 		if ((colon = strchr(s, ':')) != NULL) {
 			*colon++ = '\0';
 			decode_int(s, &first);
 			tvp->tv_sec += first;	/* minutes and hours */
 			tvp->tv_sec *= 60;
 			s = colon;
+		}
+	}
 	if ((dot = strchr(s, '.')) != NULL) {
 		int 	i, base = 100000;
 		*dot++ = '\0';
 		for (i = 0; i < 6; i++, base /= 10) {
 			if (!dot[i])
 				break;
 			if (!isdigit((unsigned char)dot[i]))
 				errx(1, "argument `%s' is not a value time specification", arg);
 			tvp->tv_usec += base * (dot[i] - '0');
+		}
+	}
 	decode_int(s, &first);
 	tvp->tv_sec += first;
 	free(copy);
+}
 /*
  * decode a string into an encoding value.
  */
 void
-decode_encoding(arg, encp)
+decode_encoding(const char *arg, int *encp)
 	const char *arg;
 	int *encp;
+{
 	size_t	len;
 	int i;
 	len = strlen(arg);
 	for (i = 0; encs[i].ename; i++)
 		if (strncmp(encs[i].ename, arg, len) == 0) {
 			*encp = encs[i].eno;
 			return;
+		}
 	errx(1, "unknown encoding `%s'", arg);
+}
-const char *const audio_errlist[] = {
+static const char *const audio_errlist[] = {
 	"error zero",				/* nothing? */
 	"no audio entry",			/* AUDIO_ENOENT */
 	"short header",				/* AUDIO_ESHORTHDR */
 	"unsupported WAV format",		/* AUDIO_EWAVUNSUPP */
 	"bad (unsupported) WAV PCM format",	/* AUDIO_EWAVBADPCM */
 	"no WAV audio data",			/* AUDIO_EWAVNODATA */
 	"internal error",			/* AUDIO_EINTERNAL */
 };
 const char *
-audio_errstring(errval)
+audio_errstring(int errval)
 	int	errval;
+{
 	errval = -errval;
 	if (errval < 1 || errval > AUDIO_MAXERRNO)
 		return "Invalid error";
 	return audio_errlist[errval];
+}

 @@ -1,215 +1,217 @@
-/*	$NetBSD: libaudio.h,v 1.16 2009/06/18 02:37:27 mrg Exp $	*/
+/*	$NetBSD: libaudio.h,v 1.17 2011/08/28 01:17:47 joerg Exp $	*/
 /*
  * Copyright (c) 1999, 2009 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.
  */
 /*
  * audio formats
  */
 #define AUDIO_FORMAT_DEFAULT	-1
 #define AUDIO_FORMAT_NONE	1
 #define AUDIO_FORMAT_SUN	2
 #define AUDIO_FORMAT_WAV	3
 int	audio_format_from_str (char *);
 /*
  * We copy the Sun/NeXT on-disk audio header format and document what
  * we know of it here.
+ *
  * The header size appears to be an offset to where the data really
  * begins, rather than defining the real length of the audio header.
  * The Sun/NeXT audio format seems to only use 24 bytes of data (with
  * an additional 8 bytes of nuls written, padding it to 32 bytes).
+ *
  * If the size of the audio data is unknown (eg, reading from a pipe)
  * the Sun demo audio tools place AUDIO_UNKNOWN_SIZE in the
  * `data_size' member.
+ *
  * For stereo data, the channels appear to be interleaved with the
  * left channel first.  For more channels, who knows?
  */
 /*
  * This is the Sun/NeXT audio file magic value.  Note that it
  * is also `.snd' in ASCII.
  */
 #define	AUDIO_FILE_MAGIC		((u_int32_t)0x2e736e64)
 #define AUDIO_UNKNOWN_SIZE		((unsigned)(~0))
 typedef struct {
 	u_int32_t	magic;
 	u_int32_t	hdr_size;	/* header size; in bytes */
 	u_int32_t	data_size;	/* optional; in bytes */
 	u_int32_t	encoding;	/* see below */
 	u_int32_t	sample_rate;	/* per second */
 	u_int32_t	channels;	/* number of interleaved channels */
 } sun_audioheader;
 #define Audio_filehdr sun_audioheader	/* SunOS compat(?) */
 /*
  * these are the types of "encoding" for above.  taken from the
  * SunOS <multimedia/audio_filehdr.h>.
  */
 #define	AUDIO_FILE_ENCODING_MULAW_8		1
 #define	AUDIO_FILE_ENCODING_LINEAR_8		2
 #define	AUDIO_FILE_ENCODING_LINEAR_16		3
 #define	AUDIO_FILE_ENCODING_LINEAR_24		4
 #define	AUDIO_FILE_ENCODING_LINEAR_32		5
 #define	AUDIO_FILE_ENCODING_FLOAT		6
 #define	AUDIO_FILE_ENCODING_DOUBLE		7
 #define	AUDIO_FILE_ENCODING_ADPCM_G721		23
 #define	AUDIO_FILE_ENCODING_ADPCM_G722		24
 #define	AUDIO_FILE_ENCODING_ADPCM_G723_3	25
 #define	AUDIO_FILE_ENCODING_ADPCM_G723_5	26
 #define	AUDIO_FILE_ENCODING_ALAW_8		27
 const char *audio_enc_from_val (int);
 int	audio_enc_to_val (const char *);
 int	audio_sun_to_encoding (int, u_int *, u_int *);
 int	audio_encoding_to_sun (int, int, int *);
 /*
  * M$ WAV files, info gleamed from sox sources
  */
 /*
  * This is the WAV audio file magic value.  Note that it
  * is also `RIFF' and `WAVE' in ASCII.
  */
 #define	WAVAUDIO_FILE_MAGIC_RIFF	((u_int32_t)0x52494646)
 #define	WAVAUDIO_FILE_MAGIC_WAVE	((u_int32_t)0x57415645)
 #define	WAVAUDIO_FILE_MAGIC_FMT		((u_int32_t)0x666d7420)
 #define	WAVAUDIO_FILE_MAGIC_DATA	((u_int32_t)0x64617461)
 /* purloined from public Microsoft RIFF docs via sox or mplayer */
 #define WAVE_FORMAT_UNKNOWN		(0x0000)
 #define WAVE_FORMAT_PCM			(0x0001)
 #define WAVE_FORMAT_ADPCM		(0x0002)
 #define WAVE_FORMAT_ALAW		(0x0006)
 #define WAVE_FORMAT_MULAW		(0x0007)
 #define WAVE_FORMAT_OKI_ADPCM		(0x0010)
 #define WAVE_FORMAT_IMA_ADPCM		(0x0011)
 #define WAVE_FORMAT_DIGISTD		(0x0015)
 #define WAVE_FORMAT_DIGIFIX		(0x0016)
 #define WAVE_FORMAT_DOLBY_AC2		(0x0030)
 #define WAVE_FORMAT_GSM610		(0x0031)
 #define WAVE_FORMAT_ROCKWELL_ADPCM	(0x003b)
 #define WAVE_FORMAT_ROCKWELL_DIGITALK	(0x003c)
 #define WAVE_FORMAT_G721_ADPCM		(0x0040)
 #define WAVE_FORMAT_G728_CELP		(0x0041)
 #define WAVE_FORMAT_MPEG		(0x0050)
 #define WAVE_FORMAT_MPEGLAYER3		(0x0055)
 #define WAVE_FORMAT_G726_ADPCM		(0x0064)
 #define WAVE_FORMAT_G722_ADPCM		(0x0065)
 #define IBM_FORMAT_MULAW		(0x0101)
 #define IBM_FORMAT_ALAW			(0x0102)
 #define IBM_FORMAT_ADPCM		(0x0103)
 #define WAVE_FORMAT_EXTENSIBLE		(0xfffe)
 const char *wav_enc_from_val (int);
 typedef struct {
 	char		name[4];
 	u_int32_t	len;
 } wav_audioheaderpart;
 typedef struct {
 	u_int16_t	tag;
 	u_int16_t	channels;
 	u_int32_t	sample_rate;
 	u_int32_t	avg_bps;
 	u_int16_t	alignment;
 	u_int16_t	bits_per_sample;
 } __packed wav_audioheaderfmt;
 typedef struct {
 	u_int16_t	len;
 	u_int16_t	valid_bits;
 	u_int32_t	speaker_pos_mask;
 	u_int16_t	sub_tag;
 	u_int8_t	dummy[14];
 } __packed wav_audiohdrextensible;
 /* returns size of header, or -ve for failure */
 ssize_t audio_wav_parse_hdr (void *, size_t, u_int *, u_int *, u_int *, u_int *, size_t *);
 extern int verbose;
 /*
  * audio routine error codes
  */
 #define AUDIO_ENOENT		-1		/* no such audio format */
 #define AUDIO_ESHORTHDR		-2		/* short header */
 #define AUDIO_EWAVUNSUPP	-3		/* WAV: unsupported file */
 #define AUDIO_EWAVBADPCM	-4		/* WAV: bad PCM bps */
 #define AUDIO_EWAVNODATA	-5		/* WAV: missing data */
 #define AUDIO_EINTERNAL		-6		/* internal error */
 #define AUDIO_MAXERRNO		5
 /* and something to get a string associated with this error */
 const char *audio_errstring (int);
 /*
  * generic routines?
  */
 void	decode_int (const char *, int *);
 void	decode_time (const char *, struct timeval *);
 void	decode_encoding (const char *, int *);
 /*
  * get/put 16/32 bits of big/little endian data
  */
 #include <sys/types.h>
 #include <machine/endian.h>
 #include <machine/bswap.h>
 #if BYTE_ORDER == BIG_ENDIAN
 #define getle16(v)	bswap16(v)
 #define getle32(v)	bswap32(v)
 #define getbe16(v)	(v)
 #define getbe32(v)	(v)
 #define putle16(x,v)	(x) = bswap16(v)
 #define putle32(x,v)	(x) = bswap32(v)
 #define putbe16(x,v)	(x) = (v)
 #define putbe32(x,v)	(x) = (v)
 #else
 #define getle16(v)	(v)
 #define getle32(v)	(v)
 #define getbe16(v)	bswap16(v)
 #define getbe32(v)	bswap32(v)
 #define putle16(x,v)	(x) = (v)
 #define putle32(x,v)	(x) = (v)
 #define putbe16(x,v)	(x) = bswap16(v)
 #define putbe32(x,v)	(x) = bswap32(v)
 #endif

 @@ -1,219 +1,211 @@
-/*	$NetBSD: wav.c,v 1.9 2009/06/18 02:37:27 mrg Exp $	*/
+/*	$NetBSD: wav.c,v 1.10 2011/08/28 01:17:47 joerg Exp $	*/
 /*
  * Copyright (c) 2002, 2009 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.
  */
 /*
  * WAV support for the audio tools; thanks go to the sox utility for
  * clearing up issues with WAV files.
  */
 #include <sys/cdefs.h>
 #ifndef lint
-__RCSID("$NetBSD: wav.c,v 1.9 2009/06/18 02:37:27 mrg Exp $");
+__RCSID("$NetBSD: wav.c,v 1.10 2011/08/28 01:17:47 joerg Exp $");
 #endif
 #include <sys/types.h>
 #include <sys/audioio.h>
 #include <sys/ioctl.h>
 #include <sys/time.h>
 #include <ctype.h>
 #include <err.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <stdint.h>
 #include "libaudio.h"
-struct {
+static const struct {
 	int	wenc;
 	const char *wname;
 } wavencs[] = {
 	{ WAVE_FORMAT_UNKNOWN, 	"Microsoft Official Unknown" },
 	{ WAVE_FORMAT_PCM,	"Microsoft PCM" },
 	{ WAVE_FORMAT_ADPCM,	"Microsoft ADPCM" },
 	{ WAVE_FORMAT_ALAW,	"Microsoft A-law" },
 	{ WAVE_FORMAT_MULAW,	"Microsoft mu-law" },
 	{ WAVE_FORMAT_OKI_ADPCM,"OKI ADPCM" },
 	{ WAVE_FORMAT_DIGISTD,	"Digistd format" },
 	{ WAVE_FORMAT_DIGIFIX,	"Digifix format" },
 	{ -1, 			"?Unknown?" },
 };
 const char *
 wav_enc_from_val(int encoding)
+{
 	int	i;
 	for (i = 0; wavencs[i].wenc != -1; i++)
 		if (wavencs[i].wenc == encoding)
 			break;
 	return (wavencs[i].wname);
+}
 extern int verbose;
 /*
  * sample header is:
+ *
  *   RIFF\^@^C^@WAVEfmt ^P^@^@^@^A^@^B^@D<AC>^@^@^P<B1>^B^@^D^@^P^@data^@^@^C^@^@^@^@^@^@^@^@^@^@
+ *
  */
 /*
  * WAV format helpers
  */
 /*
  * find a .wav header, etc. returns header length on success
  */
 ssize_t
-audio_wav_parse_hdr(hdr, sz, enc, prec, sample, channels, datasize)
+audio_wav_parse_hdr(void *hdr, size_t sz, u_int *enc, u_int *prec,
-	void	*hdr;
+    u_int *sample, u_int *channels, size_t *datasize)
 	size_t	sz;
 	u_int	*enc;
 	u_int	*prec;
 	u_int	*sample;
 	u_int	*channels;
 	size_t *datasize;
+{
 	char	*where = hdr, *owhere;
 	wav_audioheaderpart part;
 	wav_audioheaderfmt fmt;
 	wav_audiohdrextensible ext;
 	char	*end = (((char *)hdr) + sz);
 	u_int	newenc, newprec;
 	u_int16_t fmttag;
 	static const char
 	    strfmt[4] = "fmt ",
 	    strRIFF[4] = "RIFF",
 	    strWAVE[4] = "WAVE",
 	    strdata[4] = "data";
 	if (sz < 32)
 		return (AUDIO_ENOENT);
 	if (strncmp(where, strRIFF, sizeof strRIFF))
 		return (AUDIO_ENOENT);
 	where += 8;
 	if (strncmp(where, strWAVE, sizeof strWAVE))
 		return (AUDIO_ENOENT);
 	where += 4;
 	do {
 		memcpy(&part, where, sizeof part);
 		owhere = where;
 		where += getle32(part.len) + 8;
 	} while (where < end && strncmp(part.name, strfmt, sizeof strfmt));
 	/* too short ? */
 	if (where + sizeof fmt > end)
 		return (AUDIO_ESHORTHDR);
 	memcpy(&fmt, (owhere + 8), sizeof fmt);
 	fmttag = getle16(fmt.tag);
 	if (verbose)
 		printf("WAVE format tag: %x\n", fmttag);
 	if (fmttag == WAVE_FORMAT_EXTENSIBLE) {
 		if ((uintptr_t)(where - owhere) < sizeof(fmt) + sizeof(ext))
 			return (AUDIO_ESHORTHDR);
 		memcpy(&ext, owhere + sizeof fmt, sizeof ext);
 		if (getle16(ext.len) < sizeof(ext) - sizeof(ext.len))
 			return (AUDIO_ESHORTHDR);
 		fmttag = ext.sub_tag;
 		if (verbose)
 			printf("WAVE extensible sub tag: %x\n", fmttag);
+	}
 	switch (fmttag) {
 	case WAVE_FORMAT_UNKNOWN:
 	case IBM_FORMAT_MULAW:
 	case IBM_FORMAT_ALAW:
 	case IBM_FORMAT_ADPCM:
 	default:
 		return (AUDIO_EWAVUNSUPP);
 	case WAVE_FORMAT_PCM:
 	case WAVE_FORMAT_ADPCM:
 	case WAVE_FORMAT_OKI_ADPCM:
 	case WAVE_FORMAT_IMA_ADPCM:
 	case WAVE_FORMAT_DIGIFIX:
 	case WAVE_FORMAT_DIGISTD:
 		switch (getle16(fmt.bits_per_sample)) {
 		case 8:
 			newprec = 8;
 			break;
 		case 16:
 			newprec = 16;
 			break;
 		case 24:
 			newprec = 24;
 			break;
 		case 32:
 			newprec = 32;
 			break;
 		default:
 			return (AUDIO_EWAVBADPCM);
+		}
 		if (newprec == 8)
 			newenc = AUDIO_ENCODING_ULINEAR_LE;
 		else
 			newenc = AUDIO_ENCODING_SLINEAR_LE;
 		break;
 	case WAVE_FORMAT_ALAW:
 		newenc = AUDIO_ENCODING_ALAW;
 		newprec = 8;
 		break;
 	case WAVE_FORMAT_MULAW:
 		newenc = AUDIO_ENCODING_ULAW;
 		newprec = 8;
 		break;
+	}
 	do {
 		memcpy(&part, where, sizeof part);
 		owhere = where;
 		where += (getle32(part.len) + 8);
 	} while (where < end && strncmp(part.name, strdata, sizeof strdata));
 	if ((where - getle32(part.len)) <= end) {
 		if (channels)
 			*channels = (u_int)getle16(fmt.channels);
 		if (sample)
 			*sample = getle32(fmt.sample_rate);
 		if (enc)
 			*enc = newenc;
 		if (prec)
 			*prec = newprec;
 		if (datasize)
 			*datasize = (size_t)getle32(part.len);
 		return (owhere - (char *)hdr + 8);
+	}
 	return (AUDIO_EWAVNODATA);
+}

 @@ -1,465 +1,453 @@
-/*	$NetBSD: ctl.c,v 1.38 2009/04/11 10:43:09 lukem Exp $	*/
+/*	$NetBSD: ctl.c,v 1.39 2011/08/28 01:17:48 joerg Exp $	*/
 /*
  * Copyright (c) 1997 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Lennart Augustsson (augustss@NetBSD.org).
+ *
  * 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 NETBSD FOUNDATION, INC. AND CONTRIBUTORS
  * ``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 FOUNDATION OR CONTRIBUTORS
  * 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 <sys/cdefs.h>
 #ifndef lint
-__RCSID("$NetBSD: ctl.c,v 1.38 2009/04/11 10:43:09 lukem Exp $");
+__RCSID("$NetBSD: ctl.c,v 1.39 2011/08/28 01:17:48 joerg Exp $");
 #endif
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <sys/ioctl.h>
 #include <sys/audioio.h>
 #include <err.h>
 #include <fcntl.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
 #include <paths.h>
 #include "libaudio.h"
-struct field *findfield (const char *name);
+static struct field *findfield(const char *name);
-void prfield (struct field *p, const char *sep);
+static void prfield(const struct field *p, const char *sep);
-void rdfield (struct field *p, char *q);
+static void rdfield(struct field *p, char *q);
-void getinfo (int fd);
+static void getinfo(int fd);
-void audioctl_write (int, int, char *[]);
+static void audioctl_write(int, int, char *[]);
-void usage (void);
+__dead static void usage(void);
 int main (int argc, char **argv);
-audio_device_t adev;
+static audio_device_t adev;
-audio_info_t info;
+static audio_info_t info;
-char encbuf[1000];
+static char encbuf[1000];
-int properties, fullduplex, rerror;
+static int properties, fullduplex, rerror;
-struct field {
+static struct field {
 	const char *name;
 	void *valp;
 	int format;
 #define STRING 1
 #define INT 2
 #define UINT 3
 #define P_R 4
 #define ULONG 5	/* XXX obsolete now */
 #define UCHAR 6
 #define ENC 7
 #define PROPS 8
 #define XINT 9
 #define	FORMAT 10
 	char flags;
 #define READONLY 1
 #define ALIAS 2
 #define SET 4
 } fields[] = {
 	{ "name", 		&adev.name, 		STRING, READONLY },
 	{ "version",		&adev.version,		STRING, READONLY },
 	{ "config",		&adev.config,		STRING, READONLY },
 	{ "encodings",		encbuf,			STRING, READONLY },
 	{ "properties",		&properties,		PROPS,	READONLY },
 	{ "full_duplex",	&fullduplex,		UINT,   0 },
 	{ "fullduplex",		&fullduplex,		UINT,   0 },
 	{ "blocksize",		&info.blocksize,	UINT,	0 },
 	{ "hiwat",		&info.hiwat,		UINT,	0 },
 	{ "lowat",		&info.lowat,		UINT,	0 },
 	{ "monitor_gain",	&info.monitor_gain,	UINT,	0 },
 	{ "mode",		&info.mode,		P_R,	READONLY },
 	{ "play",		&info.play,		FORMAT,	ALIAS },
 	{ "play.rate",		&info.play.sample_rate,	UINT,	0 },
 	{ "play.sample_rate",	&info.play.sample_rate,	UINT,	ALIAS },
 	{ "play.channels",	&info.play.channels,	UINT,	0 },
 	{ "play.precision",	&info.play.precision,	UINT,	0 },
 	{ "play.encoding",	&info.play.encoding,	ENC,	0 },
 	{ "play.gain",		&info.play.gain,	UINT,	0 },
 	{ "play.balance",	&info.play.balance,	UCHAR,	0 },
 	{ "play.port",		&info.play.port,	XINT,	0 },
 	{ "play.avail_ports",	&info.play.avail_ports,	XINT,	0 },
 	{ "play.seek",		&info.play.seek,	UINT,	READONLY },
 	{ "play.samples",	&info.play.samples,	UINT,	READONLY },
 	{ "play.eof",		&info.play.eof,		UINT,	READONLY },
 	{ "play.pause",		&info.play.pause,	UCHAR,	0 },
 	{ "play.error",		&info.play.error,	UCHAR,	READONLY },
 	{ "play.waiting",	&info.play.waiting,	UCHAR,	READONLY },
 	{ "play.open",		&info.play.open,	UCHAR,	READONLY },
 	{ "play.active",	&info.play.active,	UCHAR,	READONLY },
 	{ "play.buffer_size",	&info.play.buffer_size,	UINT,	0 },
 	{ "record",		&info.record,		FORMAT,	ALIAS },
 	{ "record.rate",	&info.record.sample_rate,UINT,	0 },
 	{ "record.sample_rate",	&info.record.sample_rate,UINT,	ALIAS },
 	{ "record.channels",	&info.record.channels,	UINT,	0 },
 	{ "record.precision",	&info.record.precision,	UINT,	0 },
 	{ "record.encoding",	&info.record.encoding,	ENC,	0 },
 	{ "record.gain",	&info.record.gain,	UINT,	0 },
 	{ "record.balance",	&info.record.balance,	UCHAR,	0 },
 	{ "record.port",	&info.record.port,	XINT,	0 },
 	{ "record.avail_ports",	&info.record.avail_ports,XINT,	0 },
 	{ "record.seek",	&info.record.seek,	UINT,	READONLY },
 	{ "record.samples",	&info.record.samples,	UINT,	READONLY },
 	{ "record.eof",		&info.record.eof,	UINT,	READONLY },
 	{ "record.pause",	&info.record.pause,	UCHAR,	0 },
 	{ "record.error",	&info.record.error,	UCHAR,	READONLY },
 	{ "record.waiting",	&info.record.waiting,	UCHAR,	READONLY },
 	{ "record.open",	&info.record.open,	UCHAR,	READONLY },
 	{ "record.active",	&info.record.active,	UCHAR,	READONLY },
 	{ "record.buffer_size",	&info.record.buffer_size,UINT,	0 },
 	{ "record.errors",	&rerror,		INT,	READONLY },
 	{ .name = NULL },
 };
-static struct {
+static const struct {
 	const char *name;
 	u_int prop;
 } props[] = {
 	{ "full_duplex",	AUDIO_PROP_FULLDUPLEX },
 	{ "mmap",		AUDIO_PROP_MMAP },
 	{ "independent",	AUDIO_PROP_INDEPENDENT },
 	{ .name = NULL },
 };
-struct field *
+static struct field *
-findfield(name)
+findfield(const char *name)
 	const char *name;
+{
 	int i;
 	for (i = 0; fields[i].name; i++)
 		if (strcmp(fields[i].name, name) == 0)
 			return &fields[i];
 	return 0;
+}
-void
+static void
-prfield(p, sep)
+prfield(const struct field *p, const char *sep)
 	struct field *p;
 	const char *sep;
+{
 	u_int v;
 	const char *cm, *encstr;
 	int i;
 	if (sep)
 		printf("%s%s", p->name, sep);
 	switch(p->format) {
 	case STRING:
-		printf("%s", (char*)p->valp);
+		printf("%s", (const char*)p->valp);
 		break;
 	case INT:
-		printf("%d", *(int*)p->valp);
+		printf("%d", *(const int*)p->valp);
 		break;
 	case UINT:
-		printf("%u", *(u_int*)p->valp);
+		printf("%u", *(const u_int*)p->valp);
 		break;
 	case XINT:
-		printf("0x%x", *(u_int*)p->valp);
+		printf("0x%x", *(const u_int*)p->valp);
 		break;
 	case UCHAR:
-		printf("%u", *(u_char*)p->valp);
+		printf("%u", *(const u_char*)p->valp);
 		break;
 	case ULONG:
-		printf("%lu", *(u_long*)p->valp);
+		printf("%lu", *(const u_long*)p->valp);
 		break;
 	case P_R:
-		v = *(u_int*)p->valp;
+		v = *(const u_int*)p->valp;
 		cm = "";
 		if (v & AUMODE_PLAY) {
 			if (v & AUMODE_PLAY_ALL)
 				printf("play");
 			else
 				printf("playsync");
 			cm = ",";
+		}
 		if (v & AUMODE_RECORD)
 			printf("%srecord", cm);
 		break;
 	case ENC:
 		v = *(u_int*)p->valp;
 		encstr = audio_enc_from_val(v);
 		if (encstr)
 			printf("%s", encstr);
 		else
 			printf("%u", v);
 		break;
 	case PROPS:
 		v = *(u_int*)p->valp;
 		for (cm = "", i = 0; props[i].name; i++) {
 			if (v & props[i].prop) {
 				printf("%s%s", cm, props[i].name);
 				cm = ",";
+			}
+		}
 		break;
 	case FORMAT:
 		prfield(p + 1, 0);
 		printf(",");
 		prfield(p + 3, 0);
 		printf(",");
 		prfield(p + 4, 0);
 		printf(",");
 		prfield(p + 5, 0);
 		break;
 	default:
 		errx(1, "Invalid print format.");
+	}
+}
-void
+static void
-rdfield(p, q)
+rdfield(struct field *p, char *q)
 	struct field *p;
 	char *q;
+{
 	int enc;
 	u_int u;
 	char *s;
 	switch(p->format) {
 	case UINT:
 		if (sscanf(q, "%u", (unsigned int *)p->valp) != 1)
 			errx(1, "Bad number: %s", q);
 		break;
 	case UCHAR:
 		if (sscanf(q, "%u", &u) != 1)
 			errx(1, "Bad number: %s", q);
 		else
 			*(u_char *)p->valp = u;
 		break;
 	case XINT:
 		if (sscanf(q, "0x%x", (unsigned int *)p->valp) != 1 &&
 		    sscanf(q, "%x", (unsigned int *)p->valp) != 1)
 			errx(1, "Bad number: %s", q);
 		break;
 	case ENC:
 		enc = audio_enc_to_val(q);
 		if (enc >= 0)
 			*(u_int*)p->valp = enc;
 		else
 			errx(1, "Unknown encoding: %s", q);
 		break;
 	case FORMAT:
 		s = strsep(&q, ",");
 		if (s)
 			rdfield(p + 1, s);
 		s = strsep(&q, ",");
 		if (s)
 			rdfield(p + 3, s);
 		s = strsep(&q, ",");
 		if (s)
 			rdfield(p + 4, s);
 		s = strsep(&q, ",");
 		if (s)
 			rdfield(p + 5, s);
 		if (!s || q)
 			errx(1, "Bad format");
 		break;
 	default:
 		errx(1, "Invalid read format.");
+	}
 	p->flags |= SET;
+}
-void
+static void
-getinfo(fd)
+getinfo(int fd)
 	int fd;
+{
 	int pos, i;
 	if (ioctl(fd, AUDIO_GETDEV, &adev) < 0)
 		err(1, "AUDIO_GETDEV");
 	for (pos = 0, i = 0; ; i++) {
 		audio_encoding_t enc;
 		enc.index = i;
 		if (ioctl(fd, AUDIO_GETENC, &enc) < 0)
 			break;
 		if (pos >= (int)sizeof(encbuf)-1)
 			break;
 		if (pos)
 			encbuf[pos++] = ',';
 		if (pos >= (int)sizeof(encbuf)-1)
 			break;
 		pos += snprintf(encbuf+pos, sizeof(encbuf)-pos, "%s:%d%s",
 			enc.name, enc.precision,
 			enc.flags & AUDIO_ENCODINGFLAG_EMULATED ? "*" : "");
+	}
 	if (ioctl(fd, AUDIO_GETFD, &fullduplex) < 0)
 		err(1, "AUDIO_GETFD");
 	if (ioctl(fd, AUDIO_GETPROPS, &properties) < 0)
 		err(1, "AUDIO_GETPROPS");
 	if (ioctl(fd, AUDIO_RERROR, &rerror) < 0)
 		err(1, "AUDIO_RERROR");
 	if (ioctl(fd, AUDIO_GETINFO, &info) < 0)
 		err(1, "AUDIO_GETINFO");
+}
-void
+static void
-usage()
+usage(void)
+{
 	const char *prog = getprogname();
 	fprintf(stderr, "Usage: %s [-d file] [-n] name ...\n", prog);
 	fprintf(stderr, "Usage: %s [-d file] [-n] -w name=value ...\n", prog);
 	fprintf(stderr, "Usage: %s [-d file] [-n] -a\n", prog);
 	exit(1);
+}
 int
-main(argc, argv)
+main(int argc, char *argv[])
 	int argc;
 	char **argv;
+{
 	int fd, i, ch;
 	int aflag = 0, wflag = 0;
 	const char *deffile = _PATH_AUDIOCTL;
 	const char *file;
 	const char *sep = "=";
 	file = getenv("AUDIOCTLDEVICE");
 	if (file == NULL)
 		file = deffile;
 	while ((ch = getopt(argc, argv, "ad:f:nw")) != -1) {
 		switch(ch) {
 		case 'a':
 			aflag++;
 			break;
 		case 'w':
 			wflag++;
 			break;
 		case 'n':
 			sep = 0;
 			break;
 		case 'f': /* compatibility */
 		case 'd':
 			file = optarg;
 			break;
 		case '?':
 		default:
 			usage();
+		}
+	}
 	argc -= optind;
 	argv += optind;
 	fd = open(file, O_WRONLY);
 	if (fd < 0)
 		fd = open(file, O_RDONLY);
         if (fd < 0 && file == deffile) {
         	file = _PATH_AUDIOCTL0;
                 fd = open(file, O_WRONLY);
 		if (fd < 0)
 			fd = open(file, O_RDONLY);
+        }
 	if (fd < 0)
 		err(1, "%s", file);
 	if (!wflag)
 		getinfo(fd);
 	if (argc == 0 && aflag && !wflag) {
 		for (i = 0; fields[i].name; i++) {
 			if (!(fields[i].flags & ALIAS)) {
 				prfield(&fields[i], sep);
 				printf("\n");
+			}
+		}
 	} else if (argc > 0 && !aflag) {
 		if (wflag) {
 			audioctl_write(fd, argc, argv);
 			if (sep) {
 				getinfo(fd);
 				for (i = 0; fields[i].name; i++) {
 					if (fields[i].flags & SET) {
 						printf("%s: -> ", fields[i].name);
 						prfield(&fields[i], 0);
 						printf("\n");
+					}
+				}
+			}
 		} else {
 			struct field *p;
 			while (argc--) {
 				p = findfield(*argv);
 				if (p == 0) {
 					if (strchr(*argv, '='))
 						warnx("field %s does not exist (use -w to set a variable)", *argv);
 					else
 						warnx("field %s does not exist", *argv);
 				} else {
 					prfield(p, sep);
 					printf("\n");
+				}
 				argv++;
+			}
+		}
 	} else
 		usage();
 	exit(0);
+}
-void
+static void
-audioctl_write(fd, argc, argv)
+audioctl_write(int fd, int argc, char *argv[])
 	int fd;
 	int argc;
 	char *argv[];
+{
 	struct field *p;
 	AUDIO_INITINFO(&info);
 	while (argc--) {
 		char *q;
 		q = strchr(*argv, '=');
 		if (q) {
 			*q++ = 0;
 			p = findfield(*argv);
 			if (p == 0)
 				warnx("field `%s' does not exist", *argv);
 			else {
 				if (p->flags & READONLY)
 					warnx("`%s' is read only", *argv);
 				else {
 					rdfield(p, q);
 					if (p->valp == &fullduplex)
 						if (ioctl(fd, AUDIO_SETFD, &fullduplex) < 0)
 							err(1, "set failed");
+				}
+			}
 		} else
 			warnx("No `=' in %s", *argv);
 		argv++;
+	}
 	if (ioctl(fd, AUDIO_SETINFO, &info) < 0)
 		err(1, "set failed");
+}

 @@ -1,489 +1,477 @@
-/*	$NetBSD: play.c,v 1.53 2010/12/29 18:48:40 wiz Exp $	*/
+/*	$NetBSD: play.c,v 1.54 2011/08/28 01:17:48 joerg Exp $	*/
 /*
  * Copyright (c) 1999, 2000, 2001, 2002, 2010 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 <sys/cdefs.h>
 #ifndef lint
-__RCSID("$NetBSD: play.c,v 1.53 2010/12/29 18:48:40 wiz Exp $");
+__RCSID("$NetBSD: play.c,v 1.54 2011/08/28 01:17:48 joerg Exp $");
 #endif
 #include <sys/param.h>
 #include <sys/audioio.h>
 #include <sys/ioctl.h>
 #include <sys/mman.h>
 #include <sys/stat.h>
 #include <err.h>
 #include <fcntl.h>
 #include <signal.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
 #include <util.h>
 #include <paths.h>
 #include "libaudio.h"
-int main(int, char *[]);
+static void usage(void) __dead;
-void usage(void);
+static void play(char *);
-void play(char *);
+static void play_fd(const char *, int);
-void play_fd(const char *, int);
+static ssize_t audioctl_write_fromhdr(void *, size_t, int, size_t *, const char *);
-ssize_t audioctl_write_fromhdr(void *, size_t, int, size_t *, const char *);
+static void cleanup(int) __dead;
 void cleanup(int) __dead;
 static audio_info_t	info;
-audio_info_t	info;
+static int	volume;
-int	volume;
+static int	balance;
-int	balance;
+static int	port;
-int	port;
+static int	fflag;
-int	fflag;
+static int	qflag;
 int	qflag;
 int	verbose;
-int	sample_rate;
+static int	sample_rate;
-int	encoding;
+static int	encoding;
-char	*encoding_str;
+static char	*encoding_str;
-int	precision;
+static int	precision;
-int	channels;
+static int	channels;
-char	const *play_errstring = NULL;
+static char	const *play_errstring = NULL;
-size_t	bufsize;
+static size_t	bufsize;
-int	audiofd;
+static int	audiofd;
-int	exitstatus = EXIT_SUCCESS;
+static int	exitstatus = EXIT_SUCCESS;
 int
-main(argc, argv)
+main(int argc, char *argv[])
 	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:fhip: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,
 , 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 '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;
 	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 < 32 * 1024)
 			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);
+}
-void
+static void
-cleanup(signo)
+cleanup(int signo)
 	int signo;
+{
 	(void)ioctl(audiofd, AUDIO_FLUSH, NULL);
 	(void)ioctl(audiofd, AUDIO_SETINFO, &info);
 	close(audiofd);
 	if (signo != 0) {
 		(void)raise_default_signal(signo);
+	}
 	exit(exitstatus);
+}
-void
+static void
-play(file)
+play(char *file)
 	char *file;
+{
 	struct stat sb;
 	void *addr, *oaddr;
 	off_t	filesize;
 	size_t	sizet_filesize;
 	size_t datasize = 0;
 	ssize_t	hdrlen;
 	int fd;
 	if (file[0] == '-' && file[1] == 0) {
 		play_fd("standard input", STDIN_FILENO);
 		return;
+	}
 	fd = open(file, O_RDONLY);
 	if (fd < 0) {
 		if (!qflag)
 			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_rdev & S_IFMT) == 0 ||
 	    ((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
 	 */
 	if ((hdrlen = audioctl_write_fromhdr(addr,
 	    sizet_filesize, audiofd, &datasize, file)) < 0) {
 		if (play_errstring)
 			errx(1, "%s: %s", play_errstring, file);
 		else
 			errx(1, "unknown audio file: %s", file);
+	}
 	filesize -= hdrlen;
 	addr = (char *)addr + hdrlen;
 	if ((uint64_t)filesize < datasize || datasize == 0) {
 		if ((uint64_t)filesize < datasize)
 			warnx("bogus datasize: %ld", (u_long)datasize);
 		datasize = filesize;
+	}
 	while (datasize > bufsize) {
 		if ((size_t)write(audiofd, addr, bufsize) != bufsize)
 			err(1, "write failed");
 		addr = (char *)addr + bufsize;
 		datasize -= bufsize;
+	}
 	if ((size_t)write(audiofd, addr, datasize) != datasize)
 		err(1, "final write failed");
 	if (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
  */
-void
+static void
-play_fd(file, fd)
+play_fd(const char *file, int fd)
 	const char *file;
 	int     fd;
+{
 	char    *buffer = malloc(bufsize);
 	ssize_t hdrlen;
 	int     nr, nw;
 	size_t	datasize = 0;
 	size_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);
 	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 = write(audiofd, buffer, nr);
 		if (nw != nr)
 			goto write_error;
 		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 (ioctl(audiofd, AUDIO_DRAIN) < 0 && !qflag)
 		warn("audio drain ioctl failed");
 	return;
 read_error:
 	err(1, "read of standard input failed");
 write_error:
 	err(1, "audio device write 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!
  */
-ssize_t
+static ssize_t
-audioctl_write_fromhdr(hdr, fsz, fd, datasize, file)
+audioctl_write_fromhdr(void *hdr, size_t fsz, int fd, size_t *datasize, const char *file)
 	void	*hdr;
 	size_t	fsz;
 	int	fd;
 	size_t	*datasize;
 	const char	*file;
+{
 	sun_audioheader	*sunhdr;
 	ssize_t	hdr_len = 0;
 	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 = 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 : "");
+	}
 	if (ioctl(fd, AUDIO_SETINFO, &info) < 0)
 		err(1, "failed to set audio info");
 	return (hdr_len);
+}
-void
+static void
-usage()
+usage(void)
+{
 	fprintf(stderr, "Usage: %s [-hiqV] [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);
+}

 @@ -1,796 +1,784 @@
-/*	$NetBSD: record.c,v 1.50 2010/12/29 18:49:41 wiz Exp $	*/
+/*	$NetBSD: record.c,v 1.51 2011/08/28 01:17:48 joerg Exp $	*/
 /*
  * Copyright (c) 1999, 2002, 2003, 2005, 2010 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.
  */
 /*
  * SunOS compatible audiorecord(1)
  */
 #include <sys/cdefs.h>
 #ifndef lint
-__RCSID("$NetBSD: record.c,v 1.50 2010/12/29 18:49:41 wiz Exp $");
+__RCSID("$NetBSD: record.c,v 1.51 2011/08/28 01:17:48 joerg Exp $");
 #endif
 #include <sys/param.h>
 #include <sys/audioio.h>
 #include <sys/ioctl.h>
 #include <sys/time.h>
 #include <sys/uio.h>
 #include <err.h>
 #include <fcntl.h>
 #include <paths.h>
 #include <signal.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
 #include <util.h>
 #include "libaudio.h"
 #include "auconv.h"
-audio_info_t info, oinfo;
+static audio_info_t info, oinfo;
-ssize_t	total_size = -1;
+static ssize_t	total_size = -1;
-const char *device;
+static const char *device;
-int	format = AUDIO_FORMAT_DEFAULT;
+static int	format = AUDIO_FORMAT_DEFAULT;
-char	*header_info;
+static char	*header_info;
-char	default_info[8] = { '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0' };
+static char	default_info[8] = { '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0' };
-int	audiofd, outfd;
+static int	audiofd, outfd;
-int	qflag, aflag, fflag;
+static int	qflag, aflag, fflag;
 int	verbose;
-int	monitor_gain, omonitor_gain;
+static int	monitor_gain, omonitor_gain;
-int	gain;
+static int	gain;
-int	balance;
+static int	balance;
-int	port;
+static int	port;
-int	encoding;
+static int	encoding;
-char	*encoding_str;
+static char	*encoding_str;
-int	precision;
+static int	precision;
-int	sample_rate;
+static int	sample_rate;
-int	channels;
+static int	channels;
-struct timeval record_time;
+static struct timeval record_time;
-struct timeval start_time;
+static struct timeval start_time;
-void (*conv_func) (u_char *, int);
+static void (*conv_func) (u_char *, int);
-void usage (void);
+static void usage (void) __dead;
-int main (int, char *[]);
+static int timeleft (struct timeval *, struct timeval *);
-int timeleft (struct timeval *, struct timeval *);
+static void cleanup (int) __dead;
-void cleanup (int) __dead;
+static int write_header_sun (void **, size_t *, int *);
-int write_header_sun (void **, size_t *, int *);
+static int write_header_wav (void **, size_t *, int *);
-int write_header_wav (void **, size_t *, int *);
+static void write_header (void);
-void write_header (void);
+static void rewrite_header (void);
 void rewrite_header (void);
 int
-main(argc, argv)
+main(int argc, char *argv[])
 	int argc;
 	char *argv[];
+{
 	u_char	*buffer;
 	size_t	len, bufsize = 0;
 	int	ch, no_time_limit = 1;
 	const char *defdevice = _PATH_SOUND;
 	while ((ch = getopt(argc, argv, "ab:B:C:F:c:d:e:fhi:m:P:p:qt:s:Vv:")) != -1) {
 		switch (ch) {
 		case 'a':
 			aflag++;
 			break;
 		case 'b':
 			decode_int(optarg, &balance);
 			if (balance < 0 || balance > 63)
 				errx(1, "balance must be between 0 and 63");
 			break;
 		case 'B':
 			bufsize = strsuftoll("read buffer size", optarg,
 , UINT_MAX);
 			break;
 		case 'C':
 			/* Ignore, compatibility */
 			break;
 		case 'F':
 			format = audio_format_from_str(optarg);
 			if (format < 0)
 				errx(1, "Unknown audio format; supported "
 				    "formats: \"sun\", \"wav\", and \"none\"");
 			break;
 		case 'c':
 			decode_int(optarg, &channels);
 			if (channels < 0 || channels > 16)
 				errx(1, "channels must be between 0 and 16");
 			break;
 		case 'd':
 			device = optarg;
 			break;
 		case 'e':
 			encoding_str = optarg;
 			break;
 		case 'f':
 			fflag++;
 			break;
 		case 'i':
 			header_info = optarg;
 			break;
 		case 'm':
 			decode_int(optarg, &monitor_gain);
 			if (monitor_gain < 0 || monitor_gain > 255)
 				errx(1, "monitor volume must be between 0 and 255");
 			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, "mic", len) == 0)
 				port |= AUDIO_MICROPHONE;
 			else if (strncmp(optarg, "cd", len) == 0 ||
 			           strncmp(optarg, "internal-cd", len) == 0)
 				port |= AUDIO_CD;
 			else if (strncmp(optarg, "line", len) == 0)
 				port |= AUDIO_LINE_IN;
 			else
 				errx(1,
 			    "port must be `cd', `internal-cd', `mic', or `line'");
 			break;
 		case 'q':
 			qflag++;
 			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 't':
 			no_time_limit = 0;
 			decode_time(optarg, &record_time);
 			break;
 		case 'V':
 			verbose++;
 			break;
 		case 'v':
 			decode_int(optarg, &gain);
 			if (gain < 0 || gain > 255)
 				errx(1, "volume must be between 0 and 255");
 			break;
 		/* case 'h': */
 		default:
 			usage();
 			/* NOTREACHED */
+		}
+	}
 	argc -= optind;
 	argv += optind;
 	if (argc != 1)
 		usage();
 	/*
 	 * convert the encoding string into a value.
 	 */
 	if (encoding_str) {
 		encoding = audio_enc_to_val(encoding_str);
 		if (encoding == -1)
 			errx(1, "unknown encoding, bailing...");
+	}
 	/*
 	 * open the output file
 	 */
 	if (argv[0][0] != '-' || argv[0][1] != '\0') {
 		/* intuit the file type from the name */
 		if (format == AUDIO_FORMAT_DEFAULT)
+		{
 			size_t flen = strlen(*argv);
 			const char *arg = *argv;
 			if (strcasecmp(arg + flen - 3, ".au") == 0)
 				format = AUDIO_FORMAT_SUN;
 			else if (strcasecmp(arg + flen - 4, ".wav") == 0)
 				format = AUDIO_FORMAT_WAV;
+		}
 		outfd = open(*argv, O_CREAT|(aflag ? O_APPEND : O_TRUNC)|O_WRONLY, 0666);
 		if (outfd < 0)
 			err(1, "could not open %s", *argv);
 	} else
 		outfd = STDOUT_FILENO;
 	/*
 	 * open the audio device
 	 */
 	if (device == NULL && (device = getenv("AUDIODEVICE")) == NULL &&
 	    (device = getenv("AUDIODEV")) == NULL) /* Sun compatibility */
 		device = defdevice;
 	audiofd = open(device, O_RDONLY);
 	if (audiofd < 0 && device == defdevice) {
 		device = _PATH_SOUND0;
 		audiofd = open(device, O_RDONLY);
+	}
 	if (audiofd < 0)
 		err(1, "failed to open %s", device);
 	/*
 	 * work out the buffer size to use, and allocate it.  also work out
 	 * what the old monitor gain value is, so that we can reset it later.
 	 */
 	if (ioctl(audiofd, AUDIO_GETINFO, &oinfo) < 0)
 		err(1, "failed to get audio info");
 	if (bufsize == 0) {
 		bufsize = oinfo.record.buffer_size;
 		if (bufsize < 32 * 1024)
 			bufsize = 32 * 1024;
+	}
 	omonitor_gain = oinfo.monitor_gain;
 	buffer = malloc(bufsize);
 	if (buffer == NULL)
 		err(1, "couldn't malloc buffer of %d size", (int)bufsize);
 	/*
 	 * set up audio device for recording with the speified parameters
 	 */
 	AUDIO_INITINFO(&info);
 	/*
 	 * for these, get the current values for stuffing into the header
 	 */
 #define SETINFO(x)	if (x) \
 				info.record.x = x; \
 			else \
 				info.record.x = x = oinfo.record.x;
 	SETINFO (sample_rate)
 	SETINFO (channels)
 	SETINFO (precision)
 	SETINFO (encoding)
 	SETINFO (gain)
 	SETINFO (port)
 	SETINFO (balance)
 #undef SETINFO
 	if (monitor_gain)
 		info.monitor_gain = monitor_gain;
 	else
 		monitor_gain = oinfo.monitor_gain;
 	info.mode = AUMODE_RECORD;
 	if (ioctl(audiofd, AUDIO_SETINFO, &info) < 0)
 		err(1, "failed to set audio info");
 	signal(SIGINT, cleanup);
 	write_header();
 	total_size = 0;
 	if (verbose && conv_func) {
 		const char *s = NULL;
 		if (conv_func == swap_bytes)
 			s = "swap bytes (16 bit)";
 		else if (conv_func == swap_bytes32)
 			s = "swap bytes (32 bit)";
 		else if (conv_func == change_sign16_be)
 			s = "change sign (big-endian, 16 bit)";
 		else if (conv_func == change_sign16_le)
 			s = "change sign (little-endian, 16 bit)";
 		else if (conv_func == change_sign32_be)
 			s = "change sign (big-endian, 32 bit)";
 		else if (conv_func == change_sign32_le)
 			s = "change sign (little-endian, 32 bit)";
 		else if (conv_func == change_sign16_swap_bytes_be)
 			s = "change sign & swap bytes (big-endian, 16 bit)";
 		else if (conv_func == change_sign16_swap_bytes_le)
 			s = "change sign & swap bytes (little-endian, 16 bit)";
 		else if (conv_func == change_sign32_swap_bytes_be)
 			s = "change sign (big-endian, 32 bit)";
 		else if (conv_func == change_sign32_swap_bytes_le)
 			s = "change sign & swap bytes (little-endian, 32 bit)";
 		if (s)
 			fprintf(stderr, "%s: converting, using function: %s\n",
 			    getprogname(), s);
 		else
 			fprintf(stderr, "%s: using unnamed conversion "
 					"function\n", getprogname());
+	}
 	if (verbose)
 		fprintf(stderr,
 		   "sample_rate=%d channels=%d precision=%d encoding=%s\n",
 		   info.record.sample_rate, info.record.channels,
 		   info.record.precision,
 		   audio_enc_from_val(info.record.encoding));
 	if (!no_time_limit && verbose)
 		fprintf(stderr, "recording for %lu seconds, %lu microseconds\n",
 		    (u_long)record_time.tv_sec, (u_long)record_time.tv_usec);
 	(void)gettimeofday(&start_time, NULL);
 	while (no_time_limit || timeleft(&start_time, &record_time)) {
 		if ((size_t)read(audiofd, buffer, bufsize) != bufsize)
 			err(1, "read failed");
 		if (conv_func)
 			(*conv_func)(buffer, bufsize);
 		if ((size_t)write(outfd, buffer, bufsize) != bufsize)
 			err(1, "write failed");
 		total_size += bufsize;
+	}
 	cleanup(0);
+}
 int
-timeleft(start_tvp, record_tvp)
+timeleft(struct timeval *start_tvp, struct timeval *record_tvp)
 	struct timeval *start_tvp;
 	struct timeval *record_tvp;
+{
 	struct timeval now, diff;
 	(void)gettimeofday(&now, NULL);
 	timersub(&now, start_tvp, &diff);
 	timersub(record_tvp, &diff, &now);
 	return (now.tv_sec > 0 || (now.tv_sec == 0 && now.tv_usec > 0));
+}
 void
-cleanup(signo)
+cleanup(int signo)
 	int signo;
+{
 	rewrite_header();
 	close(outfd);
 	if (omonitor_gain) {
 		AUDIO_INITINFO(&info);
 		info.monitor_gain = omonitor_gain;
 		if (ioctl(audiofd, AUDIO_SETINFO, &info) < 0)
 			err(1, "failed to reset audio info");
+	}
 	close(audiofd);
 	if (signo != 0) {
 		(void)raise_default_signal(signo);
+	}
 	exit(0);
+}
-int
+static int
-write_header_sun(hdrp, lenp, leftp)
+write_header_sun(void **hdrp, size_t *lenp, int *leftp)
 	void **hdrp;
 	size_t *lenp;
 	int *leftp;
+{
 	static int warned = 0;
 	static sun_audioheader auh;
 	int sunenc, oencoding = encoding;
 	/* only perform conversions if we don't specify the encoding */
 	switch (encoding) {
 	case AUDIO_ENCODING_ULINEAR_LE:
 #if BYTE_ORDER == LITTLE_ENDIAN
 	case AUDIO_ENCODING_ULINEAR:
 #endif
 		if (precision == 16)
 			conv_func = change_sign16_swap_bytes_le;
 		else if (precision == 32)
 			conv_func = change_sign32_swap_bytes_le;
 		if (conv_func)
 			encoding = AUDIO_ENCODING_SLINEAR_BE;
 		break;
 	case AUDIO_ENCODING_ULINEAR_BE:
 #if BYTE_ORDER == BIG_ENDIAN
 	case AUDIO_ENCODING_ULINEAR:
 #endif
 		if (precision == 16)
 			conv_func = change_sign16_be;
 		else if (precision == 32)
 			conv_func = change_sign32_be;
 		if (conv_func)
 			encoding = AUDIO_ENCODING_SLINEAR_BE;
 		break;
 	case AUDIO_ENCODING_SLINEAR_LE:
 #if BYTE_ORDER == LITTLE_ENDIAN
 	case AUDIO_ENCODING_SLINEAR:
 #endif
 		if (precision == 16)
 			conv_func = swap_bytes;
 		else if (precision == 32)
 			conv_func = swap_bytes32;
 		if (conv_func)
 			encoding = AUDIO_ENCODING_SLINEAR_BE;
 		break;
 #if BYTE_ORDER == BIG_ENDIAN
 	case AUDIO_ENCODING_SLINEAR:
 		encoding = AUDIO_ENCODING_SLINEAR_BE;
 		break;
 #endif
+	}
 	/* if we can't express this as a Sun header, don't write any */
 	if (audio_encoding_to_sun(encoding, precision, &sunenc) != 0) {
 		if (!qflag && !warned) {
 			const char *s = audio_enc_from_val(oencoding);
 			if (s == NULL)
 				s = "(unknown)";
 			warnx("failed to convert to sun encoding from %s "
 			      "(precision %d);\nSun audio header not written",
 			      s, precision);
+		}
 		format = AUDIO_FORMAT_NONE;
 		conv_func = 0;
 		warned = 1;
 		return -1;
+	}
 	auh.magic = htonl(AUDIO_FILE_MAGIC);
 	if (outfd == STDOUT_FILENO)
 		auh.data_size = htonl(AUDIO_UNKNOWN_SIZE);
 	else if (total_size != -1)
 		auh.data_size = htonl(total_size);
 	else
 		auh.data_size = 0;
 	auh.encoding = htonl(sunenc);
 	auh.sample_rate = htonl(sample_rate);
 	auh.channels = htonl(channels);
 	if (header_info) {
 		int 	len, infolen;
 		infolen = ((len = strlen(header_info)) + 7) & 0xfffffff8;
 		*leftp = infolen - len;
 		auh.hdr_size = htonl(sizeof(auh) + infolen);
 	} else {
 		*leftp = sizeof(default_info);
 		auh.hdr_size = htonl(sizeof(auh) + *leftp);
+	}
 	*(sun_audioheader **)hdrp = &auh;
 	*lenp = sizeof auh;
 	return 0;
+}
-int
+static int
-write_header_wav(hdrp, lenp, leftp)
+write_header_wav(void **hdrp, size_t *lenp, int *leftp)
 	void **hdrp;
 	size_t *lenp;
 	int *leftp;
+{
 	/*
 	 * WAV header we write looks like this:
+	 *
 	 *      bytes   purpose
 	 *      0-3     "RIFF"
 	 *      4-7     file length (minus 8)
 	 *      8-15    "WAVEfmt "
 	 *      16-19   format size
 	 *      20-21   format tag
 	 *      22-23   number of channels
 	 *      24-27   sample rate
 	 *      28-31   average bytes per second
 	 *      32-33   block alignment
 	 *      34-35   bits per sample
+	 *
 	 * then for ULAW and ALAW outputs, we have an extended chunk size
 	 * and a WAV "fact" to add:
+	 *
 	 *      36-37   length of extension (== 0)
 	 *      38-41   "fact"
 	 *      42-45   fact size
 	 *      46-49   number of samples written
 	 *      50-53   "data"
 	 *      54-57   data length
 	 *      58-     raw audio data
+	 *
 	 * for PCM outputs we have just the data remaining:
+	 *
 	 *      36-39   "data"
 	 *      40-43   data length
 	 *      44-     raw audio data
+	 *
 	 *	RIFF\^@^C^@WAVEfmt ^P^@^@^@^A^@^B^@D<AC>^@^@^P<B1>^B^@^D^@^P^@data^@^@^C^@^@^@^@^@^@^@^@^@^@
 	 */
 	char	wavheaderbuf[64], *p = wavheaderbuf;
 	const char *riff = "RIFF",
 	    *wavefmt = "WAVEfmt ",
 	    *fact = "fact",
 	    *data = "data";
 	u_int32_t filelen, fmtsz, sps, abps, factsz = 4, nsample, datalen;
 	u_int16_t fmttag, nchan, align, bps, extln = 0;
 	if (header_info)
 		warnx("header information not supported for WAV");
 	*leftp = 0;
 	switch (precision) {
 	case 8:
 		bps = 8;
 		break;
 	case 16:
 		bps = 16;
 		break;
 	case 32:
 		bps = 32;
 		break;
 	default:
+		{
 			static int warned = 0;
 			if (warned == 0) {
 				warnx("can not support precision of %d", precision);
 				warned = 1;
+			}
+		}
 		return (-1);
+	}
 	switch (encoding) {
 	case AUDIO_ENCODING_ULAW:
 		fmttag = WAVE_FORMAT_MULAW;
 		fmtsz = 18;
 		align = channels;
 		break;
 	case AUDIO_ENCODING_ALAW:
 		fmttag = WAVE_FORMAT_ALAW;
 		fmtsz = 18;
 		align = channels;
 		break;
 	/*
 	 * we could try to support RIFX but it seems to be more portable
 	 * to output little-endian data for WAV files.
 	 */
 	case AUDIO_ENCODING_ULINEAR_BE:
 #if BYTE_ORDER == BIG_ENDIAN
 	case AUDIO_ENCODING_ULINEAR:
 #endif
 		if (bps == 16)
 			conv_func = change_sign16_swap_bytes_be;
 		else if (bps == 32)
 			conv_func = change_sign32_swap_bytes_be;
 		goto fmt_pcm;
 	case AUDIO_ENCODING_SLINEAR_BE:
 #if BYTE_ORDER == BIG_ENDIAN
 	case AUDIO_ENCODING_SLINEAR:
 #endif
 		if (bps == 8)
 			conv_func = change_sign8;
 		else if (bps == 16)
 			conv_func = swap_bytes;
 		else if (bps == 32)
 			conv_func = swap_bytes32;
 		goto fmt_pcm;
 	case AUDIO_ENCODING_ULINEAR_LE:
 #if BYTE_ORDER == LITTLE_ENDIAN
 	case AUDIO_ENCODING_ULINEAR:
 #endif
 		if (bps == 16)
 			conv_func = change_sign16_le;
 		else if (bps == 32)
 			conv_func = change_sign32_le;
 		/* FALLTHROUGH */
 	case AUDIO_ENCODING_SLINEAR_LE:
 	case AUDIO_ENCODING_PCM16:
 #if BYTE_ORDER == LITTLE_ENDIAN
 	case AUDIO_ENCODING_SLINEAR:
 #endif
 		if (bps == 8)
 			conv_func = change_sign8;
 fmt_pcm:
 		fmttag = WAVE_FORMAT_PCM;
 		fmtsz = 16;
 		align = channels * (bps / 8);
 		break;
 	default:
+		{
 			static int warned = 0;
 			if (warned == 0) {
 				const char *s = wav_enc_from_val(encoding);
 				if (s == NULL)
 					warnx("can not support encoding of %s", s);
 				else
 					warnx("can not support encoding of %d", encoding);
 				warned = 1;
+			}
+		}
 		format = AUDIO_FORMAT_NONE;
 		return (-1);
+	}
 	nchan = channels;
 	sps = sample_rate;
 	/* data length */
 	if (outfd == STDOUT_FILENO)
 		datalen = 0;
 	else if (total_size != -1)
 		datalen = total_size;
 	else
 		datalen = 0;
 	/* file length */
 	filelen = 4 + (8 + fmtsz) + (8 + datalen);
 	if (fmttag != WAVE_FORMAT_PCM)
 		filelen += 8 + factsz;
 	abps = (double)align*sample_rate / (double)1 + 0.5;
 	nsample = (datalen / bps) / sample_rate;
 	/*
 	 * now we've calculated the info, write it out!
 	 */
 #define put32(x) do { \
 	u_int32_t _f; \
 	putle32(_f, (x)); \
 	memcpy(p, &_f, 4); \
 } while (0)
 #define put16(x) do { \
 	u_int16_t _f; \
 	putle16(_f, (x)); \
 	memcpy(p, &_f, 2); \
 } while (0)
 	memcpy(p, riff, 4);
 	p += 4;				/* 4 */
 	put32(filelen);
 	p += 4;				/* 8 */
 	memcpy(p, wavefmt, 8);
 	p += 8;				/* 16 */
 	put32(fmtsz);
 	p += 4;				/* 20 */
 	put16(fmttag);
 	p += 2;				/* 22 */
 	put16(nchan);
 	p += 2;				/* 24 */
 	put32(sps);
 	p += 4;				/* 28 */
 	put32(abps);
 	p += 4;				/* 32 */
 	put16(align);
 	p += 2;				/* 34 */
 	put16(bps);
 	p += 2;				/* 36 */
 	/* NON PCM formats have an extended chunk; write it */
 	if (fmttag != WAVE_FORMAT_PCM) {
 		put16(extln);
 		p += 2;			/* 38 */
 		memcpy(p, fact, 4);
 		p += 4;			/* 42 */
 		put32(factsz);
 		p += 4;			/* 46 */
 		put32(nsample);
 		p += 4;			/* 50 */
+	}
 	memcpy(p, data, 4);
 	p += 4;				/* 40/54 */
 	put32(datalen);
 	p += 4;				/* 44/58 */
 #undef put32
 #undef put16
 	*hdrp = wavheaderbuf;
 	*lenp = (p - wavheaderbuf);
 	return 0;
+}
-void
+static void
-write_header()
+write_header(void)
+{
 	struct iovec iv[3];
 	int veclen, left, tlen;
 	void *hdr;
 	size_t hdrlen;
 	switch (format) {
 	case AUDIO_FORMAT_DEFAULT:
 	case AUDIO_FORMAT_SUN:
 		if (write_header_sun(&hdr, &hdrlen, &left) != 0)
 			return;
 		break;
 	case AUDIO_FORMAT_WAV:
 		if (write_header_wav(&hdr, &hdrlen, &left) != 0)
 			return;
 		break;
 	case AUDIO_FORMAT_NONE:
 		return;
 	default:
 		errx(1, "unknown audio format");
+	}
 	veclen = 0;
 	tlen = 0;
 	if (hdrlen != 0) {
 		iv[veclen].iov_base = hdr;
 		iv[veclen].iov_len = hdrlen;
 		tlen += iv[veclen++].iov_len;
+	}
 	if (header_info) {
 		iv[veclen].iov_base = header_info;
 		iv[veclen].iov_len = (int)strlen(header_info) + 1;
 		tlen += iv[veclen++].iov_len;
+	}
 	if (left) {
 		iv[veclen].iov_base = default_info;
 		iv[veclen].iov_len = left;
 		tlen += iv[veclen++].iov_len;
+	}
 	if (tlen == 0)
 		return;
 	if (writev(outfd, iv, veclen) != tlen)
 		err(1, "could not write audio header");
+}
-void
+static void
-rewrite_header()
+rewrite_header(void)
+{
 	/* can't do this here! */
 	if (outfd == STDOUT_FILENO)
 		return;
 	if (lseek(outfd, SEEK_SET, 0) < 0)
 		err(1, "could not seek to start of file for header rewrite");
 	write_header();
+}
-void
+static void
-usage()
+usage(void)
+{
 	fprintf(stderr, "Usage: %s [-afhqV] [options] {files ...|-}\n",
 	    getprogname());
 	fprintf(stderr, "Options:\n\t"
 	    "-B buffer size\n\t"
 	    "-b balance (0-63)\n\t"
 	    "-c channels\n\t"
 	    "-d audio device\n\t"
 	    "-e encoding\n\t"
 	    "-F format\n\t"
 	    "-i header information\n\t"
 	    "-m monitor volume\n\t"
 	    "-P precision (4, 8, 16, 24, or 32 bits)\n\t"
 	    "-p input port\n\t"
 	    "-s sample rate\n\t"
 	    "-t recording time\n\t"
 	    "-v volume\n");
 	exit(EXIT_FAILURE);
+}