1 /*
2 * aseqdump.c - show the events received at an ALSA sequencer port
3 *
4 * Copyright (c) 2005 Clemens Ladisch <clemens@ladisch.de>
5 *
6 *
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
11 *
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20 */
21
22 #include <stdio.h>
23 #include <stdlib.h>
24 #include <stdarg.h>
25 #include <string.h>
26 #include <signal.h>
27 #include <getopt.h>
28 #include <poll.h>
29 #include <alsa/asoundlib.h>
30 #include "aconfig.h"
31 #include "version.h"
32
33 static snd_seq_t *seq;
34 static int port_count;
35 static snd_seq_addr_t *ports;
36 static volatile sig_atomic_t stop = 0;
37
38
39 /* prints an error message to stderr, and dies */
fatal(const char * msg,...)40 static void fatal(const char *msg, ...)
41 {
42 va_list ap;
43
44 va_start(ap, msg);
45 vfprintf(stderr, msg, ap);
46 va_end(ap);
47 fputc('\n', stderr);
48 exit(EXIT_FAILURE);
49 }
50
51 /* memory allocation error handling */
check_mem(void * p)52 static void check_mem(void *p)
53 {
54 if (!p)
55 fatal("Out of memory");
56 }
57
58 /* error handling for ALSA functions */
check_snd(const char * operation,int err)59 static void check_snd(const char *operation, int err)
60 {
61 if (err < 0)
62 fatal("Cannot %s - %s", operation, snd_strerror(err));
63 }
64
init_seq(void)65 static void init_seq(void)
66 {
67 int err;
68
69 /* open sequencer */
70 err = snd_seq_open(&seq, "default", SND_SEQ_OPEN_DUPLEX, 0);
71 check_snd("open sequencer", err);
72
73 /* set our client's name */
74 err = snd_seq_set_client_name(seq, "aseqdump");
75 check_snd("set client name", err);
76 }
77
78 /* parses one or more port addresses from the string */
parse_ports(const char * arg)79 static void parse_ports(const char *arg)
80 {
81 char *buf, *s, *port_name;
82 int err;
83
84 /* make a copy of the string because we're going to modify it */
85 buf = strdup(arg);
86 check_mem(buf);
87
88 for (port_name = s = buf; s; port_name = s + 1) {
89 /* Assume that ports are separated by commas. We don't use
90 * spaces because those are valid in client names. */
91 s = strchr(port_name, ',');
92 if (s)
93 *s = '\0';
94
95 ++port_count;
96 ports = realloc(ports, port_count * sizeof(snd_seq_addr_t));
97 check_mem(ports);
98
99 err = snd_seq_parse_address(seq, &ports[port_count - 1], port_name);
100 if (err < 0)
101 fatal("Invalid port %s - %s", port_name, snd_strerror(err));
102 }
103
104 free(buf);
105 }
106
create_port(void)107 static void create_port(void)
108 {
109 int err;
110
111 err = snd_seq_create_simple_port(seq, "aseqdump",
112 SND_SEQ_PORT_CAP_WRITE |
113 SND_SEQ_PORT_CAP_SUBS_WRITE,
114 SND_SEQ_PORT_TYPE_MIDI_GENERIC |
115 SND_SEQ_PORT_TYPE_APPLICATION);
116 check_snd("create port", err);
117 }
118
connect_ports(void)119 static void connect_ports(void)
120 {
121 int i, err;
122
123 for (i = 0; i < port_count; ++i) {
124 err = snd_seq_connect_from(seq, 0, ports[i].client, ports[i].port);
125 if (err < 0)
126 fatal("Cannot connect from port %d:%d - %s",
127 ports[i].client, ports[i].port, snd_strerror(err));
128 }
129 }
130
dump_event(const snd_seq_event_t * ev)131 static void dump_event(const snd_seq_event_t *ev)
132 {
133 printf("%3d:%-3d ", ev->source.client, ev->source.port);
134 switch (ev->type) {
135 case SND_SEQ_EVENT_NOTEON:
136 if (ev->data.note.velocity)
137 printf("Note on %2d, note %d, velocity %d\n",
138 ev->data.note.channel, ev->data.note.note, ev->data.note.velocity);
139 else
140 printf("Note off %2d, note %d\n",
141 ev->data.note.channel, ev->data.note.note);
142 break;
143 case SND_SEQ_EVENT_NOTEOFF:
144 printf("Note off %2d, note %d, velocity %d\n",
145 ev->data.note.channel, ev->data.note.note, ev->data.note.velocity);
146 break;
147 case SND_SEQ_EVENT_KEYPRESS:
148 printf("Polyphonic aftertouch %2d, note %d, value %d\n",
149 ev->data.note.channel, ev->data.note.note, ev->data.note.velocity);
150 break;
151 case SND_SEQ_EVENT_CONTROLLER:
152 printf("Control change %2d, controller %d, value %d\n",
153 ev->data.control.channel, ev->data.control.param, ev->data.control.value);
154 break;
155 case SND_SEQ_EVENT_PGMCHANGE:
156 printf("Program change %2d, program %d\n",
157 ev->data.control.channel, ev->data.control.value);
158 break;
159 case SND_SEQ_EVENT_CHANPRESS:
160 printf("Channel aftertouch %2d, value %d\n",
161 ev->data.control.channel, ev->data.control.value);
162 break;
163 case SND_SEQ_EVENT_PITCHBEND:
164 printf("Pitch bend %2d, value %d\n",
165 ev->data.control.channel, ev->data.control.value);
166 break;
167 case SND_SEQ_EVENT_CONTROL14:
168 printf("Control change %2d, controller %d, value %5d\n",
169 ev->data.control.channel, ev->data.control.param, ev->data.control.value);
170 break;
171 case SND_SEQ_EVENT_NONREGPARAM:
172 printf("Non-reg. parameter %2d, parameter %d, value %d\n",
173 ev->data.control.channel, ev->data.control.param, ev->data.control.value);
174 break;
175 case SND_SEQ_EVENT_REGPARAM:
176 printf("Reg. parameter %2d, parameter %d, value %d\n",
177 ev->data.control.channel, ev->data.control.param, ev->data.control.value);
178 break;
179 case SND_SEQ_EVENT_SONGPOS:
180 printf("Song position pointer value %d\n",
181 ev->data.control.value);
182 break;
183 case SND_SEQ_EVENT_SONGSEL:
184 printf("Song select value %d\n",
185 ev->data.control.value);
186 break;
187 case SND_SEQ_EVENT_QFRAME:
188 printf("MTC quarter frame %02xh\n",
189 ev->data.control.value);
190 break;
191 case SND_SEQ_EVENT_TIMESIGN:
192 // XXX how is this encoded?
193 printf("SMF time signature (%#010x)\n",
194 ev->data.control.value);
195 break;
196 case SND_SEQ_EVENT_KEYSIGN:
197 // XXX how is this encoded?
198 printf("SMF key signature (%#010x)\n",
199 ev->data.control.value);
200 break;
201 case SND_SEQ_EVENT_START:
202 if (ev->source.client == SND_SEQ_CLIENT_SYSTEM &&
203 ev->source.port == SND_SEQ_PORT_SYSTEM_TIMER)
204 printf("Queue start queue %d\n",
205 ev->data.queue.queue);
206 else
207 printf("Start\n");
208 break;
209 case SND_SEQ_EVENT_CONTINUE:
210 if (ev->source.client == SND_SEQ_CLIENT_SYSTEM &&
211 ev->source.port == SND_SEQ_PORT_SYSTEM_TIMER)
212 printf("Queue continue queue %d\n",
213 ev->data.queue.queue);
214 else
215 printf("Continue\n");
216 break;
217 case SND_SEQ_EVENT_STOP:
218 if (ev->source.client == SND_SEQ_CLIENT_SYSTEM &&
219 ev->source.port == SND_SEQ_PORT_SYSTEM_TIMER)
220 printf("Queue stop queue %d\n",
221 ev->data.queue.queue);
222 else
223 printf("Stop\n");
224 break;
225 case SND_SEQ_EVENT_SETPOS_TICK:
226 printf("Set tick queue pos. queue %d\n", ev->data.queue.queue);
227 break;
228 case SND_SEQ_EVENT_SETPOS_TIME:
229 printf("Set rt queue pos. queue %d\n", ev->data.queue.queue);
230 break;
231 case SND_SEQ_EVENT_TEMPO:
232 printf("Set queue tempo queue %d\n", ev->data.queue.queue);
233 break;
234 case SND_SEQ_EVENT_CLOCK:
235 printf("Clock\n");
236 break;
237 case SND_SEQ_EVENT_TICK:
238 printf("Tick\n");
239 break;
240 case SND_SEQ_EVENT_QUEUE_SKEW:
241 printf("Queue timer skew queue %d\n", ev->data.queue.queue);
242 break;
243 case SND_SEQ_EVENT_TUNE_REQUEST:
244 printf("Tune request\n");
245 break;
246 case SND_SEQ_EVENT_RESET:
247 printf("Reset\n");
248 break;
249 case SND_SEQ_EVENT_SENSING:
250 printf("Active Sensing\n");
251 break;
252 case SND_SEQ_EVENT_CLIENT_START:
253 printf("Client start client %d\n",
254 ev->data.addr.client);
255 break;
256 case SND_SEQ_EVENT_CLIENT_EXIT:
257 printf("Client exit client %d\n",
258 ev->data.addr.client);
259 break;
260 case SND_SEQ_EVENT_CLIENT_CHANGE:
261 printf("Client changed client %d\n",
262 ev->data.addr.client);
263 break;
264 case SND_SEQ_EVENT_PORT_START:
265 printf("Port start %d:%d\n",
266 ev->data.addr.client, ev->data.addr.port);
267 break;
268 case SND_SEQ_EVENT_PORT_EXIT:
269 printf("Port exit %d:%d\n",
270 ev->data.addr.client, ev->data.addr.port);
271 break;
272 case SND_SEQ_EVENT_PORT_CHANGE:
273 printf("Port changed %d:%d\n",
274 ev->data.addr.client, ev->data.addr.port);
275 break;
276 case SND_SEQ_EVENT_PORT_SUBSCRIBED:
277 printf("Port subscribed %d:%d -> %d:%d\n",
278 ev->data.connect.sender.client, ev->data.connect.sender.port,
279 ev->data.connect.dest.client, ev->data.connect.dest.port);
280 break;
281 case SND_SEQ_EVENT_PORT_UNSUBSCRIBED:
282 printf("Port unsubscribed %d:%d -> %d:%d\n",
283 ev->data.connect.sender.client, ev->data.connect.sender.port,
284 ev->data.connect.dest.client, ev->data.connect.dest.port);
285 break;
286 case SND_SEQ_EVENT_SYSEX:
287 {
288 unsigned int i;
289 printf("System exclusive ");
290 for (i = 0; i < ev->data.ext.len; ++i)
291 printf(" %02X", ((unsigned char*)ev->data.ext.ptr)[i]);
292 printf("\n");
293 }
294 break;
295 default:
296 printf("Event type %d\n", ev->type);
297 }
298 }
299
list_ports(void)300 static void list_ports(void)
301 {
302 snd_seq_client_info_t *cinfo;
303 snd_seq_port_info_t *pinfo;
304
305 snd_seq_client_info_alloca(&cinfo);
306 snd_seq_port_info_alloca(&pinfo);
307
308 puts(" Port Client name Port name");
309
310 snd_seq_client_info_set_client(cinfo, -1);
311 while (snd_seq_query_next_client(seq, cinfo) >= 0) {
312 int client = snd_seq_client_info_get_client(cinfo);
313
314 snd_seq_port_info_set_client(pinfo, client);
315 snd_seq_port_info_set_port(pinfo, -1);
316 while (snd_seq_query_next_port(seq, pinfo) >= 0) {
317 /* we need both READ and SUBS_READ */
318 if ((snd_seq_port_info_get_capability(pinfo)
319 & (SND_SEQ_PORT_CAP_READ | SND_SEQ_PORT_CAP_SUBS_READ))
320 != (SND_SEQ_PORT_CAP_READ | SND_SEQ_PORT_CAP_SUBS_READ))
321 continue;
322 printf("%3d:%-3d %-32.32s %s\n",
323 snd_seq_port_info_get_client(pinfo),
324 snd_seq_port_info_get_port(pinfo),
325 snd_seq_client_info_get_name(cinfo),
326 snd_seq_port_info_get_name(pinfo));
327 }
328 }
329 }
330
help(const char * argv0)331 static void help(const char *argv0)
332 {
333 printf("Usage: %s [options]\n"
334 "\nAvailable options:\n"
335 " -h,--help this help\n"
336 " -V,--version show version\n"
337 " -l,--list list input ports\n"
338 " -p,--port=client:port,... source port(s)\n",
339 argv0);
340 }
341
version(void)342 static void version(void)
343 {
344 puts("aseqdump version " SND_UTIL_VERSION_STR);
345 }
346
sighandler(int sig)347 static void sighandler(int sig)
348 {
349 stop = 1;
350 }
351
main(int argc,char * argv[])352 int main(int argc, char *argv[])
353 {
354 static const char short_options[] = "hVlp:";
355 static const struct option long_options[] = {
356 {"help", 0, NULL, 'h'},
357 {"version", 0, NULL, 'V'},
358 {"list", 0, NULL, 'l'},
359 {"port", 1, NULL, 'p'},
360 {0}
361 };
362
363 int do_list = 0;
364 struct pollfd *pfds;
365 int npfds;
366 int c, err;
367
368 init_seq();
369
370 while ((c = getopt_long(argc, argv, short_options,
371 long_options, NULL)) != -1) {
372 switch (c) {
373 case 'h':
374 help(argv[0]);
375 return 0;
376 case 'V':
377 version();
378 return 0;
379 case 'l':
380 do_list = 1;
381 break;
382 case 'p':
383 parse_ports(optarg);
384 break;
385 default:
386 help(argv[0]);
387 return 1;
388 }
389 }
390 if (optind < argc) {
391 help(argv[0]);
392 return 1;
393 }
394
395 if (do_list) {
396 list_ports();
397 return 0;
398 }
399
400 create_port();
401 connect_ports();
402
403 err = snd_seq_nonblock(seq, 1);
404 check_snd("set nonblock mode", err);
405
406 if (port_count > 0)
407 printf("Waiting for data.");
408 else
409 printf("Waiting for data at port %d:0.",
410 snd_seq_client_id(seq));
411 printf(" Press Ctrl+C to end.\n");
412 printf("Source Event Ch Data\n");
413
414 signal(SIGINT, sighandler);
415 signal(SIGTERM, sighandler);
416
417 npfds = snd_seq_poll_descriptors_count(seq, POLLIN);
418 pfds = alloca(sizeof(*pfds) * npfds);
419 for (;;) {
420 snd_seq_poll_descriptors(seq, pfds, npfds, POLLIN);
421 if (poll(pfds, npfds, -1) < 0)
422 break;
423 do {
424 snd_seq_event_t *event;
425 err = snd_seq_event_input(seq, &event);
426 if (err < 0)
427 break;
428 if (event)
429 dump_event(event);
430 } while (err > 0);
431 fflush(stdout);
432 if (stop)
433 break;
434 }
435
436 snd_seq_close(seq);
437 return 0;
438 }
439