/*
   * aseqdump.c - show the events received at an ALSA sequencer port
   *
   * Copyright (c) 2005 Clemens Ladisch <clemens@ladisch.de>
   *
   *
   *  This program is free software; you can redistribute it and/or modify
   *  it under the terms of the GNU General Public License as published by
   *  the Free Software Foundation; either version 2 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 General Public License for more details.
   *
   *  You should have received a copy of the GNU General Public License
   *  along with this program; if not, write to the Free Software
   *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
   */
  
  #include <stdio.h>
  #include <stdlib.h>
  #include <stdarg.h>
  #include <string.h>
  #include <signal.h>
  #include <getopt.h>
  #include <sys/poll.h>
  #include <alsa/asoundlib.h>
  #include "aconfig.h"
  #include "version.h"
  
  static snd_seq_t *seq;
  static int port_count;
  static snd_seq_addr_t *ports;
  static volatile sig_atomic_t stop = 0;
  
  
  /* prints an error message to stderr, and dies */
  static void fatal(const char *msg, ...)
  {
  	va_list ap;
  
  	va_start(ap, msg);
  	vfprintf(stderr, msg, ap);
  	va_end(ap);
  	fputc('\n', stderr);
  	exit(EXIT_FAILURE);
  }
  
  /* memory allocation error handling */
  static void check_mem(void *p)
  {
  	if (!p)
  		fatal("Out of memory");
  }
  
  /* error handling for ALSA functions */
  static void check_snd(const char *operation, int err)
  {
  	if (err < 0)
  		fatal("Cannot %s - %s", operation, snd_strerror(err));
  }
  
  static void init_seq(void)
  {
  	int err;
  
  	/* open sequencer */
  	err = snd_seq_open(&seq, "default", SND_SEQ_OPEN_DUPLEX, 0);
  	check_snd("open sequencer", err);
  
  	/* set our client's name */
  	err = snd_seq_set_client_name(seq, "aseqdump");
  	check_snd("set client name", err);
  }
  
  /* parses one or more port addresses from the string */
  static void parse_ports(const char *arg)
  {
  	char *buf, *s, *port_name;
  	int err;
  
  	/* make a copy of the string because we're going to modify it */
  	buf = strdup(arg);
  	check_mem(buf);
  
  	for (port_name = s = buf; s; port_name = s + 1) {
  		/* Assume that ports are separated by commas.  We don't use
  		 * spaces because those are valid in client names. */
  		s = strchr(port_name, ',');
  		if (s)
  			*s = '\0';
  
  		++port_count;
  		ports = realloc(ports, port_count * sizeof(snd_seq_addr_t));
  		check_mem(ports);
  
  		err = snd_seq_parse_address(seq, &ports[port_count - 1], port_name);
  		if (err < 0)
  			fatal("Invalid port %s - %s", port_name, snd_strerror(err));
  	}
  
  	free(buf);
  }
  
  static void create_port(void)
  {
  	int err;
  
  	err = snd_seq_create_simple_port(seq, "aseqdump",
  					 SND_SEQ_PORT_CAP_WRITE |
  					 SND_SEQ_PORT_CAP_SUBS_WRITE,
  					 SND_SEQ_PORT_TYPE_MIDI_GENERIC |
  					 SND_SEQ_PORT_TYPE_APPLICATION);
  	check_snd("create port", err);
  }
  
  static void connect_ports(void)
  {
  	int i, err;
  
  	for (i = 0; i < port_count; ++i) {
  		err = snd_seq_connect_from(seq, 0, ports[i].client, ports[i].port);
  		if (err < 0)
  			fatal("Cannot connect from port %d:%d - %s",
  			      ports[i].client, ports[i].port, snd_strerror(err));
  	}
  }
  
  static void dump_event(const snd_seq_event_t *ev)
  {
    printf("%3d:%-3d ", ev->source.client, ev->source.port);// source = num du clavier qu'on met ds la ligne de commande; port num usb ? 
  	switch (ev->type) {
  	case SND_SEQ_EVENT_NOTEON:
  		if (ev->data.note.velocity)
  			printf("Note on                %2d, note %d, velocity %d\n",
  			       ev->data.note.channel, ev->data.note.note, ev->data.note.velocity);
  		else
  			printf("Note off               %2d, note %d\n",
  			       ev->data.note.channel, ev->data.note.note);
  		break;
  	case SND_SEQ_EVENT_NOTEOFF:
  		printf("Note off               %2d, note %d, velocity %d\n",
  		       ev->data.note.channel, ev->data.note.note, ev->data.note.velocity);
  		break;
  	case SND_SEQ_EVENT_KEYPRESS:
  		printf("Polyphonic aftertouch  %2d, note %d, value %d\n",
  		       ev->data.note.channel, ev->data.note.note, ev->data.note.velocity);
  		break;
  	case SND_SEQ_EVENT_CONTROLLER:
  		printf("Control change         %2d, controller %d, value %d\n",
  		       ev->data.control.channel, ev->data.control.param, ev->data.control.value);
  		break;
  	case SND_SEQ_EVENT_PGMCHANGE:
  		printf("Program change         %2d, program %d\n",
  		       ev->data.control.channel, ev->data.control.value);
  		break;
  	case SND_SEQ_EVENT_CHANPRESS:
  		printf("Channel aftertouch     %2d, value %d\n",
  		       ev->data.control.channel, ev->data.control.value);
  		break;
  	case SND_SEQ_EVENT_PITCHBEND:
  		printf("Pitch bend             %2d, value %d\n",
  		       ev->data.control.channel, ev->data.control.value);
  		break;
  	case SND_SEQ_EVENT_CONTROL14:
  		printf("Control change         %2d, controller %d, value %5d\n",
  		       ev->data.control.channel, ev->data.control.param, ev->data.control.value);
  		break;
  	case SND_SEQ_EVENT_NONREGPARAM:
  		printf("Non-reg. parameter     %2d, parameter %d, value %d\n",
  		       ev->data.control.channel, ev->data.control.param, ev->data.control.value);
  		break;
  	case SND_SEQ_EVENT_REGPARAM:
  		printf("Reg. parameter         %2d, parameter %d, value %d\n",
  		       ev->data.control.channel, ev->data.control.param, ev->data.control.value);
  		break;
  	case SND_SEQ_EVENT_SONGPOS:
  		printf("Song position pointer      value %d\n",
  		       ev->data.control.value);
  		break;
  	case SND_SEQ_EVENT_SONGSEL:
  		printf("Song select                value %d\n",
  		       ev->data.control.value);
  		break;
  	case SND_SEQ_EVENT_QFRAME:
  		printf("MTC quarter frame          %02xh\n",
  		       ev->data.control.value);
  		break;
  	case SND_SEQ_EVENT_TIMESIGN:
  		// XXX how is this encoded?
  		printf("SMF time signature         (%#010x)\n",
  		       ev->data.control.value);
  		break;
  	case SND_SEQ_EVENT_KEYSIGN:
  		// XXX how is this encoded?
  		printf("SMF key signature          (%#010x)\n",
  		       ev->data.control.value);
  		break;
  	case SND_SEQ_EVENT_START:
  		if (ev->source.client == SND_SEQ_CLIENT_SYSTEM &&
  		    ev->source.port == SND_SEQ_PORT_SYSTEM_TIMER)
  			printf("Queue start                queue %d\n",
  			       ev->data.queue.queue);
  		else
  			printf("Start\n");
  		break;
  	case SND_SEQ_EVENT_CONTINUE:
  		if (ev->source.client == SND_SEQ_CLIENT_SYSTEM &&
  		    ev->source.port == SND_SEQ_PORT_SYSTEM_TIMER)
  			printf("Queue continue             queue %d\n",
  			       ev->data.queue.queue);
  		else
  			printf("Continue\n");
  		break;
  	case SND_SEQ_EVENT_STOP:
  		if (ev->source.client == SND_SEQ_CLIENT_SYSTEM &&
  		    ev->source.port == SND_SEQ_PORT_SYSTEM_TIMER)
  			printf("Queue stop                 queue %d\n",
  			       ev->data.queue.queue);
  		else
  			printf("Stop\n");
  		break;
  	case SND_SEQ_EVENT_SETPOS_TICK:
  		printf("Set tick queue pos.        queue %d\n", ev->data.queue.queue);
  		break;
  	case SND_SEQ_EVENT_SETPOS_TIME:
  		printf("Set rt queue pos.          queue %d\n", ev->data.queue.queue);
  		break;
  	case SND_SEQ_EVENT_TEMPO:
  		printf("Set queue tempo            queue %d\n", ev->data.queue.queue);
  		break;
  	case SND_SEQ_EVENT_CLOCK:
  		printf("Clock\n");
  		break;
  	case SND_SEQ_EVENT_TICK:
  		printf("Tick\n");
  		break;
  	case SND_SEQ_EVENT_QUEUE_SKEW:
  		printf("Queue timer skew           queue %d\n", ev->data.queue.queue);
  		break;
  	case SND_SEQ_EVENT_TUNE_REQUEST:
  		printf("Tune request\n");
  		break;
  	case SND_SEQ_EVENT_RESET:
  		printf("Reset\n");
  		break;
  	case SND_SEQ_EVENT_SENSING:
  		printf("Active Sensing\n");
  		break;
  	case SND_SEQ_EVENT_CLIENT_START:
  		printf("Client start               client %d\n",
  		       ev->data.addr.client);
  		break;
  	case SND_SEQ_EVENT_CLIENT_EXIT:
  		printf("Client exit                client %d\n",
  		       ev->data.addr.client);
  		break;
  	case SND_SEQ_EVENT_CLIENT_CHANGE:
  		printf("Client changed             client %d\n",
  		       ev->data.addr.client);
  		break;
  	case SND_SEQ_EVENT_PORT_START:
  		printf("Port start                 %d:%d\n",
  		       ev->data.addr.client, ev->data.addr.port);
  		break;
  	case SND_SEQ_EVENT_PORT_EXIT:
  		printf("Port exit                  %d:%d\n",
  		       ev->data.addr.client, ev->data.addr.port);
  		break;
  	case SND_SEQ_EVENT_PORT_CHANGE:
  		printf("Port changed               %d:%d\n",
  		       ev->data.addr.client, ev->data.addr.port);
  		break;
  	case SND_SEQ_EVENT_PORT_SUBSCRIBED:
  		printf("Port subscribed            %d:%d -> %d:%d\n",
  		       ev->data.connect.sender.client, ev->data.connect.sender.port,
  		       ev->data.connect.dest.client, ev->data.connect.dest.port);
  		break;
  	case SND_SEQ_EVENT_PORT_UNSUBSCRIBED:
  		printf("Port unsubscribed          %d:%d -> %d:%d\n",
  		       ev->data.connect.sender.client, ev->data.connect.sender.port,
  		       ev->data.connect.dest.client, ev->data.connect.dest.port);
  		break;
  	case SND_SEQ_EVENT_SYSEX:
  		{
  			unsigned int i;
  			printf("System exclusive          ");
  			for (i = 0; i < ev->data.ext.len; ++i)
  				printf(" %02X", ((unsigned char*)ev->data.ext.ptr)[i]);
  			printf("\n");
  		}
  		break;
  	default:
  		printf("Event type %d\n",  ev->type);
  	}
  }
  
  static void list_ports(void)
  {
  	snd_seq_client_info_t *cinfo;
  	snd_seq_port_info_t *pinfo;
  
  	snd_seq_client_info_alloca(&cinfo);
  	snd_seq_port_info_alloca(&pinfo);
  
  	puts(" Port    Client name                      Port name");
  
  	snd_seq_client_info_set_client(cinfo, -1);
  	while (snd_seq_query_next_client(seq, cinfo) >= 0) {
  		int client = snd_seq_client_info_get_client(cinfo);
  
  		snd_seq_port_info_set_client(pinfo, client);
  		snd_seq_port_info_set_port(pinfo, -1);
  		while (snd_seq_query_next_port(seq, pinfo) >= 0) {
  			/* we need both READ and SUBS_READ */
  			if ((snd_seq_port_info_get_capability(pinfo)
  			     & (SND_SEQ_PORT_CAP_READ | SND_SEQ_PORT_CAP_SUBS_READ))
  			    != (SND_SEQ_PORT_CAP_READ | SND_SEQ_PORT_CAP_SUBS_READ))
  				continue;
  			printf("%3d:%-3d  %-32.32s %s\n",
  			       snd_seq_port_info_get_client(pinfo),
  			       snd_seq_port_info_get_port(pinfo),
  			       snd_seq_client_info_get_name(cinfo),
  			       snd_seq_port_info_get_name(pinfo));
  		}
  	}
  }
  
  static void help(const char *argv0)
  {
  	printf("Usage: %s [options]\n"
  		"\nAvailable options:\n"
  		"  -h,--help                  this help\n"
  		"  -V,--version               show version\n"
  		"  -l,--list                  list input ports\n"
  		"  -p,--port=client:port,...  source port(s)\n",
  		argv0);
  }
  
  static void version(void)
  {
  	puts("aseqdump version " SND_UTIL_VERSION_STR);
  }
  
  static void sighandler(int sig)
  {
  	stop = 1;
  }
  
  int main(int argc, char *argv[])
  {
  	static const char short_options[] = "hVlp:";
  	static const struct option long_options[] = {
  		{"help", 0, NULL, 'h'},
  		{"version", 0, NULL, 'V'},
  		{"list", 0, NULL, 'l'},
  		{"port", 1, NULL, 'p'},
  		{ }
  	};
  
  	int do_list = 0;
  	struct pollfd *pfds;
  	int npfds;
  	int c, err;
  
  	init_seq();
  	// Gere les options de la ligne de commande
  	while ((c = getopt_long(argc, argv, short_options,
  				long_options, NULL)) != -1) {
  		switch (c) {
  		case 'h':
  			help(argv[0]);
  			return 0;
  		case 'V':
  			version();
  			return 0;
  		case 'l':
  			do_list = 1;
  			break;
  		case 'p':
  		  parse_ports(optarg);//optarg = l'option
  			break;
  		default:
  			help(argv[0]);
  			return 1;
  		}
  	}
  	if (optind < argc) {
  		help(argv[0]);
  		return 1;
  	}
  
  	if (do_list) {
  		list_ports();
  		return 0;
  	}
  
  	create_port();
  	connect_ports();
  
  	err = snd_seq_nonblock(seq, 1);
  	check_snd("set nonblock mode", err);
  	
  	if (port_count > 0)
  		printf("Waiting for data.");
  	else
  		printf("Waiting for data at port %d:0.",
  		       snd_seq_client_id(seq));
  	printf(" Press Ctrl+C to end.\n");
  	printf("Source  Event                  Ch  Data\n");
  	
  	signal(SIGINT, sighandler);
  	signal(SIGTERM, sighandler);
  
  	npfds = snd_seq_poll_descriptors_count(seq, POLLIN);
  	pfds = alloca(sizeof(*pfds) * npfds);
  	for (;;) {
  		snd_seq_poll_descriptors(seq, pfds, npfds, POLLIN);
  		if (poll(pfds, npfds, -1) < 0)
  			break;
  		do {
  			snd_seq_event_t *event;
  			err = snd_seq_event_input(seq, &event);
  			if (err < 0)
  				break;
  			if (event)
  				dump_event(event);
  		} while (err > 0);
  		fflush(stdout);
  		if (stop)
  			break;
  	}
  
  	snd_seq_close(seq);
  	return 0;
  }