NetBSD/sys/dev/audio/audiobell.c

/*	$NetBSD: audiobell.c,v 1.5 2021/07/21 06:35:44 skrll Exp $	*/

/*
 * Copyright (c) 1999 Richard Earnshaw
 * Copyright (c) 2004 Ben Harris
 *
 * 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 the RiscBSD team.
 * 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/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: audiobell.c,v 1.5 2021/07/21 06:35:44 skrll Exp $");

#include <sys/param.h>
#include <sys/types.h>
#include <sys/audioio.h>
#include <sys/conf.h>
#include <sys/device.h>
#include <sys/malloc.h>
#include <sys/systm.h>
#include <sys/uio.h>

#include <dev/audio/audio_if.h>
#include <dev/audio/audiovar.h>
#include <dev/audio/audiodef.h>
#include <dev/audio/audiobellvar.h>

/*
 * The hexadecagon is sufficiently close to a sine wave.
 * Audiobell always outputs this 16 points data but changes its playback
 * frequency.  In addition, audio layer does linear interpolation in the
 * frequency conversion stage, so the waveform becomes smooth.
 * When the playback frequency rises (or the device frequency is not enough
 * high) and one wave cannot be expressed with 16 points, the data is thinned
 * out by power of two, like 8 points -> 4 points (triangular wave)
 * -> 2 points (rectangular wave).
 */

/* Amplitude.  Full scale amplitude is too loud. */
#define A(x) ((x) * 0.6)

/* (sin(2*pi * (x/16)) * 32767 / 100) << 16 */
static const int32_t sinewave[] = {
	A(        0),
	A(  8217813),
	A( 15184539),
	A( 19839556),
	A( 21474181),
	A( 19839556),
	A( 15184539),
	A(  8217813),
	A(        0),
	A( -8217814),
	A(-15184540),
	A(-19839557),
	A(-21474182),
	A(-19839557),
	A(-15184540),
	A( -8217814),
};
#undef A

/*
 * The minimum and the maximum buffer sizes must be a multiple of 32
 * (32 = countof(sinewave) * sizeof(uint16_t)).
 */
#define MINBUFSIZE	(1024)
#define MAXBUFSIZE	(4096)

/*
 * dev is a device_t for the audio device to use.
 * pitch is the pitch of the bell in Hz,
 * period is the length in ms,
 * volume is the amplitude in % of max,
 * poll is no longer used.
 */
void
audiobell(void *dev, u_int pitch, u_int period, u_int volume, int poll)
{
	dev_t audio;
	int16_t *buf;
	audio_file_t *file;
	audio_track_t *ptrack;
	struct uio auio;
	struct iovec aiov;
	u_int i;
	u_int j;
	u_int remaincount;
	u_int remainbytes;
	u_int wave1count;
	u_int wave1bytes;
	u_int bufbytes;
	u_int len;
	u_int step;
	u_int offset;
	u_int play_sample_rate;
	u_int mixer_sample_rate;

	KASSERT(volume <= 100);

	/* Playing for 0msec does nothing. */
	if (period == 0)
		return;

	/* The audio system isn't built for polling. */
	if (poll)
		return;

	buf = NULL;
	audio = AUDIO_DEVICE | device_unit((device_t)dev);

	/* If not configured, we can't beep. */
	if (audiobellopen(audio, &file) != 0)
		return;

	ptrack = file->ptrack;
	mixer_sample_rate = ptrack->mixer->track_fmt.sample_rate;

	/* Limit pitch */
	if (pitch < 20)
		pitch = 20;

	offset = 0;
	if (pitch <= mixer_sample_rate / 16) {
		/* 16-point sine wave */
		step = 1;
	} else if (pitch <= mixer_sample_rate / 8) {
		/* 8-point sine wave */
		step = 2;
	} else if (pitch <= mixer_sample_rate / 4) {
		/* 4-point sine wave, aka, triangular wave */
		step = 4;
	} else {
		/* Rectangular wave */
		if (pitch > mixer_sample_rate / 2)
			pitch = mixer_sample_rate / 2;
		step = 8;
		offset = 4;
	}

	wave1count = __arraycount(sinewave) / step;
	play_sample_rate = pitch * wave1count;
	audiobellsetrate(file, play_sample_rate);

	/* msec to sample count */
	remaincount = play_sample_rate * period / 1000;
	/* Roundup to full wave */
	remaincount = roundup(remaincount, wave1count);
	remainbytes = remaincount * sizeof(int16_t);
	wave1bytes = wave1count * sizeof(int16_t);

	/* Based on 3*usrbuf_blksize, but not too small or too large */
	bufbytes = ptrack->usrbuf_blksize * NBLKHW;
	if (bufbytes < MINBUFSIZE)
		bufbytes = MINBUFSIZE;
	else if (bufbytes > MAXBUFSIZE)
		bufbytes = MAXBUFSIZE;
	else
		bufbytes = roundup(bufbytes, wave1bytes);
	bufbytes = uimin(bufbytes, remainbytes);
	KASSERT(bufbytes != 0);
	buf = malloc(bufbytes, M_TEMP, M_WAITOK);
	if (buf == NULL)
		goto out;

	/* Generate sinewave with specified volume */
	j = offset;
	for (i = 0; i < bufbytes / sizeof(int16_t); i++) {
		/* XXX audio already has track volume feature though #if 0 */
		buf[i] = AUDIO_SCALEDOWN(sinewave[j] * (int)volume, 16);
		j += step;
		j %= __arraycount(sinewave);
	}

	/* Write while paused to avoid inserting silence. */
	ptrack->is_pause = true;
	for (; remainbytes > 0; remainbytes -= len) {
		len = uimin(remainbytes, bufbytes);
		aiov.iov_base = (void *)buf;
		aiov.iov_len = len;
		auio.uio_iov = &aiov;
		auio.uio_iovcnt = 1;
		auio.uio_offset = 0;
		auio.uio_resid = len;
		auio.uio_rw = UIO_WRITE;
		UIO_SETUP_SYSSPACE(&auio);
		if (audiobellwrite(file, &auio) != 0)
			goto out;

		if (ptrack->usrbuf.used >= ptrack->usrbuf_blksize * NBLKHW)
			ptrack->is_pause = false;
	}
	/* Here we go! */
	ptrack->is_pause = false;
out:
	if (buf != NULL)
		free(buf, M_TEMP);
	audiobellclose(file);
}