audio encoding tester

7 files changed, 1416 insertions, 0 deletions

diff --git a/regress/sys/dev/audio/Makefile b/regress/sys/dev/audio/Makefile
new file mode 100644
index 00000000000..22c970043f8
--- /dev/null
+++ b/regress/sys/dev/audio/Makefile
@@ -0,0 +1,13 @@
+
+PROG=autest
+SRCS=autest.c adpcm.c law.c
+CFLAGS+=-Wall -Wstrict-prototypes -Wmissing-prototypes
+MAN1=autest.1
+LDADD=-lm
+
+.ifndef DO_AUTEST
+REGRESS_SKIP=
+REGRESS_SKIP_TARGETS=autest
+.endif
+
+.include <bsd.regress.mk>
diff --git a/regress/sys/dev/audio/adpcm.c b/regress/sys/dev/audio/adpcm.c
new file mode 100644
index 00000000000..79cb7c1f25f
--- /dev/null
+++ b/regress/sys/dev/audio/adpcm.c
@@ -0,0 +1,259 @@
+/*	$OpenBSD: adpcm.c,v 1.1 2003/02/01 17:58:18 jason Exp $	*/
+
+/***********************************************************
+Copyright 1992 by Stichting Mathematisch Centrum, Amsterdam, The
+Netherlands.
+
+                        All Rights Reserved
+
+Permission to use, copy, modify, and distribute this software and its 
+documentation for any purpose and without fee is hereby granted, 
+provided that the above copyright notice appear in all copies and that
+both that copyright notice and this permission notice appear in 
+supporting documentation, and that the names of Stichting Mathematisch
+Centrum or CWI not be used in advertising or publicity pertaining to
+distribution of the software without specific, written prior permission.
+
+STICHTING MATHEMATISCH CENTRUM DISCLAIMS ALL WARRANTIES WITH REGARD TO
+THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
+FITNESS, IN NO EVENT SHALL STICHTING MATHEMATISCH CENTRUM BE LIABLE
+FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
+OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+******************************************************************/
+
+/*
+** Intel/DVI ADPCM coder/decoder.
+**
+** The algorithm for this coder was taken from the IMA Compatability Project
+** proceedings, Vol 2, Number 2; May 1992.
+**
+** Version 1.2, 18-Dec-92.
+**
+** Change log:
+** - Fixed a stupid bug, where the delta was computed as
+**   stepsize*code/4 in stead of stepsize*(code+0.5)/4.
+** - There was an off-by-one error causing it to pick
+**   an incorrect delta once in a blue moon.
+** - The NODIVMUL define has been removed. Computations are now always done
+**   using shifts, adds and subtracts. It turned out that, because the standard
+**   is defined using shift/add/subtract, you needed bits of fixup code
+**   (because the div/mul simulation using shift/add/sub made some rounding
+**   errors that real div/mul don't make) and all together the resultant code
+**   ran slower than just using the shifts all the time.
+** - Changed some of the variable names to be more meaningful.
+*/
+
+#include <sys/types.h>
+
+#include "adpcm.h"
+#include <stdio.h> /*DBG*/
+
+#ifndef __STDC__
+#define signed
+#endif
+
+/* Intel ADPCM step variation table */
+static int indexTable[16] = {
+    -1, -1, -1, -1, 2, 4, 6, 8,
+    -1, -1, -1, -1, 2, 4, 6, 8,
+};
+
+static int stepsizeTable[89] = {
+    7, 8, 9, 10, 11, 12, 13, 14, 16, 17,
+    19, 21, 23, 25, 28, 31, 34, 37, 41, 45,
+    50, 55, 60, 66, 73, 80, 88, 97, 107, 118,
+    130, 143, 157, 173, 190, 209, 230, 253, 279, 307,
+    337, 371, 408, 449, 494, 544, 598, 658, 724, 796,
+    876, 963, 1060, 1166, 1282, 1411, 1552, 1707, 1878, 2066,
+    2272, 2499, 2749, 3024, 3327, 3660, 4026, 4428, 4871, 5358,
+    5894, 6484, 7132, 7845, 8630, 9493, 10442, 11487, 12635, 13899,
+    15289, 16818, 18500, 20350, 22385, 24623, 27086, 29794, 32767
+};
+    
+void
+adpcm_coder(indata, outdata, len, state)
+    int16_t indata[];
+    char outdata[];
+    int len;
+    struct adpcm_state *state;
+{
+    int16_t *inp;		/* Input buffer pointer */
+    signed char *outp;		/* output buffer pointer */
+    int val;			/* Current input sample value */
+    int sign;			/* Current adpcm sign bit */
+    int delta;			/* Current adpcm output value */
+    int diff;			/* Difference between val and valprev */
+    int step;			/* Stepsize */
+    int valpred;		/* Predicted output value */
+    int vpdiff;			/* Current change to valpred */
+    int index;			/* Current step change index */
+    int outputbuffer;		/* place to keep previous 4-bit value */
+    int bufferstep;		/* toggle between outputbuffer/output */
+
+    outputbuffer = 0; /* XXX gcc */
+
+    outp = (signed char *)outdata;
+    inp = indata;
+
+    valpred = state->valprev;
+    index = state->index;
+    step = stepsizeTable[index];
+    
+    bufferstep = 1;
+
+    for ( ; len > 0 ; len-- ) {
+	val = *inp++;
+
+	/* Step 1 - compute difference with previous value */
+	diff = val - valpred;
+	sign = (diff < 0) ? 8 : 0;
+	if ( sign ) diff = (-diff);
+
+	/* Step 2 - Divide and clamp */
+	/* Note:
+	** This code *approximately* computes:
+	**    delta = diff*4/step;
+	**    vpdiff = (delta+0.5)*step/4;
+	** but in shift step bits are dropped. The net result of this is
+	** that even if you have fast mul/div hardware you cannot put it to
+	** good use since the fixup would be too expensive.
+	*/
+	delta = 0;
+	vpdiff = (step >> 3);
+	
+	if ( diff >= step ) {
+	    delta = 4;
+	    diff -= step;
+	    vpdiff += step;
+	}
+	step >>= 1;
+	if ( diff >= step  ) {
+	    delta |= 2;
+	    diff -= step;
+	    vpdiff += step;
+	}
+	step >>= 1;
+	if ( diff >= step ) {
+	    delta |= 1;
+	    vpdiff += step;
+	}
+
+	/* Step 3 - Update previous value */
+	if ( sign )
+	  valpred -= vpdiff;
+	else
+	  valpred += vpdiff;
+
+	/* Step 4 - Clamp previous value to 16 bits */
+	if ( valpred > 32767 )
+	  valpred = 32767;
+	else if ( valpred < -32768 )
+	  valpred = -32768;
+
+	/* Step 5 - Assemble value, update index and step values */
+	delta |= sign;
+	
+	index += indexTable[delta];
+	if ( index < 0 ) index = 0;
+	if ( index > 88 ) index = 88;
+	step = stepsizeTable[index];
+
+	/* Step 6 - Output value */
+	if ( bufferstep ) {
+	    outputbuffer = (delta << 4) & 0xf0;
+	} else {
+	    *outp++ = (delta & 0x0f) | outputbuffer;
+	}
+	bufferstep = !bufferstep;
+    }
+
+    /* Output last step, if needed */
+    if ( !bufferstep )
+      *outp++ = outputbuffer;
+    
+    state->valprev = valpred;
+    state->index = index;
+}
+
+void
+adpcm_decoder(indata, outdata, len, state)
+    char indata[];
+    int16_t outdata[];
+    int len;
+    struct adpcm_state *state;
+{
+    signed char *inp;		/* Input buffer pointer */
+    int16_t *outp;		/* output buffer pointer */
+    int sign;			/* Current adpcm sign bit */
+    int delta;			/* Current adpcm output value */
+    int step;			/* Stepsize */
+    int valpred;		/* Predicted value */
+    int vpdiff;			/* Current change to valpred */
+    int index;			/* Current step change index */
+    int inputbuffer;		/* place to keep next 4-bit value */
+    int bufferstep;		/* toggle between inputbuffer/input */
+
+    inputbuffer = 0; /* XXX gcc */
+    outp = outdata;
+    inp = (signed char *)indata;
+
+    valpred = state->valprev;
+    index = state->index;
+    step = stepsizeTable[index];
+
+    bufferstep = 0;
+    
+    for ( ; len > 0 ; len-- ) {
+	
+	/* Step 1 - get the delta value */
+	if ( bufferstep ) {
+	    delta = inputbuffer & 0xf;
+	} else {
+	    inputbuffer = *inp++;
+	    delta = (inputbuffer >> 4) & 0xf;
+	}
+	bufferstep = !bufferstep;
+
+	/* Step 2 - Find new index value (for later) */
+	index += indexTable[delta];
+	if ( index < 0 ) index = 0;
+	if ( index > 88 ) index = 88;
+
+	/* Step 3 - Separate sign and magnitude */
+	sign = delta & 8;
+	delta = delta & 7;
+
+	/* Step 4 - Compute difference and new predicted value */
+	/*
+	** Computes 'vpdiff = (delta+0.5)*step/4', but see comment
+	** in adpcm_coder.
+	*/
+	vpdiff = step >> 3;
+	if ( delta & 4 ) vpdiff += step;
+	if ( delta & 2 ) vpdiff += step>>1;
+	if ( delta & 1 ) vpdiff += step>>2;
+
+	if ( sign )
+	  valpred -= vpdiff;
+	else
+	  valpred += vpdiff;
+
+	/* Step 5 - clamp output value */
+	if ( valpred > 32767 )
+	  valpred = 32767;
+	else if ( valpred < -32768 )
+	  valpred = -32768;
+
+	/* Step 6 - Update step value */
+	step = stepsizeTable[index];
+
+	/* Step 7 - Output value */
+	*outp++ = valpred;
+    }
+
+    state->valprev = valpred;
+    state->index = index;
+}
diff --git a/regress/sys/dev/audio/adpcm.h b/regress/sys/dev/audio/adpcm.h
new file mode 100644
index 00000000000..ee8ab459acd
--- /dev/null
+++ b/regress/sys/dev/audio/adpcm.h
@@ -0,0 +1,21 @@
+/*	$OpenBSD: adpcm.h,v 1.1.1.1 2003/02/01 17:58:18 jason Exp $	*/
+
+/*
+** adpcm.h - include file for adpcm coder.
+**
+** Version 1.0, 7-Jul-92.
+*/
+
+struct adpcm_state {
+    int16_t	valprev;	/* Previous output value */
+    char	index;		/* Index into stepsize table */
+};
+
+#ifdef __STDC__
+#define ARGS(x) x
+#else
+#define ARGS(x) ()
+#endif
+
+void adpcm_coder ARGS((int16_t [], char [], int, struct adpcm_state *));
+void adpcm_decoder ARGS((char [], int16_t [], int, struct adpcm_state *));
diff --git a/regress/sys/dev/audio/autest.1 b/regress/sys/dev/audio/autest.1
new file mode 100644
index 00000000000..ba895d60eb9
--- /dev/null
+++ b/regress/sys/dev/audio/autest.1
@@ -0,0 +1,74 @@
+.\"	$OpenBSD: autest.1,v 1.1 2003/02/01 17:58:18 jason Exp $
+.\"
+.\" Copyright (c) 2002 Jason L. Wright (jason@thought.net)
+.\" 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.
+.\" 3. All advertising materials mentioning features or use of this software
+.\"    must display the following acknowledgement:
+.\"	This product includes software developed by Jason L. Wright
+.\" 4. The name of the author may not be used to endorse or promote products
+.\"    derived from this software without specific prior written permission.
+.\"
+.\" 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.
+.\"
+.Dd September 10, 2002
+.Dt AUTEST 1
+.Os
+.Sh NAME
+.Nm autest
+.Nd test audio encoding output
+.Sh SYNOPSIS
+.Nm autest
+.Sh DESCRIPTION
+The
+.Nm
+utility opens
+.Ar /dev/sound
+and iterates through all of the encodings supported by the device playing
+a 440Hz tone in the proper format.
+The tone should sound almost identical in each of the formats.
+.Pp
+.Nm
+can produce tones in any of the following formats and will skip other
+formats if supported by the device:
+.Bl -tag -width XXXXXXXXXX
+.It Cm mulaw
+8bit U-Law companded
+.It Cm alaw
+8bit A-Law companded
+.It Cm adpcm
+4 bit adaptive differential pulse code modulation
+.It Cm ulinear
+8 bit unsigned linear.
+.It Cm ulinear_le
+16 bit unsigned linear little endian
+.It Cm ulinear_be
+16 bit unsigned linear big endian
+.It Cm slinear
+8 bit signed linear
+.It Cm slinear_le
+16 bit signed linear little endian
+.It Cm slinear_be
+16 bit signed linear big endian
+.Sh SEE ALSO
+.Xr audio 4
+.Sh BUGS
+The ADPCM encoding sounds very noisy on CS4231 (it's probaly incorrect).
diff --git a/regress/sys/dev/audio/autest.c b/regress/sys/dev/audio/autest.c
new file mode 100644
index 00000000000..d3e1f4e1af3
--- /dev/null
+++ b/regress/sys/dev/audio/autest.c
@@ -0,0 +1,725 @@
+/*	$OpenBSD: autest.c,v 1.1 2003/02/01 17:58:18 jason Exp $	*/
+
+/*
+ * Copyright (c) 2002 Jason L. Wright (jason@thought.net)
+ * 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.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *	This product includes software developed by Jason L. Wright
+ * 4. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission.
+ *
+ * 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/types.h>
+#include <sys/ioctl.h>
+#include <sys/audioio.h>
+#include <string.h>
+#include <fcntl.h>
+#include <err.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <math.h>
+#include <unistd.h>
+
+#include "adpcm.h"
+#include "law.h"
+
+int main(void);
+void check_encoding(int, audio_encoding_t *);
+void check_encoding_mono(int, audio_encoding_t *);
+void check_encoding_stereo(int, audio_encoding_t *);
+void enc_ulaw_8(int, audio_encoding_t *, int);
+void enc_alaw_8(int, audio_encoding_t *, int);
+void enc_ulinear_8(int, audio_encoding_t *, int);
+void enc_ulinear_be_16(int, audio_encoding_t *, int);
+void enc_ulinear_le_16(int, audio_encoding_t *, int);
+void enc_slinear_8(int, audio_encoding_t *, int);
+void enc_slinear_be_16(int, audio_encoding_t *, int);
+void enc_slinear_le_16(int, audio_encoding_t *, int);
+void enc_adpcm_8(int, audio_encoding_t *, int);
+void audio_wait(int);
+
+#define	PLAYSECS	2
+
+int
+main()
+{
+	int fd, i;
+
+	fd = open("/dev/sound", O_RDWR, 0);
+	if (fd == -1)
+		err(1, "open");
+
+
+	for (i = 0; ; i++) {
+		audio_encoding_t enc;
+
+		enc.index = i;
+		if (ioctl(fd, AUDIO_GETENC, &enc) == -1)
+			break;
+		check_encoding(fd, &enc);
+	}
+	close(fd);
+
+	return (0);
+}
+
+void
+check_encoding(int fd, audio_encoding_t *enc)
+{
+	printf("%s:%d%s",
+	    enc->name,
+	    enc->precision,
+	    (enc->flags & AUDIO_ENCODINGFLAG_EMULATED) ? "*" : "");
+	fflush(stdout);
+	check_encoding_mono(fd, enc);
+	check_encoding_stereo(fd, enc);
+	printf("\n");
+}
+
+void
+check_encoding_stereo(int fd, audio_encoding_t *enc)
+{
+	printf("...stereo");
+	fflush(stdout);
+	switch (enc->encoding) {
+	case AUDIO_ENCODING_ULAW:
+		if (enc->precision == 8) {
+			enc_ulaw_8(fd, enc, 2);
+		}
+		break;
+	case AUDIO_ENCODING_ALAW:
+		if (enc->precision == 8) {
+			enc_alaw_8(fd, enc, 2);
+		}
+		break;
+	case AUDIO_ENCODING_ULINEAR:
+		if (enc->precision == 8) {
+			enc_ulinear_8(fd, enc, 2);
+		}
+		break;
+	case AUDIO_ENCODING_ULINEAR_LE:
+		if (enc->precision == 8)
+			enc_ulinear_8(fd, enc, 2);
+		else if (enc->precision == 16)
+			enc_ulinear_le_16(fd, enc, 2);
+		break;
+	case AUDIO_ENCODING_ULINEAR_BE:
+		if (enc->precision == 8)
+			enc_ulinear_8(fd, enc, 2);
+		else if (enc->precision == 16)
+			enc_ulinear_be_16(fd, enc, 2);
+		break;
+	case AUDIO_ENCODING_SLINEAR:
+		if (enc->precision == 8) {
+			enc_slinear_8(fd, enc, 2);
+		}
+		break;
+	case AUDIO_ENCODING_SLINEAR_LE:
+		if (enc->precision == 8)
+			enc_slinear_8(fd, enc, 2);
+		else if (enc->precision == 16)
+			enc_slinear_le_16(fd, enc, 2);
+		break;
+	case AUDIO_ENCODING_SLINEAR_BE:
+		if (enc->precision == 8)
+			enc_slinear_8(fd, enc, 2);
+		else if (enc->precision == 16)
+			enc_slinear_be_16(fd, enc, 2);
+		break;
+	default:
+		printf("[skip]");
+	}
+}
+
+void
+check_encoding_mono(int fd, audio_encoding_t *enc)
+{
+	printf("...mono");
+	fflush(stdout);
+	switch (enc->encoding) {
+	case AUDIO_ENCODING_ULAW:
+		if (enc->precision == 8) {
+			enc_ulaw_8(fd, enc, 1);
+		}
+		break;
+	case AUDIO_ENCODING_ALAW:
+		if (enc->precision == 8) {
+			enc_alaw_8(fd, enc, 1);
+		}
+		break;
+	case AUDIO_ENCODING_ULINEAR:
+		if (enc->precision == 8) {
+			enc_ulinear_8(fd, enc, 1);
+		}
+		break;
+	case AUDIO_ENCODING_ULINEAR_LE:
+		if (enc->precision == 8)
+			enc_ulinear_8(fd, enc, 1);
+		else if (enc->precision == 16)
+			enc_ulinear_le_16(fd, enc, 1);
+		break;
+	case AUDIO_ENCODING_ULINEAR_BE:
+		if (enc->precision == 8)
+			enc_ulinear_8(fd, enc, 1);
+		else if (enc->precision == 16)
+			enc_ulinear_be_16(fd, enc, 1);
+		break;
+	case AUDIO_ENCODING_SLINEAR:
+		if (enc->precision == 8) {
+			enc_slinear_8(fd, enc, 1);
+		}
+		break;
+	case AUDIO_ENCODING_SLINEAR_LE:
+		if (enc->precision == 8)
+			enc_slinear_8(fd, enc, 1);
+		else if (enc->precision == 16)
+			enc_slinear_le_16(fd, enc, 1);
+		break;
+	case AUDIO_ENCODING_SLINEAR_BE:
+		if (enc->precision == 8)
+			enc_slinear_8(fd, enc, 1);
+		else if (enc->precision == 16)
+			enc_slinear_be_16(fd, enc, 1);
+		break;
+#if 0
+	case AUDIO_ENCODING_ADPCM:
+		if (enc->precision == 8)
+			enc_adpcm_8(fd, enc, 1);
+		break;
+#endif
+	default:
+		printf("[skip]");
+	}
+}
+
+void
+enc_ulinear_8(int fd, audio_encoding_t *enc, int chans)
+{
+	audio_info_t inf;
+	u_int8_t *samples = NULL, *p;
+	int i, j;
+
+	AUDIO_INITINFO(&inf);
+	inf.play.precision = enc->precision;
+	inf.play.encoding = enc->encoding;
+	inf.play.channels = chans;
+
+	if (ioctl(fd, AUDIO_SETINFO, &inf) == -1) {
+		warn("setinfo");
+		goto out;
+	}
+
+	if (ioctl(fd, AUDIO_GETINFO, &inf) == -1) {
+		warn("getinfo");
+		goto out;
+	}
+
+	samples = (u_int8_t *)malloc(inf.play.sample_rate * chans);
+	if (samples == NULL) {
+		warn("malloc");
+		goto out;
+	}
+
+	for (i = 0, p = samples; i < inf.play.sample_rate; i++) {
+		double d;
+		u_int8_t v;
+
+		d = 127.0 * sin(((double)i / (double)inf.play.sample_rate) *
+		    (2 * M_PI * 440.0));
+		d = rint(d + 127.0);
+		v = d;
+
+		for (j = 0; j < chans; j++) {
+			*p = v;
+			p++;
+		}
+	}
+
+	for (i = 0; i < PLAYSECS; i++)
+		write(fd, samples, inf.play.sample_rate * chans);
+	audio_wait(fd);
+
+out:
+	if (samples != NULL)
+		free(samples);
+}
+
+void
+enc_slinear_8(int fd, audio_encoding_t *enc, int chans)
+{
+	audio_info_t inf;
+	int8_t *samples = NULL, *p;
+	int i, j;
+
+	AUDIO_INITINFO(&inf);
+	inf.play.precision = enc->precision;
+	inf.play.encoding = enc->encoding;
+	inf.play.channels = chans;
+
+	if (ioctl(fd, AUDIO_SETINFO, &inf) == -1) {
+		warn("setinfo");
+		goto out;
+	}
+
+	if (ioctl(fd, AUDIO_GETINFO, &inf) == -1) {
+		warn("getinfo");
+		goto out;
+	}
+
+	samples = (int8_t *)malloc(inf.play.sample_rate * chans);
+	if (samples == NULL) {
+		warn("malloc");
+		goto out;
+	}
+
+	for (i = 0, p = samples; i < inf.play.sample_rate; i++) {
+		double d;
+		int8_t v;
+
+		d = 127.0 * sin(((double)i / (double)inf.play.sample_rate) *
+		    (2 * M_PI * 440.0));
+		d = rint(d);
+		v = d;
+
+		for (j = 0; j < chans; j++) {
+			*p = v;
+			p++;
+		}
+	}
+
+	for (i = 0; i < PLAYSECS; i++)
+		write(fd, samples, inf.play.sample_rate * chans);
+	audio_wait(fd);
+
+out:
+	if (samples != NULL)
+		free(samples);
+}
+
+void
+enc_slinear_be_16(int fd, audio_encoding_t *enc, int chans)
+{
+	audio_info_t inf;
+	u_int8_t *samples = NULL, *p;
+	int i, j;
+
+	AUDIO_INITINFO(&inf);
+	inf.play.precision = enc->precision;
+	inf.play.encoding = enc->encoding;
+	inf.play.channels = chans;
+
+	if (ioctl(fd, AUDIO_SETINFO, &inf) == -1) {
+		warn("setinfo");
+		goto out;
+	}
+
+	if (ioctl(fd, AUDIO_GETINFO, &inf) == -1) {
+		warn("getinfo");
+		goto out;
+	}
+
+	samples = (int8_t *)malloc(inf.play.sample_rate * chans * 2);
+	if (samples == NULL) {
+		warn("malloc");
+		goto out;
+	}
+
+	for (i = 0, p = samples; i < inf.play.sample_rate; i++) {
+		double d;
+		int16_t v;
+
+		d = 32767.0 * sin(((double)i / (double)inf.play.sample_rate) *
+		    (2 * M_PI * 440.0));
+		d = rint(d);
+		v = d;
+
+		for (j = 0; j < chans; j++) {
+			*p = (v & 0xff00) >> 8;
+			p++;
+			*p = (v & 0x00ff) >> 0;
+			p++;
+		}
+	}
+
+	for (i = 0; i < PLAYSECS; i++)
+		write(fd, samples, inf.play.sample_rate * chans * 2);
+	audio_wait(fd);
+
+out:
+	if (samples != NULL)
+		free(samples);
+}
+
+void
+enc_slinear_le_16(int fd, audio_encoding_t *enc, int chans)
+{
+	audio_info_t inf;
+	u_int8_t *samples = NULL, *p;
+	int i, j;
+
+	AUDIO_INITINFO(&inf);
+	inf.play.precision = enc->precision;
+	inf.play.encoding = enc->encoding;
+	inf.play.channels = chans;
+
+	if (ioctl(fd, AUDIO_SETINFO, &inf) == -1) {
+		warn("setinfo");
+		goto out;
+	}
+
+	if (ioctl(fd, AUDIO_GETINFO, &inf) == -1) {
+		warn("getinfo");
+		goto out;
+	}
+
+	samples = (int8_t *)malloc(inf.play.sample_rate * chans * 2);
+	if (samples == NULL) {
+		warn("malloc");
+		goto out;
+	}
+
+	for (i = 0, p = samples; i < inf.play.sample_rate; i++) {
+		double d;
+		int16_t v;
+
+		d = 32767.0 * sin(((double)i / (double)inf.play.sample_rate) *
+		    (2 * M_PI * 440.0));
+		d = rint(d);
+		v = d;
+
+		for (j = 0; j < chans; j++) {
+			*p = (v & 0x00ff) >> 0;
+			p++;
+			*p = (v & 0xff00) >> 8;
+			p++;
+		}
+	}
+
+	for (i = 0; i < PLAYSECS; i++)
+		write(fd, samples, inf.play.sample_rate * chans * 2);
+	audio_wait(fd);
+
+out:
+	if (samples != NULL)
+		free(samples);
+}
+
+void
+enc_ulinear_le_16(int fd, audio_encoding_t *enc, int chans)
+{
+	audio_info_t inf;
+	u_int8_t *samples = NULL, *p;
+	int i, j;
+
+	AUDIO_INITINFO(&inf);
+	inf.play.precision = enc->precision;
+	inf.play.encoding = enc->encoding;
+	inf.play.channels = chans;
+
+	if (ioctl(fd, AUDIO_SETINFO, &inf) == -1) {
+		warn("setinfo");
+		goto out;
+	}
+
+	if (ioctl(fd, AUDIO_GETINFO, &inf) == -1) {
+		warn("getinfo");
+		goto out;
+	}
+
+	samples = (u_int8_t *)malloc(inf.play.sample_rate * chans * 2);
+	if (samples == NULL) {
+		warn("malloc");
+		goto out;
+	}
+
+	for (i = 0, p = samples; i < inf.play.sample_rate; i++) {
+		double d;
+		u_int16_t v;
+
+		d = 32767.0 * sin(((double)i / (double)inf.play.sample_rate) *
+		    (2 * M_PI * 440.0));
+		d = rint(d + 32767.0);
+		v = d;
+
+		for (j = 0; j < chans; j++) {
+			*p = (v >> 0) & 0xff;
+			p++;
+			*p = (v >> 8) & 0xff;
+			p++;
+		}
+	}
+
+	for (i = 0; i < PLAYSECS; i++)
+		write(fd, samples, inf.play.sample_rate * chans * 2);
+	audio_wait(fd);
+
+out:
+	if (samples != NULL)
+		free(samples);
+}
+
+void
+enc_ulinear_be_16(int fd, audio_encoding_t *enc, int chans)
+{
+	audio_info_t inf;
+	u_int8_t *samples = NULL, *p;
+	int i, j;
+
+	AUDIO_INITINFO(&inf);
+	inf.play.precision = enc->precision;
+	inf.play.encoding = enc->encoding;
+	inf.play.channels = chans;
+
+	if (ioctl(fd, AUDIO_SETINFO, &inf) == -1) {
+		warn("setinfo");
+		goto out;
+	}
+
+	if (ioctl(fd, AUDIO_GETINFO, &inf) == -1) {
+		warn("getinfo");
+		goto out;
+	}
+
+	samples = (u_int8_t *)malloc(inf.play.sample_rate * chans * 2);
+	if (samples == NULL) {
+		warn("malloc");
+		goto out;
+	}
+
+	for (i = 0, p = samples; i < inf.play.sample_rate; i++) {
+		double d;
+		u_int16_t v;
+
+		d = 32767.0 * sin(((double)i / (double)inf.play.sample_rate) *
+		    (2 * M_PI * 440.0));
+		d = rint(d + 32767.0);
+		v = d;
+
+		for (j = 0; j < chans; j++) {
+			*p = (v >> 8) & 0xff;
+			p++;
+			*p = (v >> 0) & 0xff;
+			p++;
+		}
+	}
+
+	for (i = 0; i < PLAYSECS; i++)
+		write(fd, samples, inf.play.sample_rate * chans * 2);
+	audio_wait(fd);
+
+out:
+	if (samples != NULL)
+		free(samples);
+}
+
+void
+enc_adpcm_8(int fd, audio_encoding_t *enc, int chans)
+{
+	audio_info_t inf;
+	struct adpcm_state adsts;
+	int16_t *samples = NULL;
+	int i;
+	char *outbuf = NULL;
+
+	AUDIO_INITINFO(&inf);
+	inf.play.precision = enc->precision;
+	inf.play.encoding = enc->encoding;
+	inf.play.channels = chans;
+
+	if (ioctl(fd, AUDIO_SETINFO, &inf) == -1) {
+		warn("setinfo");
+		goto out;
+	}
+
+	if (ioctl(fd, AUDIO_GETINFO, &inf) == -1) {
+		warn("getinfo");
+		goto out;
+	}
+
+	bzero(&adsts, sizeof(adsts));
+
+	samples = (int16_t *)malloc(inf.play.sample_rate * sizeof(*samples));
+	if (samples == NULL) {
+		warn("malloc");
+		goto out;
+	}
+
+	outbuf = (char *)malloc(inf.play.sample_rate / 2);
+	if (outbuf == NULL) {
+		warn("malloc");
+		goto out;
+	}
+
+	for (i = 0; i < inf.play.sample_rate; i++) {
+		double d;
+
+		d = 32767.0 * sin(((double)i / (double)inf.play.sample_rate) *
+		    (2 * M_PI * 440.0));
+		samples[i] = rint(d);
+	}
+
+	for (i = 0; i < PLAYSECS; i++) {
+		adpcm_coder(samples, outbuf, inf.play.sample_rate, &adsts);
+		write(fd, outbuf, inf.play.sample_rate / 2);
+	}
+	audio_wait(fd);
+
+out:
+	if (samples == NULL)
+		free(samples);
+	if (outbuf == NULL)
+		free(outbuf);
+}
+
+void
+enc_ulaw_8(int fd, audio_encoding_t *enc, int chans)
+{
+	audio_info_t inf;
+	int16_t *samples = NULL;
+	int i, j;
+	u_int8_t *outbuf = NULL, *p;
+
+	AUDIO_INITINFO(&inf);
+	inf.play.precision = enc->precision;
+	inf.play.encoding = enc->encoding;
+	inf.play.channels = chans;
+
+	if (ioctl(fd, AUDIO_SETINFO, &inf) == -1) {
+		warn("setinfo");
+		goto out;
+	}
+
+	if (ioctl(fd, AUDIO_GETINFO, &inf) == -1) {
+		warn("getinfo");
+		goto out;
+	}
+
+	samples = (int16_t *)calloc(inf.play.sample_rate, sizeof(*samples));
+	if (samples == NULL) {
+		warn("malloc");
+		goto out;
+	}
+
+	outbuf = (u_int8_t *)malloc(inf.play.sample_rate * chans);
+	if (outbuf == NULL) {
+		warn("malloc");
+		goto out;
+	}
+
+	for (i = 0; i < inf.play.sample_rate; i++) {
+		float x;
+
+		x = 32765.0 * sin(((double)i / (double)inf.play.sample_rate) *
+		    (2 * M_PI * 440.0));
+		samples[i] = x;
+	}
+
+	for (i = 0, p = outbuf; i < inf.play.sample_rate; i++) {
+		for (j = 0; j < chans; j++) {
+			*p = linear2ulaw(samples[i]);
+			p++;
+		}
+	}
+
+	for (i = 0; i < PLAYSECS; i++) {
+		write(fd, outbuf, inf.play.sample_rate * chans);
+	}
+	audio_wait(fd);
+
+out:
+	if (samples == NULL)
+		free(samples);
+	if (outbuf == NULL)
+		free(outbuf);
+}
+
+void
+enc_alaw_8(int fd, audio_encoding_t *enc, int chans)
+{
+	audio_info_t inf;
+	int16_t *samples = NULL;
+	int i, j;
+	u_int8_t *outbuf = NULL, *p;
+
+	AUDIO_INITINFO(&inf);
+	inf.play.precision = enc->precision;
+	inf.play.encoding = enc->encoding;
+	inf.play.channels = chans;
+
+	if (ioctl(fd, AUDIO_SETINFO, &inf) == -1) {
+		warn("setinfo");
+		goto out;
+	}
+
+	if (ioctl(fd, AUDIO_GETINFO, &inf) == -1) {
+		warn("getinfo");
+		goto out;
+	}
+
+	samples = (int16_t *)calloc(inf.play.sample_rate, sizeof(*samples));
+	if (samples == NULL) {
+		warn("malloc");
+		goto out;
+	}
+
+	outbuf = (u_int8_t *)malloc(inf.play.sample_rate * chans);
+	if (outbuf == NULL) {
+		warn("malloc");
+		goto out;
+	}
+
+	for (i = 0; i < inf.play.sample_rate; i++) {
+		float x;
+
+		x = 32767.0 * sin(((double)i / (double)inf.play.sample_rate) *
+		    (2 * M_PI * 440.0));
+		samples[i] = x;
+	}
+
+	for (i = 0, p = outbuf; i < inf.play.sample_rate; i++) {
+		for (j = 0; j < chans; j++) {
+			*p = linear2alaw(samples[i]);
+			p++;
+		}
+	}
+
+	for (i = 0; i < PLAYSECS; i++) {
+		write(fd, outbuf, inf.play.sample_rate * chans);
+	}
+	audio_wait(fd);
+
+out:
+	if (samples == NULL)
+		free(samples);
+	if (outbuf == NULL)
+		free(outbuf);
+}
+
+void
+audio_wait(int fd)
+{
+	if (ioctl(fd, AUDIO_DRAIN, NULL) == -1)
+		warn("drain");
+}
diff --git a/regress/sys/dev/audio/law.c b/regress/sys/dev/audio/law.c
new file mode 100644
index 00000000000..0b79c651eb6
--- /dev/null
+++ b/regress/sys/dev/audio/law.c
@@ -0,0 +1,286 @@
+/*	$OpenBSD: law.c,v 1.1.1.1 2003/02/01 17:58:18 jason Exp $	*/
+
+/*
+ * This source code is a product of Sun Microsystems, Inc. and is provided
+ * for unrestricted use.  Users may copy or modify this source code without
+ * charge.
+ *
+ * SUN SOURCE CODE IS PROVIDED AS IS WITH NO WARRANTIES OF ANY KIND INCLUDING
+ * THE WARRANTIES OF DESIGN, MERCHANTIBILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE, OR ARISING FROM A COURSE OF DEALING, USAGE OR TRADE PRACTICE.
+ *
+ * Sun source code is provided with no support and without any obligation on
+ * the part of Sun Microsystems, Inc. to assist in its use, correction,
+ * modification or enhancement.
+ *
+ * SUN MICROSYSTEMS, INC. SHALL HAVE NO LIABILITY WITH RESPECT TO THE
+ * INFRINGEMENT OF COPYRIGHTS, TRADE SECRETS OR ANY PATENTS BY THIS SOFTWARE
+ * OR ANY PART THEREOF.
+ *
+ * In no event will Sun Microsystems, Inc. be liable for any lost revenue
+ * or profits or other special, indirect and consequential damages, even if
+ * Sun has been advised of the possibility of such damages.
+ *
+ * Sun Microsystems, Inc.
+ * 2550 Garcia Avenue
+ * Mountain View, California  94043
+ */
+
+#include <sys/types.h>
+#include "law.h"
+
+/*
+ * g711.c
+ *
+ * u-law, A-law and linear PCM conversions.
+ */
+#define	SIGN_BIT	(0x80)		/* Sign bit for a A-law byte. */
+#define	QUANT_MASK	(0xf)		/* Quantization field mask. */
+#define	NSEGS		(8)		/* Number of A-law segments. */
+#define	SEG_SHIFT	(4)		/* Left shift for segment number. */
+#define	SEG_MASK	(0x70)		/* Segment field mask. */
+
+static short seg_aend[8] = {0x1F, 0x3F, 0x7F, 0xFF,
+			   0x1FF, 0x3FF, 0x7FF, 0xFFF};
+static short seg_uend[8] = {0x3F, 0x7F, 0xFF, 0x1FF,
+			   0x3FF, 0x7FF, 0xFFF, 0x1FFF};
+
+/* copy from CCITT G.711 specifications */
+u_int8_t _u2a[128] = {			/* u- to A-law conversions */
+	1,	1,	2,	2,	3,	3,	4,	4,
+	5,	5,	6,	6,	7,	7,	8,	8,
+	9,	10,	11,	12,	13,	14,	15,	16,
+	17,	18,	19,	20,	21,	22,	23,	24,
+	25,	27,	29,	31,	33,	34,	35,	36,
+	37,	38,	39,	40,	41,	42,	43,	44,
+	46,	48,	49,	50,	51,	52,	53,	54,
+	55,	56,	57,	58,	59,	60,	61,	62,
+	64,	65,	66,	67,	68,	69,	70,	71,
+	72,	73,	74,	75,	76,	77,	78,	79,
+	80,	82,	83,	84,	85,	86,	87,	88,
+	89,	90,	91,	92,	93,	94,	95,	96,
+	97,	98,	99,	100,	101,	102,	103,	104,
+	105,	106,	107,	108,	109,	110,	111,	112,
+	113,	114,	115,	116,	117,	118,	119,	120,
+	121,	122,	123,	124,	125,	126,	127,	128};
+
+u_int8_t _a2u[128] = {			/* A- to u-law conversions */
+	1,	3,	5,	7,	9,	11,	13,	15,
+	16,	17,	18,	19,	20,	21,	22,	23,
+	24,	25,	26,	27,	28,	29,	30,	31,
+	32,	32,	33,	33,	34,	34,	35,	35,
+	36,	37,	38,	39,	40,	41,	42,	43,
+	44,	45,	46,	47,	48,	48,	49,	49,
+	50,	51,	52,	53,	54,	55,	56,	57,
+	58,	59,	60,	61,	62,	63,	64,	64,
+	65,	66,	67,	68,	69,	70,	71,	72,
+	73,	74,	75,	76,	77,	78,	79,	80,
+	80,	81,	82,	83,	84,	85,	86,	87,
+	88,	89,	90,	91,	92,	93,	94,	95,
+	96,	97,	98,	99,	100,	101,	102,	103,
+	104,	105,	106,	107,	108,	109,	110,	111,
+	112,	113,	114,	115,	116,	117,	118,	119,
+	120,	121,	122,	123,	124,	125,	126,	127};
+
+static int
+search(int val, short *table, int size)
+{
+	int i;
+
+	for (i = 0; i < size; i++)
+		if (val <= *table++)
+			return (i);
+	return (size);
+}
+
+/*
+ * linear2alaw() - Convert a 16-bit linear PCM value to 8-bit A-law
+ *
+ * linear2alaw() accepts an 16-bit integer and encodes it as A-law data.
+ *
+ *		Linear Input Code	Compressed Code
+ *	------------------------	---------------
+ *	0000000wxyza			000wxyz
+ *	0000001wxyza			001wxyz
+ *	000001wxyzab			010wxyz
+ *	00001wxyzabc			011wxyz
+ *	0001wxyzabcd			100wxyz
+ *	001wxyzabcde			101wxyz
+ *	01wxyzabcdef			110wxyz
+ *	1wxyzabcdefg			111wxyz
+ *
+ * For further information see John C. Bellamy's Digital Telephony, 1982,
+ * John Wiley & Sons, pps 98-111 and 472-476.
+ */
+u_int8_t
+linear2alaw(int pcm_val)		/* 2's complement (16-bit range) */
+{
+	int		mask;
+	int		seg;
+	u_int8_t	aval;
+
+	pcm_val = pcm_val >> 3;
+
+	if (pcm_val >= 0) {
+		mask = 0xD5;		/* sign (7th) bit = 1 */
+	} else {
+		mask = 0x55;		/* sign bit = 0 */
+		pcm_val = -pcm_val - 1;
+	}
+
+	/* Convert the scaled magnitude to segment number. */
+	seg = search(pcm_val, seg_aend, 8);
+
+	/* Combine the sign, segment, and quantization bits. */
+
+	if (seg >= 8)		/* out of range, return maximum value. */
+		return (0x7F ^ mask);
+	else {
+		aval = seg << SEG_SHIFT;
+		if (seg < 2)
+			aval |= (pcm_val >> 4) & QUANT_MASK;
+		else
+			aval |= (pcm_val >> seg) & QUANT_MASK;
+		return (aval ^ mask);
+	}
+}
+
+/*
+ * alaw2linear() - Convert an A-law value to 16-bit linear PCM
+ *
+ */
+int
+alaw2linear(u_int8_t a_val)
+{
+	int		t;
+	int		seg;
+
+	a_val ^= 0x55;
+
+	t = (a_val & QUANT_MASK) << 4;
+	seg = ((unsigned)a_val & SEG_MASK) >> SEG_SHIFT;
+	switch (seg) {
+	case 0:
+		t += 8;
+		break;
+	case 1:
+		t += 0x108;
+		break;
+	default:
+		t += 0x108;
+		t <<= seg - 1;
+	}
+	return ((a_val & SIGN_BIT) ? t : -t);
+}
+
+#define	BIAS		(0x84)		/* Bias for linear code. */
+#define CLIP		8159
+
+/*
+ * linear2ulaw() - Convert a linear PCM value to u-law
+ *
+ * In order to simplify the encoding process, the original linear magnitude
+ * is biased by adding 33 which shifts the encoding range from (0 - 8158) to
+ * (33 - 8191). The result can be seen in the following encoding table:
+ *
+ *	Biased Linear Input Code	Compressed Code
+ *	------------------------	---------------
+ *	00000001wxyza			000wxyz
+ *	0000001wxyzab			001wxyz
+ *	000001wxyzabc			010wxyz
+ *	00001wxyzabcd			011wxyz
+ *	0001wxyzabcde			100wxyz
+ *	001wxyzabcdef			101wxyz
+ *	01wxyzabcdefg			110wxyz
+ *	1wxyzabcdefgh			111wxyz
+ *
+ * Each biased linear code has a leading 1 which identifies the segment
+ * number. The value of the segment number is equal to 7 minus the number
+ * of leading 0's. The quantization interval is directly available as the
+ * four bits wxyz.  * The trailing bits (a - h) are ignored.
+ *
+ * Ordinarily the complement of the resulting code word is used for
+ * transmission, and so the code word is complemented before it is returned.
+ *
+ * For further information see John C. Bellamy's Digital Telephony, 1982,
+ * John Wiley & Sons, pps 98-111 and 472-476.
+ */
+u_int8_t
+linear2ulaw(int pcm_val)	/* 2's complement (16-bit range) */
+{
+	int		mask;
+	int		seg;
+	u_int8_t	uval;
+
+	/* Get the sign and the magnitude of the value. */
+	pcm_val = pcm_val >> 2;
+	if (pcm_val < 0) {
+		pcm_val = -pcm_val;
+		mask = 0x7F;
+	} else {
+		mask = 0xFF;
+	}
+	if (pcm_val > CLIP)
+		pcm_val = CLIP;
+	pcm_val += (BIAS >> 2);
+
+	/* Convert the scaled magnitude to segment number. */
+	seg = search(pcm_val, seg_uend, 8);
+
+	/*
+	 * Combine the sign, segment, quantization bits;
+	 * and complement the code word.
+	 */
+	if (seg >= 8)		/* out of range, return maximum value. */
+		return (0x7F ^ mask);
+	else {
+		uval = (seg << 4) | ((pcm_val >> (seg + 1)) & 0xF);
+		return (uval ^ mask);
+	}
+
+}
+
+/*
+ * ulaw2linear() - Convert a u-law value to 16-bit linear PCM
+ *
+ * First, a biased linear code is derived from the code word. An unbiased
+ * output can then be obtained by subtracting 33 from the biased code.
+ *
+ * Note that this function expects to be passed the complement of the
+ * original code word. This is in keeping with ISDN conventions.
+ */
+int
+ulaw2linear(u_int8_t u_val)
+{
+	int		t;
+
+	/* Complement to obtain normal u-law value. */
+	u_val = ~u_val;
+
+	/*
+	 * Extract and bias the quantization bits. Then
+	 * shift up by the segment number and subtract out the bias.
+	 */
+	t = ((u_val & QUANT_MASK) << 3) + BIAS;
+	t <<= ((unsigned)u_val & SEG_MASK) >> SEG_SHIFT;
+
+	return ((u_val & SIGN_BIT) ? (BIAS - t) : (t - BIAS));
+}
+
+/* A-law to u-law conversion */
+u_int8_t
+alaw2ulaw(u_int8_t aval)
+{
+	aval &= 0xff;
+	return ((aval & 0x80) ? (0xFF ^ _a2u[aval ^ 0xD5]) :
+	    (0x7F ^ _a2u[aval ^ 0x55]));
+}
+
+/* u-law to A-law conversion */
+u_int8_t
+ulaw2alaw(u_int8_t uval)
+{
+	uval &= 0xff;
+	return ((uval & 0x80) ? (0xD5 ^ (_u2a[0xFF ^ uval] - 1)) :
+	    (0x55 ^ (_u2a[0x7F ^ uval] - 1)));
+}
diff --git a/regress/sys/dev/audio/law.h b/regress/sys/dev/audio/law.h
new file mode 100644
index 00000000000..cc4809e9a3e
--- /dev/null
+++ b/regress/sys/dev/audio/law.h
@@ -0,0 +1,38 @@
+/*	$OpenBSD: law.h,v 1.1 2003/02/01 17:58:18 jason Exp $	*/
+
+/*
+ * Copyright (c) 2003 Jason L. Wright (jason@thought.net)
+ * 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.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *	This product includes software developed by Jason L. Wright
+ * 4. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission.
+ *
+ * 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.
+ */
+u_int8_t linear2alaw(int);
+u_int8_t linear2ulaw(int);
+int alaw2linear(u_int8_t);
+int ulaw2linear(u_int8_t);
+u_int8_t alaw2ulaw(u_int8_t);
+u_int8_t ulaw2alaw(u_int8_t);