/*-
 * Copyright (c) 2015-2019 Hans Petter Selasky
 *
 * 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 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 AUTHOR 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/queue.h>
#include <sys/filio.h>
#include <sys/soundcard.h>

#include <stdint.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#include <unistd.h>
#include <err.h>
#include <poll.h>

#include "backend.h"
#include "int.h"

static int
oss_set_format(int fd, int *format)
{
	int value[6];
	int error;
	int fmt;
	int i;

	value[0] = *format & VPREFERRED_SNE_AFMT;
	value[1] = *format & VPREFERRED_UNE_AFMT;
	value[2] = *format & VPREFERRED_SLE_AFMT;
	value[3] = *format & VPREFERRED_SBE_AFMT;
	value[4] = *format & VPREFERRED_ULE_AFMT;
	value[5] = *format & VPREFERRED_UBE_AFMT;

	for (i = 0; i != 6; i++) {
		fmt = value[i];
		if (fmt == 0)
			continue;
		error = ioctl(fd, SNDCTL_DSP_SETFMT, &fmt);
		/* make sure we got the format we asked for */
		if (error == 0 && fmt == value[i]) {
			*format = fmt;
			return (0);
		}
	}
	return (-1);
}

static void
oss_close(struct voss_backend *pbe)
{
	if (pbe->fd > -1) {
		close(pbe->fd);
		pbe->fd = -1;
	}
}

static int
oss_open(struct voss_backend *pbe, const char *devname, int samplerate,
    int bufsize, int *pchannels, int *pformat, int attr, int fionbio)
{
	int temp;
	int err;

	pbe->fd = open(devname, attr);
	if (pbe->fd < 0) {
		warn("Could not open DSP device '%s'", devname);
		return (-1);
	}
	err = ioctl(pbe->fd, FIONBIO, &fionbio);
	if (err < 0) {
		warn("Could not set blocking mode on DSP");
		goto error;
	}
	err = oss_set_format(pbe->fd, pformat);
	if (err < 0) {
		warn("Could not set sample format 0x%08x", *pformat);
		goto error;
	}
	temp = *pchannels;
	bufsize /= temp;	/* get buffer size per channel */
	do {
		err = ioctl(pbe->fd, SOUND_PCM_WRITE_CHANNELS, &temp);
	} while (err < 0 && --temp > 0);

	err = ioctl(pbe->fd, SOUND_PCM_READ_CHANNELS, &temp);
	if (err < 0 || temp <= 0 || temp > *pchannels) {
		warn("Could not set DSP channels: %d / %d", temp, *pchannels);
		goto error;
	}
	*pchannels = temp;

	temp = samplerate;
	err = ioctl(pbe->fd, SNDCTL_DSP_SPEED, &temp);
	if (err < 0 || temp != samplerate) {
		warn("Could not set sample rate to %d / %d Hz", temp, samplerate);
		goto error;
	}

	temp = bufsize * (*pchannels);
	err = ioctl(pbe->fd, SNDCTL_DSP_SETBLKSIZE, &temp);
	if (err < 0) {
		warn("Could not set block size to %d", temp);
		goto error;
	}
	return (0);
error:
	close(pbe->fd);
	pbe->fd = -1;
	return (-1);
}

static int
oss_rec_open(struct voss_backend *pbe, const char *devname, int samplerate,
    int bufsize, int *pchannels, int *pformat)
{
	return (oss_open(pbe, devname, samplerate, bufsize, pchannels, pformat, O_RDONLY, 0));
}

static int
oss_play_open(struct voss_backend *pbe, const char *devname, int samplerate,
    int bufsize, int *pchannels, int *pformat)
{
	bufsize *= 4;	/* XXX allow extra space for jitter */
	return (oss_open(pbe, devname, samplerate, bufsize, pchannels, pformat, O_WRONLY, 0));
}

static int
oss_rec_transfer(struct voss_backend *pbe, void *ptr, int len)
{
	struct pollfd fds = { .fd = pbe->fd, .events = POLLIN | POLLRDNORM };
	int err;

	/* wait at maximum 2 seconds for data, else something is wrong */
	err = poll(&fds, 1, 2000);
	if (err < 1)
		return (-1);
	return (read(pbe->fd, ptr, len));
}

static int
oss_play_transfer(struct voss_backend *pbe, void *ptr, int len)
{
	return (write(pbe->fd, ptr, len));
}

static void
oss_rec_delay(struct voss_backend *pbe, int *pdelay)
{
	if (ioctl(pbe->fd, FIONREAD, pdelay) != 0)
		*pdelay = -1;
}

static void
oss_play_delay(struct voss_backend *pbe, int *pdelay)
{
	if (voss_has_synchronization != 0 ||
	    ioctl(pbe->fd, SNDCTL_DSP_GETODELAY, pdelay) != 0)
		*pdelay = -1;
}

struct voss_backend voss_backend_oss_rec = {
	.open = oss_rec_open,
	.close = oss_close,
	.transfer = oss_rec_transfer,
	.delay = oss_rec_delay,
	.fd = -1,
};

struct voss_backend voss_backend_oss_play = {
	.open = oss_play_open,
	.close = oss_close,
	.transfer = oss_play_transfer,
	.delay = oss_play_delay,
	.fd = -1,
};