mirrors/alsa-lib
1
0
Fork 0
mirror of https://github.com/alsa-project/alsa-lib.git synced 2025-10-29 05:40:25 -04:00
Code Issues Projects Releases Packages Wiki Activity Actions

Takashi Iwai <iwai@ww.uni-erlangen.de>

Browse source 
Mon, 03 Jan 2000 10:47:02 +0100
- bugfix: proper handling of exclusive subscription
- bugfix and update: alsa-lib/test/seq* stuff
- minor updates (long option support, etc) of aconnect and aseqnet
- man pages for aconnect and aseqnet are added
This commit is contained in:
Jaroslav Kysela 2000-01-03 10:25:56 +00:00
parent e4b58d20f1
commit d117462cb9
9 changed files with 364 additions and 299 deletions
Download patch file Download diff file Expand all files Collapse all files

1
include/seq.h
View file

@ -64,6 +64,7 @@ int snd_seq_event_input(snd_seq_t *handle, snd_seq_event_t **ev);
int snd_seq_event_input_pending(snd_seq_t *seq, int fetch_sequencer); int snd_seq_event_input_pending(snd_seq_t *seq, int fetch_sequencer);
int snd_seq_event_input_selective(snd_seq_t *seq, snd_seq_event_t **ev, int type, int blocking); int snd_seq_event_input_selective(snd_seq_t *seq, snd_seq_event_t **ev, int type, int blocking);
int snd_seq_flush_output(snd_seq_t *handle); int snd_seq_flush_output(snd_seq_t *handle);
int snd_seq_event_output_pending(snd_seq_t *seq);
int snd_seq_extract_output(snd_seq_t *handle, snd_seq_event_t **ev); int snd_seq_extract_output(snd_seq_t *handle, snd_seq_event_t **ev);
int snd_seq_drain_output(snd_seq_t *handle); int snd_seq_drain_output(snd_seq_t *handle);
int snd_seq_drain_output_buffer(snd_seq_t *handle); int snd_seq_drain_output_buffer(snd_seq_t *handle);

13
src/seq/seq.c
View file

@ -772,6 +772,16 @@ int snd_seq_event_input_selective(snd_seq_t *seq, snd_seq_event_t **ev, int type
return seq->cells; return seq->cells;
} }
/*
* return the size of pending events
*/
int snd_seq_event_output_pending(snd_seq_t *seq)
{
if (!seq)
return -EINVAL;
return seq->obufused;
}
/* /*
* flush output buffer to sequencer * flush output buffer to sequencer
*/ */
@ -842,6 +852,7 @@ int snd_seq_drain_output_buffer(snd_seq_t *seq)
if (!seq) if (!seq)
return -EINVAL; return -EINVAL;
seq->obufused = 0; seq->obufused = 0;
return 0;
} }
/* /*
@ -857,7 +868,7 @@ int snd_seq_drain_input_buffer(snd_seq_t *seq)
} }
/* /*
* clear output buffer and and remove events in sequencer queue * clear output buffer and remove events in sequencer queue
*/ */
int snd_seq_drain_output(snd_seq_t *seq) int snd_seq_drain_output(snd_seq_t *seq)
{ {

3
test/Makefile.am
View file

@ -18,4 +18,5 @@ aseqnet_LDADD=../src/libasound.la
INCLUDES=-I$(top_srcdir)/include INCLUDES=-I$(top_srcdir)/include
CFLAGS=-static -Wall -pipe -g CFLAGS=-static -Wall -pipe -g
EXTRA_DIST=seq-decoder.c seq-sender.c midifile.h midifile.c midifile.3 EXTRA_DIST=seq-decoder.c seq-sender.c midifile.h midifile.c midifile.3 \
aconnect.1 README.aconnect aseqnet.1 README.aseqnet

13
test/README.aconnect
View file

@ -1,7 +1,7 @@
================================================================ ================================================================
aconnect - control subscriptions aconnect - control subscriptions
ver.0.1.2 ver.0.1.3
Copyright (C) 1999 Takashi Iwai Copyright (C) 1999-2000 Takashi Iwai
================================================================ ================================================================
aconnect is a utility to control subscriptions of two ports as the aconnect is a utility to control subscriptions of two ports as the
@ -42,8 +42,9 @@ using -g option.
The option -l together with -i or -o shows subscribers for each port. The option -l together with -i or -o shows subscribers for each port.
The option -D specifies the sequencer device file (as default, Ports are connected exclusively when the option -e is specified.
/dev/snd/seq). Usually, you don't have to change it.
The option -q specifies the queue number. The argument must be a
valid queue number, usually from 0 to 7.
For modifying time-stamp with a queue, use -r or -t option followed by
a queue index which updates the time-stamp. Former uses real-time queue,
while the latter uses tick queue. The queue must be used (not necessarily
owned) by the receiver client.

4
test/README.aseqnet
View file

@ -1,7 +1,7 @@
================================================================ ================================================================
ALSA sequencer connectors ALSA sequencer connectors over network
ver.0.1 ver.0.1
Copyright (C) 1999 Takashi Iwai Copyright (C) 1999-2000 Takashi Iwai
================================================================ ================================================================
* ASEQNET * ASEQNET

94
test/aconnect.c
View file

@ -1,6 +1,6 @@
/* /*
* connect / disconnect two subscriber ports * connect / disconnect two subscriber ports
* ver.0.1.2 * ver.0.1.3
* *
* Copyright (C) 1999 Takashi Iwai * Copyright (C) 1999 Takashi Iwai
* *
@ -16,42 +16,50 @@
*/ */
#include <stdio.h> #include <stdio.h>
#include <ctype.h>
#include <string.h> #include <string.h>
#include <stdlib.h> #include <stdlib.h>
#include <errno.h> #include <errno.h>
#include <fcntl.h> #include <fcntl.h>
#include <unistd.h> #include <getopt.h>
#include <sys/ioctl.h> #include <sys/ioctl.h>
#include <sys/asoundlib.h> #include <sys/asoundlib.h>
#define DEFAULT_QUEUE 0
static void usage(void) static void usage(void)
{ {
fprintf(stderr, "connect / disconnect two subscriber ports\n"); fprintf(stderr, "aconnect - ALSA sequencer connection manager\n");
fprintf(stderr, "copyright (C) 1999 Takashi Iwai\n"); fprintf(stderr, "Copyright (C) 1999-2000 Takashi Iwai\n");
fprintf(stderr, "usage: aconnect [-d] [-q queue] [-g group] sender receiver\n"); fprintf(stderr, "Usage:\n");
fprintf(stderr, " -d = disconnect\n"); fprintf(stderr, " * Connection/disconnection betwen two ports\n");
fprintf(stderr, " sender, receiver = client:port\n"); fprintf(stderr, " aconnect [-options] sender receiver\n");
fprintf(stderr, " aconnect -i [-g group] [-l]\n"); fprintf(stderr, " sender, receiver = client:port pair\n");
fprintf(stderr, " list input ports\n"); fprintf(stderr, " -d,--disconnect disconnect\n");
fprintf(stderr, " aconnect -o [-g group] [-l]\n"); fprintf(stderr, " -e,--exclusive exclusive connection\n");
fprintf(stderr, " list output ports\n"); fprintf(stderr, " -r,--real # convert real-time-stamp on queue\n");
fprintf(stderr, " -l = list current connections\n"); fprintf(stderr, " -t,--tick # convert tick-time-stamp on queue\n");
fprintf(stderr, " -g,--group name set the group name\n");
fprintf(stderr, " * List connected ports (no subscription action)\n");
fprintf(stderr, " aconnect -i|-o [-options]\n");
fprintf(stderr, " -i,--input list input (readable) ports\n");
fprintf(stderr, " -o,--output list output (writable) ports\n");
fprintf(stderr, " -g,--group name specify the group name\n");
fprintf(stderr, " -l,--list list current connections of each port\n");
} }
/* /*
* parse command line to client:port * parse command line to client:port
*/ */
static void parse_address(snd_seq_addr_t *addr, char *arg) static int parse_address(snd_seq_addr_t *addr, char *arg)
{ {
char *p; char *p;
if (! isdigit(*arg))
return -1;
if ((p = strpbrk(arg, ":.")) == NULL)
return -1;
addr->client = atoi(arg); addr->client = atoi(arg);
if ((p = strchr(arg, ':')) != NULL) addr->port = atoi(p + 1);
addr->port = atoi(p + 1); return 0;
else
addr->port = 0;
} }
/* /*
@ -153,11 +161,23 @@ enum {
SUBSCRIBE, UNSUBSCRIBE, LIST_INPUT, LIST_OUTPUT SUBSCRIBE, UNSUBSCRIBE, LIST_INPUT, LIST_OUTPUT
}; };
static struct option long_option[] = {
{"disconnect", 0, NULL, 'd'},
{"input", 0, NULL, 'i'},
{"output", 0, NULL, 'o'},
{"group", 1, NULL, 'g'},
{"real", 1, NULL, 'r'},
{"tick", 1, NULL, 't'},
{"exclusive", 0, NULL, 'e'},
{"list", 0, NULL, 'l'},
{NULL, 0, NULL, 0},
};
int main(int argc, char **argv) int main(int argc, char **argv)
{ {
int c; int c;
snd_seq_t *seq; snd_seq_t *seq;
int queue = DEFAULT_QUEUE; int queue = 0, convert_time = 0, convert_real = 0, exclusive = 0;
int command = SUBSCRIBE; int command = SUBSCRIBE;
char *group = ""; char *group = "";
int client; int client;
@ -165,7 +185,7 @@ int main(int argc, char **argv)
snd_seq_client_info_t cinfo; snd_seq_client_info_t cinfo;
snd_seq_port_subscribe_t subs; snd_seq_port_subscribe_t subs;
while ((c = getopt(argc, argv, "diog:D:q:l")) != -1) { while ((c = getopt_long(argc, argv, "diog:r:t:el", long_option, NULL)) != -1) {
switch (c) { switch (c) {
case 'd': case 'd':
command = UNSUBSCRIBE; command = UNSUBSCRIBE;
@ -179,8 +199,18 @@ int main(int argc, char **argv)
case 'g': case 'g':
group = optarg; group = optarg;
break; break;
case 'q': case 'e':
exclusive = 1;
break;
case 'r':
queue = atoi(optarg); queue = atoi(optarg);
convert_time = 1;
convert_real = 1;
break;
case 't':
queue = atoi(optarg);
convert_time = 1;
convert_real = 0;
break; break;
case 'l': case 'l':
list_subs = 1; list_subs = 1;
@ -232,12 +262,18 @@ int main(int argc, char **argv)
/* set subscription */ /* set subscription */
memset(&subs, 0, sizeof(subs)); memset(&subs, 0, sizeof(subs));
parse_address(&subs.sender, argv[optind]); if (parse_address(&subs.sender, argv[optind]) < 0) {
parse_address(&subs.dest, argv[optind + 1]); fprintf(stderr, "invalid sender address %s\n", argv[optind]);
return 1;
}
if (parse_address(&subs.dest, argv[optind + 1]) < 0) {
fprintf(stderr, "invalid destination address %s\n", argv[optind + 1]);
return 1;
}
subs.queue = queue; subs.queue = queue;
subs.exclusive = 0; subs.exclusive = exclusive;
subs.convert_time = 0; subs.convert_time = convert_time;
subs.realtime = 0; subs.realtime = convert_real;
if (command == UNSUBSCRIBE) { if (command == UNSUBSCRIBE) {
if (snd_seq_get_port_subscription(seq, &subs) < 0) { if (snd_seq_get_port_subscription(seq, &subs) < 0) {
@ -247,7 +283,7 @@ int main(int argc, char **argv)
} }
if (snd_seq_unsubscribe_port(seq, &subs) < 0) { if (snd_seq_unsubscribe_port(seq, &subs) < 0) {
snd_seq_close(seq); snd_seq_close(seq);
fprintf(stderr, "Disconnection failed (errno=%d)\n", errno); fprintf(stderr, "Disconnection failed (%s)\n", snd_strerror(errno));
return 1; return 1;
} }
} else { } else {
@ -258,7 +294,7 @@ int main(int argc, char **argv)
} }
if (snd_seq_subscribe_port(seq, &subs) < 0) { if (snd_seq_subscribe_port(seq, &subs) < 0) {
snd_seq_close(seq); snd_seq_close(seq);
fprintf(stderr, "Connection failed (errno=%d)\n", errno); fprintf(stderr, "Connection failed (%s)\n", snd_strerror(errno));
return 1; return 1;
} }
} }

42
test/aseqnet.c
View file

@ -2,7 +2,7 @@
* network server/client for ALSA sequencer * network server/client for ALSA sequencer
* ver.0.1 * ver.0.1
* *
* Copyright (C) 1999 Takashi Iwai * Copyright (C) 1999-2000 Takashi Iwai
* *
* This program is free software; you can redistribute it and/or modify * 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 * it under the terms of the GNU General Public License version 2 as
@ -22,7 +22,7 @@
#include <netinet/in.h> #include <netinet/in.h>
#include <netdb.h> #include <netdb.h>
#include <sys/asoundlib.h> #include <sys/asoundlib.h>
#include <unistd.h> #include <getopt.h>
#include <signal.h> #include <signal.h>
/* /*
@ -69,13 +69,21 @@ static int server_mode;
* main routine * main routine
*/ */
static struct option long_option[] = {
{"port", 1, NULL, 'p'},
{"source", 1, NULL, 's'},
{"dest", 1, NULL, 'd'},
{"help", 0, NULL, 'h'},
{NULL, 0, NULL, 0},
};
int main(int argc, char **argv) int main(int argc, char **argv)
{ {
int c; int c;
int port = DEFAULT_PORT; int port = DEFAULT_PORT;
char *source = NULL, *dest = NULL; char *source = NULL, *dest = NULL;
while ((c = getopt(argc, argv, "p:s:d:")) != -1) { while ((c = getopt_long(argc, argv, "p:s:d:", long_option, NULL)) != -1) {
switch (c) { switch (c) {
case 'p': case 'p':
if (isdigit(*optarg)) if (isdigit(*optarg))
@ -130,9 +138,9 @@ static void usage(void)
fprintf(stderr, " server mode: aseqnet [-options]\n"); fprintf(stderr, " server mode: aseqnet [-options]\n");
fprintf(stderr, " client mode: aseqnet [-options] server_host\n"); fprintf(stderr, " client mode: aseqnet [-options] server_host\n");
fprintf(stderr, "options:\n"); fprintf(stderr, "options:\n");
fprintf(stderr, " -p port : sepcify TCP port (digit or service name)\n"); fprintf(stderr, " -p,--port # : sepcify TCP port (digit or service name)\n");
fprintf(stderr, " -s addr : read from given addr (client:port)\n"); fprintf(stderr, " -s,--source addr : read from given addr (client:port)\n");
fprintf(stderr, " -d addr : write to given addr (client:port)\n"); fprintf(stderr, " -d,--dest addr : write to given addr (client:port)\n");
} }
@ -157,15 +165,17 @@ static void init_buf(void)
/* /*
* parse client:port argument * parse client:port argument
*/ */
static void parse_addr(snd_seq_addr_t *addr, char *arg) static int parse_addr(snd_seq_addr_t *addr, char *arg)
{ {
char *p; char *p;
if (! isdigit(*arg))
return -1;
if ((p = strpbrk(arg, ":.")) == NULL)
return -1;
addr->client = atoi(arg); addr->client = atoi(arg);
if ((p = strchr(arg, ':')) != NULL) addr->port = atoi(p + 1);
addr->port = atoi(p + 1); return 0;
else
addr->port = 0;
} }
@ -222,7 +232,10 @@ static void init_seq(char *source, char *dest)
/* explicit subscriptions */ /* explicit subscriptions */
if (source) { if (source) {
/* read subscription */ /* read subscription */
parse_addr(&addr, source); if (parse_addr(&addr, source) < 0) {
fprintf(stderr, "invalid source address %s\n", source);
exit(1);
}
if (snd_seq_connect_from(handle, seq_port, addr.client, addr.port)) { if (snd_seq_connect_from(handle, seq_port, addr.client, addr.port)) {
perror("read subscription"); perror("read subscription");
exit(1); exit(1);
@ -230,7 +243,10 @@ static void init_seq(char *source, char *dest)
} }
if (dest) { if (dest) {
/* write subscription */ /* write subscription */
parse_addr(&addr, dest); if (parse_addr(&addr, dest) < 0) {
fprintf(stderr, "invalid destination address %s\n", dest);
exit(1);
}
if (snd_seq_connect_to(handle, seq_port, addr.client, addr.port)) { if (snd_seq_connect_to(handle, seq_port, addr.client, addr.port)) {
perror("write subscription"); perror("write subscription");
exit(1); exit(1);

462
test/seq-decoder.c
View file

@ -4,48 +4,48 @@
static char *event_names[256] = { static char *event_names[256] = {
/* 0 */ "System", /* 0 */ "System",
/* 1 */ "Note", /* 1 */ "Result",
/* 2 */ "Note On", /* 2 */ "Reserved 2",
/* 3 */ "Note Off", /* 3 */ "Reserved 3",
/* 4 */ "Reserved 4", /* 4 */ "Reserved 4",
/* 5 */ "Reserved 5", /* 5 */ "Note",
/* 6 */ "Reserved 6", /* 6 */ "Note On",
/* 7 */ "Reserved 7", /* 7 */ "Note Off",
/* 8 */ "Reserved 8", /* 8 */ "Key Pressure",
/* 9 */ "Reserved 9", /* 9 */ "Reserved 9",
/* 10 */ "KeyPress", /* 10 */ "Controller",
/* 11 */ "Controller", /* 11 */ "Program Change",
/* 12 */ "Program Change", /* 12 */ "Channel Pressure",
/* 13 */ "Channel Pressure", /* 13 */ "Pitchbend",
/* 14 */ "Pitchbend", /* 14 */ "Control14",
/* 15 */ "Control14", /* 15 */ "Nonregparam",
/* 16 */ "Nonregparam", /* 16 */ "Regparam",
/* 17 */ "Regparam", /* 17 */ "Reserved 17",
/* 18 */ "Reserved 18", /* 18 */ "Reserved 18",
/* 19 */ "Reserved 19", /* 19 */ "Reserved 19",
/* 20 */ "Song Position", /* 20 */ "Song Position",
/* 21 */ "Song Select", /* 21 */ "Song Select",
/* 22 */ "Clock", /* 22 */ "Qframe",
/* 23 */ "Start", /* 23 */ "SMF Time Signature",
/* 24 */ "Continue", /* 24 */ "SMF Key Signature",
/* 25 */ "Stop", /* 25 */ "Reserved 25",
/* 26 */ "Qframe", /* 26 */ "Reserved 26",
/* 27 */ "Reserved 27", /* 27 */ "Reserved 27",
/* 28 */ "Reserved 28", /* 28 */ "Reserved 28",
/* 29 */ "Reserved 29", /* 29 */ "Reserved 29",
/* 30 */ "Tempo", /* 30 */ "Start",
/* 31 */ "SMF Time Signature", /* 31 */ "Continue",
/* 32 */ "SMF Key Signature", /* 32 */ "Stop",
/* 33 */ "Reserved 33", /* 33 */ "Set Position Tick",
/* 34 */ "Reserved 34", /* 34 */ "Set Position Time",
/* 35 */ "Reserved 35", /* 35 */ "Tempo",
/* 36 */ "Reserved 36", /* 36 */ "Clock",
/* 37 */ "Reserved 37", /* 37 */ "Tick",
/* 38 */ "Reserved 38", /* 38 */ "Reserved 38",
/* 39 */ "Reserved 39", /* 39 */ "Reserved 39",
/* 40 */ "System Exclusive", /* 40 */ "Tune Request",
/* 41 */ "Heart Beat", /* 41 */ "Reset",
/* 42 */ "Reserved 42", /* 42 */ "Active Sensing",
/* 43 */ "Reserved 43", /* 43 */ "Reserved 43",
/* 44 */ "Reserved 44", /* 44 */ "Reserved 44",
/* 45 */ "Reserved 45", /* 45 */ "Reserved 45",
@ -53,8 +53,8 @@ static char *event_names[256] = {
/* 47 */ "Reserved 47", /* 47 */ "Reserved 47",
/* 48 */ "Reserved 48", /* 48 */ "Reserved 48",
/* 49 */ "Reserved 49", /* 49 */ "Reserved 49",
/* 50 */ "Heart Beat (Active sensing)", /* 50 */ "Echo",
/* 51 */ "Echo", /* 51 */ "OSS",
/* 52 */ "Reserved 52", /* 52 */ "Reserved 52",
/* 53 */ "Reserved 53", /* 53 */ "Reserved 53",
/* 54 */ "Reserved 54", /* 54 */ "Reserved 54",
@ -69,206 +69,196 @@ static char *event_names[256] = {
/* 63 */ "Port Start", /* 63 */ "Port Start",
/* 64 */ "Port Exit", /* 64 */ "Port Exit",
/* 65 */ "Port Change", /* 65 */ "Port Change",
/* 66 */ "Reserved 66", /* 66 */ "Port Subscribed",
/* 67 */ "Reserved 67", /* 67 */ "Port Used",
/* 68 */ "Reserved 68", /* 68 */ "Port Unsubscribed",
/* 69 */ "Reserved 69", /* 69 */ "Port Unused",
/* 70 */ "Reserved 70", /* 70 */ "Sample",
/* 71 */ "Reserved 71", /* 71 */ "Sample Cluster",
/* 72 */ "Reserved 72", /* 72 */ "Sample Start",
/* 73 */ "Reserved 73", /* 73 */ "Sample Stop",
/* 74 */ "Reserved 74", /* 74 */ "Sample Freq",
/* 75 */ "Reserved 75", /* 75 */ "Sample Volume",
/* 76 */ "Reserved 76", /* 76 */ "Sample Loop",
/* 77 */ "Reserved 77", /* 77 */ "Sample Position",
/* 78 */ "Reserved 78", /* 78 */ "Sample Private1",
/* 79 */ "Reserved 79", /* 79 */ "Reserved 79",
/* 80 */ "Sample Select", /* 80 */ "Reserved 80",
/* 81 */ "Sample Start", /* 81 */ "Reserved 81",
/* 82 */ "Sample Stop", /* 82 */ "Reserved 82",
/* 83 */ "Sample Frequency", /* 83 */ "Reserved 83",
/* 84 */ "Sample Volume", /* 84 */ "Reserved 84",
/* 85 */ "Sample Loop", /* 85 */ "Reserved 85",
/* 86 */ "Sample Position", /* 86 */ "Reserved 86",
/* 87 */ "Reseved 87", /* 87 */ "Reserved 87",
/* 88 */ "Reseved 88", /* 88 */ "Reserved 88",
/* 89 */ "Reseved 89", /* 89 */ "Reserved 89",
/* 90 */ "Reseved 90", /* 90 */ "User 0",
/* 91 */ "Reseved 91", /* 91 */ "User 1",
/* 92 */ "Reseved 92", /* 92 */ "User 2",
/* 93 */ "Reseved 93", /* 93 */ "User 3",
/* 94 */ "Reseved 94", /* 94 */ "User 4",
/* 95 */ "Reseved 95", /* 95 */ "User 5",
/* 96 */ "Reseved 96", /* 96 */ "User 6",
/* 97 */ "Reseved 97", /* 97 */ "User 7",
/* 98 */ "Reseved 98", /* 98 */ "User 8",
/* 99 */ "Reseved 99", /* 99 */ "User 9",
/* 100 */ "Reseved 100", /* 100 */ "Instr Begin",
/* 101 */ "Reseved 101", /* 101 */ "Instr End",
/* 102 */ "Reseved 102", /* 102 */ "Instr Info",
/* 103 */ "Reseved 103", /* 103 */ "Instr Info Result",
/* 104 */ "Reseved 104", /* 104 */ "Instr Finfo",
/* 105 */ "Reseved 105", /* 105 */ "Instr Finfo Result",
/* 106 */ "Reseved 106", /* 106 */ "Instr Reset",
/* 107 */ "Reseved 107", /* 107 */ "Instr Status",
/* 108 */ "Reseved 108", /* 108 */ "Instr Status Result",
/* 109 */ "Reseved 109", /* 109 */ "Instr Put",
/* 100 */ "Reserved 100" /* 110 */ "Instr Get",
/* 101 */ "Reserved 101" /* 111 */ "Instr Get Result",
/* 102 */ "Reserved 102" /* 112 */ "Instr Free",
/* 103 */ "Reserved 103" /* 113 */ "Instr List",
/* 104 */ "Reserved 104" /* 114 */ "Instr List Result",
/* 105 */ "Reserved 105" /* 115 */ "Instr Cluster",
/* 106 */ "Reserved 106" /* 116 */ "Instr Cluster Get",
/* 107 */ "Reserved 107" /* 117 */ "Instr Cluster Result",
/* 108 */ "Reserved 108" /* 118 */ "Instr Change",
/* 109 */ "Reserved 109" /* 119 */ "Reserved 119",
/* 110 */ "Reserved 110" /* 120 */ "Reserved 120",
/* 111 */ "Reserved 111" /* 121 */ "Reserved 121",
/* 112 */ "Reserved 112" /* 122 */ "Reserved 122",
/* 113 */ "Reserved 113" /* 123 */ "Reserved 123",
/* 114 */ "Reserved 114" /* 124 */ "Reserved 124",
/* 115 */ "Reserved 115" /* 125 */ "Reserved 125",
/* 116 */ "Reserved 116" /* 126 */ "Reserved 126",
/* 117 */ "Reserved 117" /* 127 */ "Reserved 127",
/* 118 */ "Reserved 118" /* 128 */ "Reserved 128",
/* 119 */ "Reserved 119" /* 129 */ "Reserved 129",
/* 120 */ "Reserved 120" /* 130 */ "Sysex",
/* 121 */ "Reserved 121" /* 131 */ "Bounce",
/* 122 */ "Reserved 122" /* 132 */ "Reserved 132",
/* 123 */ "Reserved 123" /* 133 */ "Reserved 133",
/* 124 */ "Reserved 124" /* 134 */ "Reserved 134",
/* 125 */ "Reserved 125" /* 135 */ "User Var0",
/* 126 */ "Reserved 126" /* 136 */ "User Var1",
/* 127 */ "Reserved 127" /* 137 */ "User Var2",
/* 128 */ "Reserved 128" /* 138 */ "User Var3",
/* 129 */ "Reserved 129" /* 139 */ "User Var4",
/* 130 */ "Reserved 130" /* 140 */ "IPC Shm",
/* 131 */ "Reserved 131" /* 141 */ "Reserved 141",
/* 132 */ "Reserved 132" /* 142 */ "Reserved 142",
/* 133 */ "Reserved 133" /* 143 */ "Reserved 143",
/* 134 */ "Reserved 134" /* 144 */ "Reserved 144",
/* 135 */ "Reserved 135" /* 145 */ "User IPC0",
/* 136 */ "Reserved 136" /* 146 */ "User IPC1",
/* 137 */ "Reserved 137" /* 147 */ "User IPC2",
/* 138 */ "Reserved 138" /* 148 */ "User IPC3",
/* 139 */ "Reserved 139" /* 149 */ "User IPC4",
/* 140 */ "Reserved 140" /* 150 */ "Reserved 150",
/* 141 */ "Reserved 141" /* 151 */ "Reserved 151",
/* 142 */ "Reserved 142" /* 152 */ "Reserved 152",
/* 143 */ "Reserved 143" /* 153 */ "Reserved 153",
/* 144 */ "Reserved 144" /* 154 */ "Reserved 154",
/* 145 */ "Reserved 145" /* 155 */ "Reserved 155",
/* 146 */ "Reserved 146" /* 156 */ "Reserved 156",
/* 147 */ "Reserved 147" /* 157 */ "Reserved 157",
/* 148 */ "Reserved 148" /* 158 */ "Reserved 158",
/* 149 */ "Reserved 149" /* 159 */ "Reserved 159",
/* 150 */ "Reserved 150" /* 160 */ "Reserved 160",
/* 151 */ "Reserved 151" /* 161 */ "Reserved 161",
/* 152 */ "Reserved 152" /* 162 */ "Reserved 162",
/* 153 */ "Reserved 153" /* 163 */ "Reserved 163",
/* 154 */ "Reserved 154" /* 164 */ "Reserved 164",
/* 155 */ "Reserved 155" /* 165 */ "Reserved 165",
/* 156 */ "Reserved 156" /* 166 */ "Reserved 166",
/* 157 */ "Reserved 157" /* 167 */ "Reserved 167",
/* 158 */ "Reserved 158" /* 168 */ "Reserved 168",
/* 159 */ "Reserved 159" /* 169 */ "Reserved 169",
/* 160 */ "Reserved 160" /* 170 */ "Reserved 170",
/* 161 */ "Reserved 161" /* 171 */ "Reserved 171",
/* 162 */ "Reserved 162" /* 172 */ "Reserved 172",
/* 163 */ "Reserved 163" /* 173 */ "Reserved 173",
/* 164 */ "Reserved 164" /* 174 */ "Reserved 174",
/* 165 */ "Reserved 165" /* 175 */ "Reserved 175",
/* 166 */ "Reserved 166" /* 176 */ "Reserved 176",
/* 167 */ "Reserved 167" /* 177 */ "Reserved 177",
/* 168 */ "Reserved 168" /* 178 */ "Reserved 178",
/* 169 */ "Reserved 169" /* 179 */ "Reserved 179",
/* 170 */ "Reserved 170" /* 180 */ "Reserved 180",
/* 171 */ "Reserved 171" /* 181 */ "Reserved 181",
/* 172 */ "Reserved 172" /* 182 */ "Reserved 182",
/* 173 */ "Reserved 173" /* 183 */ "Reserved 183",
/* 174 */ "Reserved 174" /* 184 */ "Reserved 184",
/* 175 */ "Reserved 175" /* 185 */ "Reserved 185",
/* 176 */ "Reserved 176" /* 186 */ "Reserved 186",
/* 177 */ "Reserved 177" /* 187 */ "Reserved 187",
/* 178 */ "Reserved 178" /* 188 */ "Reserved 188",
/* 179 */ "Reserved 179" /* 189 */ "Reserved 189",
/* 180 */ "Reserved 180" /* 190 */ "Reserved 190",
/* 181 */ "Reserved 181" /* 191 */ "Reserved 191",
/* 182 */ "Reserved 182" /* 192 */ "Reserved 192",
/* 183 */ "Reserved 183" /* 193 */ "Reserved 193",
/* 184 */ "Reserved 184" /* 194 */ "Reserved 194",
/* 185 */ "Reserved 185" /* 195 */ "Reserved 195",
/* 186 */ "Reserved 186" /* 196 */ "Reserved 196",
/* 187 */ "Reserved 187" /* 197 */ "Reserved 197",
/* 188 */ "Reserved 188" /* 198 */ "Reserved 198",
/* 189 */ "Reserved 189" /* 199 */ "Reserved 199",
/* 190 */ "Reserved 190" /* 200 */ "Reserved 200",
/* 191 */ "Reserved 191" /* 201 */ "Reserved 201",
/* 192 */ "Reserved 192" /* 202 */ "Reserved 202",
/* 193 */ "Reserved 193" /* 203 */ "Reserved 203",
/* 194 */ "Reserved 194" /* 204 */ "Reserved 204",
/* 195 */ "Reserved 195" /* 205 */ "Reserved 205",
/* 196 */ "Reserved 196" /* 206 */ "Reserved 206",
/* 197 */ "Reserved 197" /* 207 */ "Reserved 207",
/* 198 */ "Reserved 198" /* 208 */ "Reserved 208",
/* 199 */ "Reserved 199" /* 209 */ "Reserved 209",
/* 200 */ "Reserved 200" /* 210 */ "Reserved 210",
/* 201 */ "Reserved 201" /* 211 */ "Reserved 211",
/* 202 */ "Reserved 202" /* 212 */ "Reserved 212",
/* 203 */ "Reserved 203" /* 213 */ "Reserved 213",
/* 204 */ "Reserved 204" /* 214 */ "Reserved 214",
/* 205 */ "Reserved 205" /* 215 */ "Reserved 215",
/* 206 */ "Reserved 206" /* 216 */ "Reserved 216",
/* 207 */ "Reserved 207" /* 217 */ "Reserved 217",
/* 208 */ "Reserved 208" /* 218 */ "Reserved 218",
/* 209 */ "Reserved 209" /* 219 */ "Reserved 219",
/* 210 */ "Reserved 210" /* 220 */ "Reserved 220",
/* 211 */ "Reserved 211" /* 221 */ "Reserved 221",
/* 212 */ "Reserved 212" /* 222 */ "Reserved 222",
/* 213 */ "Reserved 213" /* 223 */ "Reserved 223",
/* 214 */ "Reserved 214" /* 224 */ "Reserved 224",
/* 215 */ "Reserved 215" /* 225 */ "Reserved 225",
/* 216 */ "Reserved 216" /* 226 */ "Reserved 226",
/* 217 */ "Reserved 217" /* 227 */ "Reserved 227",
/* 218 */ "Reserved 218" /* 228 */ "Reserved 228",
/* 219 */ "Reserved 219" /* 229 */ "Reserved 229",
/* 220 */ "Reserved 220" /* 230 */ "Reserved 230",
/* 221 */ "Reserved 221" /* 231 */ "Reserved 231",
/* 222 */ "Reserved 222" /* 232 */ "Reserved 232",
/* 223 */ "Reserved 223" /* 233 */ "Reserved 233",
/* 224 */ "Reserved 224" /* 234 */ "Reserved 234",
/* 225 */ "Reserved 225" /* 235 */ "Reserved 235",
/* 226 */ "Reserved 226" /* 236 */ "Reserved 236",
/* 227 */ "Reserved 227" /* 237 */ "Reserved 237",
/* 228 */ "Reserved 228" /* 238 */ "Reserved 238",
/* 229 */ "Reserved 229" /* 239 */ "Reserved 239",
/* 230 */ "Reserved 230" /* 240 */ "Reserved 240",
/* 231 */ "Reserved 231" /* 241 */ "Reserved 241",
/* 232 */ "Reserved 232" /* 242 */ "Reserved 242",
/* 233 */ "Reserved 233" /* 243 */ "Reserved 243",
/* 234 */ "Reserved 234" /* 244 */ "Reserved 244",
/* 235 */ "Reserved 235" /* 245 */ "Reserved 245",
/* 236 */ "Reserved 236" /* 246 */ "Reserved 246",
/* 237 */ "Reserved 237" /* 247 */ "Reserved 247",
/* 238 */ "Reserved 238" /* 248 */ "Reserved 248",
/* 239 */ "Reserved 239" /* 249 */ "Reserved 249",
/* 240 */ "Reserved 240" /* 250 */ "Reserved 250",
/* 241 */ "Reserved 241" /* 251 */ "Reserved 251",
/* 242 */ "Reserved 242" /* 252 */ "Reserved 252",
/* 243 */ "Reserved 243" /* 253 */ "Reserved 253",
/* 244 */ "Reserved 244" /* 254 */ "Reserved 254",
/* 245 */ "Reserved 245" /* 255 */ "None"
/* 246 */ "Reserved 246"
/* 247 */ "Reserved 247"
/* 248 */ "Reserved 248"
/* 249 */ "Reserved 249"
/* 250 */ "Reserved 250"
/* 251 */ "Reserved 251"
/* 252 */ "Reserved 252"
/* 253 */ "Reserved 253"
/* 254 */ "Reserved 254"
/* 255 */ "Reserved 255"
}; };
int decode_event(snd_seq_event_t * ev) int decode_event(snd_seq_event_t * ev)
@ -299,10 +289,11 @@ int decode_event(snd_seq_event_t * ev)
/* decode actual event data... */ /* decode actual event data... */
switch (ev->type) { switch (ev->type) {
case SND_SEQ_EVENT_NOTE: case SND_SEQ_EVENT_NOTE:
printf("; ch=%d, note=%d, velocity=%d, duration=%d\n", printf("; ch=%d, note=%d, velocity=%d, off_velocity=%d, duration=%d\n",
ev->data.note.channel, ev->data.note.channel,
ev->data.note.note, ev->data.note.note,
ev->data.note.velocity, ev->data.note.velocity,
ev->data.note.off_velocity,
ev->data.note.duration); ev->data.note.duration);
break; break;
@ -384,6 +375,10 @@ int decode_event(snd_seq_event_t * ev)
case SND_SEQ_EVENT_PORT_START: case SND_SEQ_EVENT_PORT_START:
case SND_SEQ_EVENT_PORT_EXIT: case SND_SEQ_EVENT_PORT_EXIT:
case SND_SEQ_EVENT_PORT_CHANGE: case SND_SEQ_EVENT_PORT_CHANGE:
case SND_SEQ_EVENT_PORT_SUBSCRIBED:
case SND_SEQ_EVENT_PORT_USED:
case SND_SEQ_EVENT_PORT_UNSUBSCRIBED:
case SND_SEQ_EVENT_PORT_UNUSED:
printf("; client=%i, port = %i\n", ev->data.addr.client, ev->data.addr.port); printf("; client=%i, port = %i\n", ev->data.addr.client, ev->data.addr.port);
break; break;
@ -437,6 +432,7 @@ void event_decoder(snd_seq_t *handle, int argc, char *argv[])
bzero(&port, sizeof(port)); bzero(&port, sizeof(port));
strcpy(port.name, "Input"); strcpy(port.name, "Input");
port.capability = SND_SEQ_PORT_CAP_WRITE | SND_SEQ_PORT_CAP_READ; port.capability = SND_SEQ_PORT_CAP_WRITE | SND_SEQ_PORT_CAP_READ;
port.capability |= SND_SEQ_PORT_CAP_SUBS_WRITE;
if ((err = snd_seq_create_port(handle, &port)) < 0) { if ((err = snd_seq_create_port(handle, &port)) < 0) {
fprintf(stderr, "Cannot create input port: %s\n", snd_strerror(err)); fprintf(stderr, "Cannot create input port: %s\n", snd_strerror(err));
return; return;

31
test/seq-sender.c
View file

@ -83,9 +83,7 @@ void event_sender_start_timer(snd_seq_t *handle, int client, int queue, snd_pcm_
#endif #endif
if ((err = snd_seq_start_queue(handle, queue, NULL))<0) if ((err = snd_seq_start_queue(handle, queue, NULL))<0)
fprintf(stderr, "Timer event output error: %s\n", snd_strerror(err)); fprintf(stderr, "Timer event output error: %s\n", snd_strerror(err));
/* ugly, but working */ snd_seq_flush_output(handle);
while (snd_seq_flush_output(handle)>0)
sleep(1);
} }
void event_sender_filter(snd_seq_t *handle) void event_sender_filter(snd_seq_t *handle)
@ -123,6 +121,11 @@ void send_event(snd_seq_t *handle, int queue, int client, int port,
fprintf(stderr, "Event output error: %s\n", snd_strerror(err)); fprintf(stderr, "Event output error: %s\n", snd_strerror(err));
ev.dest.client = sub->dest.client; ev.dest.client = sub->dest.client;
ev.dest.port = sub->dest.port; ev.dest.port = sub->dest.port;
ev.type = SND_SEQ_EVENT_PGMCHANGE;
ev.data.control.channel = 0;
ev.data.control.value = 16;
if ((err = snd_seq_event_output(handle, &ev))<0)
fprintf(stderr, "Event output error: %s\n", snd_strerror(err));
ev.type = SND_SEQ_EVENT_NOTE; ev.type = SND_SEQ_EVENT_NOTE;
ev.data.note.channel = 0; ev.data.note.channel = 0;
ev.data.note.note = 64 + (queue*2); ev.data.note.note = 64 + (queue*2);
@ -141,13 +144,13 @@ void event_sender(snd_seq_t *handle, int argc, char *argv[])
snd_seq_port_info_t port; snd_seq_port_info_t port;
snd_seq_port_subscribe_t sub; snd_seq_port_subscribe_t sub;
fd_set out, in; fd_set out, in;
int client, queue, max, err, v1, v2, time = 0, first, pcm_flag = 0; int client, queue, max, err, v1, v2, time = 0, pcm_flag = 0;
char *ptr; char *ptr;
snd_pcm_t *phandle = NULL; snd_pcm_t *phandle = NULL;
char *pbuf = NULL; char *pbuf = NULL;
if (argc < 1) { if (argc < 1) {
fprintf(stderr, "Invalid destonation...\n"); fprintf(stderr, "Invalid destination...\n");
return; return;
} }
@ -197,7 +200,7 @@ void event_sender(snd_seq_t *handle, int argc, char *argv[])
} }
} }
printf("Destonation client = %i, port = %i\n", sub.dest.client, sub.dest.port); printf("Destination client = %i, port = %i\n", sub.dest.client, sub.dest.port);
#ifdef USE_PCM #ifdef USE_PCM
if (pcm_flag) { if (pcm_flag) {
@ -217,13 +220,17 @@ void event_sender(snd_seq_t *handle, int argc, char *argv[])
#endif #endif
event_sender_start_timer(handle, client, queue, phandle); event_sender_start_timer(handle, client, queue, phandle);
first = 1; /* send the first event */
send_event(handle, queue, client, port.port, &sub, &time);
while (1) { while (1) {
FD_ZERO(&out); FD_ZERO(&out);
FD_ZERO(&in); FD_ZERO(&in);
max = snd_seq_file_descriptor(handle); max = snd_seq_file_descriptor(handle);
FD_SET(snd_seq_file_descriptor(handle), &out);
FD_SET(snd_seq_file_descriptor(handle), &in); FD_SET(snd_seq_file_descriptor(handle), &in);
if (snd_seq_event_output_pending(handle)) {
FD_SET(snd_seq_file_descriptor(handle), &out);
}
#ifdef USE_PCM #ifdef USE_PCM
if (phandle) { if (phandle) {
if (snd_pcm_file_descriptor(phandle) > max) if (snd_pcm_file_descriptor(phandle) > max)
@ -241,12 +248,8 @@ void event_sender(snd_seq_t *handle, int argc, char *argv[])
} }
} }
#endif #endif
if (FD_ISSET(snd_seq_file_descriptor(handle), &out)) { if (FD_ISSET(snd_seq_file_descriptor(handle), &out))
if (first) { snd_seq_flush_output(handle);
send_event(handle, queue, client, port.port, &sub, &time);
first = 0;
}
}
if (FD_ISSET(snd_seq_file_descriptor(handle), &in)) { if (FD_ISSET(snd_seq_file_descriptor(handle), &in)) {
do { do {
if ((err = snd_seq_event_input(handle, &ev))<0) if ((err = snd_seq_event_input(handle, &ev))<0)