/*
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation. See the file COPYING
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * Copyright (C) 2017 Frank van Maarseveen <frankvm@frankvm.com>
 */

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
#include <netdb.h>
#include <sys/socket.h>
#include <sys/select.h>
#include <sys/resource.h>
#include <sys/uio.h>
#include "common.h"
#include "alsa.h"

#define SEQWIN			80			// gracefully handle UDP broadcast buffer games (empirically determined)

/*
 * UDP audio packets consists of
 * -	16 byte header
 * -	1400 byte audio data, optional.
 *
 * Audio data must be provided with 48kHz frame rate effectively. Absence of
 * audio data will put the audio device on pause without draining the queues.
 */
struct play_hdr {							// 16 bytes
	char			magic[3];				// "AU"
	uint8_t			srcid;
	uint16_t		vol[PLAY_NVOL];
	uint32_t		seq;
};

static int			prio;
static int			port = 13012;
static int			volid;
static uint32_t			lastseq;
static const char		silence[PLAY_CHUNKBYTES];
static const char *		device = "hw:CODEC";
static struct play_param	param;

static const char		usage[] =
	"Usage: %s [<option>...]\n"
	"\n"
	"Options are:\n"
	"    -h		Show command usage.\n"
	"    -p<port>	UDP Port to listen on (default 13012)\n"
	"    -v		Be more verbose (for debugging)\n"
	"    -P<prio>	Set process priority, see setpriority()\n"
	"    -D<device>	Specify audio device. Default is \"hw:CODEC\". See /proc/asound/cards\n"
	"    		for actual names and prefix them with \"hw:\"\n"
	"    -V<volume>	Specify volume control name. Default is \"PCM\". See the -v option\n"
	"    		output if this doesn't work out.\n"
	"    -b<frames>	Buffer size in frames. Default is 24000 (0.5s).\n"
	"    -s<vol#>	Select UDP volume control channel.\n"
	"\n"
	"The -D and -V options default to what's suitable for a Behringer UCA202 USB\n"
	"audio device which has initially been used for testing. The HiFiBerry DAC+ pro\n"
	"requires \"-Dhw:sndrpihifiberry -VDigital\" for example.\n"
	"\n";

static void options(int argc, char **argv)
{
	int opt;

	prio = getpriority(PRIO_PROCESS, 0);
	param.volume = "PCM";
	param.bufferframes = PLAY_RATE / 2;
	if (prio == -1)
		die("getpriority: %s\n", strerror(errno));
	while ((opt = getopt(argc, argv, "hp:vP:D:V:b:s:")) != -1) {
		switch (opt) {
		default:
			die("Use -h for help\n");
		case 'h':
			printf(usage, me);
			exit(0);
		case 'p':
			port = atoi(optarg);
			break;
		case 'v':
			++opt_v;
			break;
		case 'P':
			prio = atoi(optarg);
			break;
		case 'D':
			device = optarg;
			break;
		case 'V':
			param.volume = optarg;
			break;
		case 'b':
			param.bufferframes = atoi(optarg);
			break;
		case 's':
			if (sscanf(optarg, "%d", &volid) != 1 || volid < 0 || volid >= PLAY_NVOL)
				die("-s: must be in range 0..%d\n", PLAY_NVOL - 1);
			break;
		}
	}
	if (optind < argc)
		die("too many arguments (%s).\n", argv[optind]);
}

static int play_inputfd(void)
{
	char service[40];
	struct addrinfo hints, *res, *p;
	int err, s;

	snprintf(service, sizeof (service), "%d", port);
	memset(&hints, 0, sizeof (hints));
	hints.ai_family = AF_INET;
	hints.ai_socktype = SOCK_DGRAM;
	hints.ai_flags = AI_PASSIVE;
	err = getaddrinfo(NULL, service, &hints, &res);
	if (err)
		die("getaddrinfo: %s\n", gai_strerror(err));
	for (p = res; p; p = p->ai_next) {
		s = socket(p->ai_family, p->ai_socktype, p->ai_protocol);
		if (s != -1) {
			if (bind(s, p->ai_addr, p->ai_addrlen) == 0)
				break;
			close(s);
		}
	}
	if (!p)
		die("UDP bind: %s\n", strerror(errno));
	freeaddrinfo(res);
	return s;
}

static void play_read(int fd)
{
	char buf[PLAY_CHUNKBYTES + PLAY_FRAMESIZE];
	struct iovec iov[2];
	struct play_hdr hdr;
	int32_t deltaseq;
	int n;

	iov[0].iov_base = &hdr;
	iov[0].iov_len = sizeof (hdr);
	iov[1].iov_base = buf;
	iov[1].iov_len = sizeof (buf);
	n = readv(fd, iov, ARRAYSIZE(iov));
	if ((n != sizeof (hdr) && n != sizeof (hdr) + PLAY_CHUNKBYTES) || strcmp(hdr.magic, "AU")) {
		err("!");
		return;
	}
	deltaseq = hdr.seq - lastseq;
	if (deltaseq > -SEQWIN && deltaseq <= 0) {		// ignore stuff from the recent past (duplicates or previously stalled)
		out("delta %ld, dropped\n", (long)deltaseq);
		return;
	}
	if (deltaseq < 0 || deltaseq > SEQWIN) {
		out("%ld lost, resynchronizing.\n", (long)deltaseq - 1);
		alsa_resync();
		deltaseq = 1;
	}
	alsa_volume(hdr.vol[volid]);
	if (n == sizeof (hdr)) {
		alsa_suspend();
	} else {
		alsa_resume();
		if (deltaseq > 1)
			out("%ld lost\n", (long)deltaseq - 1);
		while (deltaseq > 1) {
			alsa_write(silence, PLAY_CHUNKSIZE);
			--deltaseq;
		}
		n = alsa_syncadj();
		if (n > 0)
			memcpy(buf + PLAY_CHUNKBYTES, buf + PLAY_CHUNKBYTES - PLAY_FRAMESIZE, PLAY_FRAMESIZE);
		alsa_write(buf, PLAY_CHUNKSIZE + n);
	}
	lastseq = hdr.seq;
}

static void play_loop(void)
{
	struct timeval tv;
	fd_set ifd;
	int s, n, maxfd;

	s = play_inputfd();
	while (1) {
		tv.tv_sec = 1;
		tv.tv_usec = 0;
		FD_ZERO(&ifd);
		maxfd = -1;
		FD_SET(s, &ifd);
		if (maxfd < s)
			maxfd = s;
		n = select(maxfd + 1, &ifd, NULL, NULL, &tv);
		if (n == -1)
			die("select: %s\n", strerror(errno));
		if (!n) {
			alsa_volume(0);	// (try to) avoid static upon USB disconnect/reboot
			continue;
		}
		if (FD_ISSET(s, &ifd))
			play_read(s);
	}
}

int main(int argc, char **argv)
{
	me = "snd-udpplay";
	options(argc, argv);
	if (setpriority(PRIO_PROCESS, 0, prio) == -1)
		die("setpriority: %s\n", strerror(errno));
	alsa_open(device, &param);
	play_loop();
}