/*

 *  Sequencer Interface - middle-level routines

 *

 *  Copyright (c) 1999 by Takashi Iwai <tiwai@suse.de>

 *

 *

 *   This library is free software; you can redistribute it and/or modify

 *   it under the terms of the GNU Lesser General Public License as

 *   published by the Free Software Foundation; either version 2.1 of

 *   the License, or (at your option) any later version.

 *

 *   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 Lesser General Public License for more details.

 *

 *   You should have received a copy of the GNU Lesser General Public

 *   License along with this library; if not, write to the Free Software

 *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA

 *

 */

#include <stdio.h>

#include <stdlib.h>

#include <unistd.h>

#include <string.h>

#include <fcntl.h>

#include <ctype.h>

#include <sys/ioctl.h>

#include "seq_local.h"

/**

 * \brief queue controls - start/stop/continue

 * \param seq sequencer handle

 * \param q queue id to control

 * \param type event type

 * \param value event value

 * \param ev event instance

 *

 * This function sets up general queue control event and sends it.

 * To send at scheduled time, set the schedule in \a ev.

 * If \a ev is NULL, the event is composed locally and sent immediately

 * to the specified queue.  In any cases, you need to call #snd_seq_drain_output()

 * appropriately to feed the event.

 *

 * \sa snd_seq_alloc_queue()

 */

int snd_seq_control_queue(snd_seq_t *seq, int q, int type, int value, snd_seq_event_t *ev)

{

	snd_seq_event_t tmpev;

	if (ev == NULL) {

		snd_seq_ev_clear(&tmpev);

		ev = &tmpev;

		snd_seq_ev_set_direct(ev);

	}

	snd_seq_ev_set_queue_control(ev, type, q, value);

	return snd_seq_event_output(seq, ev);

}

/**

 * \brief create a port - simple version

 * \param seq sequencer handle

 * \param name the name of the port

 * \param caps capability bits

 * \param type type bits

 * \return the created port number or negative error code

 *

 * Creates a port with the given capability and type bits.

 *

 * \sa snd_seq_create_port(), snd_seq_delete_simple_port()

 */

int snd_seq_create_simple_port(snd_seq_t *seq, const char *name,

			       unsigned int caps, unsigned int type)

{

	snd_seq_port_info_t pinfo;

	int result;

	memset(&pinfo, 0, sizeof(pinfo));

	if (name)

		strncpy(pinfo.name, name, sizeof(pinfo.name) - 1);

	pinfo.capability = caps;

	pinfo.type = type;

	pinfo.midi_channels = 16;

	pinfo.midi_voices = 64; /* XXX */

	pinfo.synth_voices = 0; /* XXX */

	result = snd_seq_create_port(seq, &pinfo);

	if (result < 0)

		return result;

	else

		return pinfo.addr.port;

}

/**

 * \brief delete the port

 * \param seq sequencer handle

 * \param port port id

 * \return 0 on success or negative error code

 *

 * \sa snd_seq_delete_port(), snd_seq_create_simple_port()

 */

int snd_seq_delete_simple_port(snd_seq_t *seq, int port)

{

	return snd_seq_delete_port(seq, port);

}

/**

 * \brief simple subscription (w/o exclusive & time conversion)

 * \param seq sequencer handle

 * \param myport the port id as receiver

 * \param src_client sender client id

 * \param src_port sender port id

 * \return 0 on success or negative error code

 *

 * Connect from the given sender client:port to the given destination port in the

 * current client.

 *

 * \sa snd_seq_subscribe_port(), snd_seq_disconnect_from()

 */

int snd_seq_connect_from(snd_seq_t *seq, int myport, int src_client, int src_port)

{

	snd_seq_port_subscribe_t subs;

	memset(&subs, 0, sizeof(subs));

	subs.sender.client = src_client;

	subs.sender.port = src_port;

	/*subs.dest.client = seq->client;*/

	subs.dest.client = snd_seq_client_id(seq);

	subs.dest.port = myport;

	return snd_seq_subscribe_port(seq, &subs);

}

/**

 * \brief simple subscription (w/o exclusive & time conversion)

 * \param seq sequencer handle

 * \param myport the port id as sender

 * \param dest_client destination client id

 * \param dest_port destination port id

 * \return 0 on success or negative error code

 *

 * Connect from the given receiver port in the current client

 * to the given destination client:port.

 *

 * \sa snd_seq_subscribe_port(), snd_seq_disconnect_to()

 */

int snd_seq_connect_to(snd_seq_t *seq, int myport, int dest_client, int dest_port)

{

	snd_seq_port_subscribe_t subs;

	memset(&subs, 0, sizeof(subs));

	/*subs.sender.client = seq->client;*/

	subs.sender.client = snd_seq_client_id(seq);

	subs.sender.port = myport;

	subs.dest.client = dest_client;

	subs.dest.port = dest_port;

	return snd_seq_subscribe_port(seq, &subs);

}

/**

 * \brief simple disconnection

 * \param seq sequencer handle

 * \param myport the port id as receiver

 * \param src_client sender client id

 * \param src_port sender port id

 * \return 0 on success or negative error code

 *

 * Remove connection from the given sender client:port

 * to the given destination port in the current client.

 *

 * \sa snd_seq_unsubscribe_port(), snd_seq_connect_from()

 */

int snd_seq_disconnect_from(snd_seq_t *seq, int myport, int src_client, int src_port)

{

	snd_seq_port_subscribe_t subs;

	memset(&subs, 0, sizeof(subs));

	subs.sender.client = src_client;

	subs.sender.port = src_port;

	/*subs.dest.client = seq->client;*/

	subs.dest.client = snd_seq_client_id(seq);

	subs.dest.port = myport;

	return snd_seq_unsubscribe_port(seq, &subs);

}

/**

 * \brief simple disconnection

 * \param seq sequencer handle

 * \param myport the port id as sender

 * \param dest_client destination client id

 * \param dest_port destination port id

 * \return 0 on success or negative error code

 *

 * Remove connection from the given sender client:port

 * to the given destination port in the current client.

 *

 * \sa snd_seq_unsubscribe_port(), snd_seq_connect_to()

 */

int snd_seq_disconnect_to(snd_seq_t *seq, int myport, int dest_client, int dest_port)

{

	snd_seq_port_subscribe_t subs;

	memset(&subs, 0, sizeof(subs));

	/*subs.sender.client = seq->client;*/

	subs.sender.client = snd_seq_client_id(seq);

	subs.sender.port = myport;

	subs.dest.client = dest_client;

	subs.dest.port = dest_port;

	return snd_seq_unsubscribe_port(seq, &subs);

}

/*

 * set client information

 */

/**

 * \brief set client name

 * \param seq sequencer handle

 * \param name name string

 * \return 0 on success or negative error code

 *

 * \sa snd_seq_set_client_info()

 */

int snd_seq_set_client_name(snd_seq_t *seq, const char *name)

{

	snd_seq_client_info_t info;

	int err;

	if ((err = snd_seq_get_client_info(seq, &info)) < 0)

		return err;

	strncpy(info.name, name, sizeof(info.name) - 1);

	return snd_seq_set_client_info(seq, &info;;

}

/**

 * \brief add client event filter

 * \param seq sequencer handle

 * \param event_type event type to be added

 * \return 0 on success or negative error code

 *

 * \sa snd_seq_set_client_info()

 */

int snd_seq_set_client_event_filter(snd_seq_t *seq, int event_type)

{

	snd_seq_client_info_t info;

	int err;

	if ((err = snd_seq_get_client_info(seq, &info)) < 0)

		return err;

	snd_seq_client_info_event_filter_add(&info, event_type);

	return snd_seq_set_client_info(seq, &info;;

}

/**

 * \brief change the output pool size of the given client

 * \param seq sequencer handle

 * \param size output pool size

 * \return 0 on success or negative error code

 *

 * \sa snd_seq_set_client_pool()

 */

int snd_seq_set_client_pool_output(snd_seq_t *seq, size_t size)

{

	snd_seq_client_pool_t info;

	int err;

	if ((err = snd_seq_get_client_pool(seq, &info)) < 0)

		return err;

	info.output_pool = size;

	return snd_seq_set_client_pool(seq, &info;;

}

/**

 * \brief change the output room size of the given client

 * \param seq sequencer handle

 * \param size output room size

 * \return 0 on success or negative error code

 *

 * \sa snd_seq_set_client_pool()

 */

int snd_seq_set_client_pool_output_room(snd_seq_t *seq, size_t size)

{

	snd_seq_client_pool_t info;

	int err;

	if ((err = snd_seq_get_client_pool(seq, &info)) < 0)

		return err;

	info.output_room = size;

	return snd_seq_set_client_pool(seq, &info;;

}

/**

 * \brief change the input pool size of the given client

 * \param seq sequencer handle

 * \param size input pool size

 * \return 0 on success or negative error code

 *

 * \sa snd_seq_set_client_pool()

 */

int snd_seq_set_client_pool_input(snd_seq_t *seq, size_t size)

{

	snd_seq_client_pool_t info;

	int err;

	if ((err = snd_seq_get_client_pool(seq, &info)) < 0)

		return err;

	info.input_pool = size;

	return snd_seq_set_client_pool(seq, &info;;

}

/**

 * \brief reset client output pool

 * \param seq sequencer handle

 * \return 0 on success or negative error code

 *

 * So far, this works identically like #snd_seq_drop_output().

 */

int snd_seq_reset_pool_output(snd_seq_t *seq)

{

	return snd_seq_drop_output(seq);

}

/**

 * \brief reset client input pool

 * \param seq sequencer handle

 * \return 0 on success or negative error code

 *

 * So far, this works identically like #snd_seq_drop_input().

 */

int snd_seq_reset_pool_input(snd_seq_t *seq)

{

	return snd_seq_drop_input(seq);

}

/**

 * \brief wait until all events are processed

 * \param seq sequencer handle

 * \return 0 on success or negative error code

 *

 * This function waits until all events of this client are processed.

 *

 * \sa snd_seq_drain_output()

 */

int snd_seq_sync_output_queue(snd_seq_t *seq)

{

	int err;

	snd_seq_client_pool_t info;

	int saved_room;

	struct pollfd pfd;

	assert(seq);

	/* reprogram the room size to full */

	if ((err = snd_seq_get_client_pool(seq, &info)) < 0)

		return err;

	saved_room = info.output_room;

	info.output_room = info.output_pool; /* wait until all gone */

	if ((err = snd_seq_set_client_pool(seq, &info)) < 0)

		return err;

	/* wait until all events are purged */

	pfd.fd = seq->poll_fd;

	pfd.events = POLLOUT;

	err = poll(&pfd, 1, -1);

	/* restore the room size */ 

	info.output_room = saved_room;

	snd_seq_set_client_pool(seq, &info;;

	return err;

}

/**

 * \brief parse the given string and get the sequencer address

 * \param seq sequencer handle

 * \param addr the address pointer to be returned

 * \param arg the string to be parsed

 * \return 0 on success or negative error code

 *

 * This function parses the sequencer client and port numbers from the given string.

 * The client and port tokens are separated by either colon or period, e.g. 128:1.

 * When \a seq is not NULL, the function accepts also a client name not only

 * digit numbers.

 * Actually \a arg need to be only a prefix of the wanted client.

 * That is, if a client named "Foobar XXL Master 2012" with number 128 is available,

 * then parsing "Foobar" will return the address 128:0 if no other client is

 * an exact match.

 */

int snd_seq_parse_address(snd_seq_t *seq, snd_seq_addr_t *addr, const char *arg)

{

	char *p;

	int client, port;

	int len;

	assert(addr && arg);

	if ((p = strpbrk(arg, ":.")) != NULL) {

		if ((port = atoi(p + 1)) < 0)

			return -EINVAL;

		len = (int)(p - arg); /* length of client name */

	} else {

		port = 0;

		len = strlen(arg);

	}

	addr->port = port;

	if (isdigit(*arg)) {

		client = atoi(arg);

		if (client < 0)

			return -EINVAL;

		addr->client = client;

	} else {

		/* convert from the name */

		snd_seq_client_info_t cinfo;

		if (! seq)

			return -EINVAL;

		if (len <= 0)

			return -EINVAL;

		client = -1;

		cinfo.client = -1;

		while (snd_seq_query_next_client(seq, &cinfo) >= 0) {

			if (!strncmp(arg, cinfo.name, len)) {

				if (strlen(cinfo.name) == (size_t)len) {

					/* exact match */

					addr->client = cinfo.client;

					return 0;

				}

				if (client < 0)

					client = cinfo.client;

			}

		}

		if (client >= 0) {

			/* prefix match */

			addr->client = client;

			return 0;

		}

		return -ENOENT; /* not found */

	}

	return 0;

}