Mercurial > hg > easaier-soundaccess

comparison plugin/api/dssi_alsa_compat.c @ 0:fc9323a41f5a

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
start base : Sonic Visualiser sv1-1.0rc1
author lbajardsilogic
date Fri, 11 May 2007 09:08:14 +0000
parents
children
comparison
equal deleted inserted replaced
-1:000000000000 0:fc9323a41f5a
1 /* DSSI ALSA compatibility library
2 *
3 * This library provides for non-ALSA systems the ALSA snd_seq_event_t handling
4 * necessary to compile and run DSSI. It was extracted from alsa-lib 1.0.8.
5 *
6 * See ./alsa/README for more information.
7 */
8
9 #include <stdlib.h>
10 #include <errno.h>
11
12 #include "alsa/asoundef.h"
13 #include "alsa/sound/asequencer.h"
14 #include "alsa/seq.h"
15 #include "alsa/seq_event.h"
16 #include "alsa/seq_midi_event.h"
17
18 /**
19 * \file seq/seq_event.c
20 * \brief Sequencer Event Types
21 * \author Takashi Iwai <tiwai@suse.de>
22 * \date 2001
23 */
24
25 #define FIXED_EV(x) (_SND_SEQ_TYPE(SND_SEQ_EVFLG_FIXED) | _SND_SEQ_TYPE(x))
26
27 /** Event types conversion array */
28 const unsigned int snd_seq_event_types[256] = {
29
30 FIXED_EV(SND_SEQ_EVFLG_RESULT), // SND_SEQ_EVENT_SYSTEM = 0
31 FIXED_EV(SND_SEQ_EVFLG_RESULT), // SND_SEQ_EVENT_RESULT
32 0,
33 0,
34 0,
35 FIXED_EV(SND_SEQ_EVFLG_NOTE) | _SND_SEQ_TYPE_OPT(SND_SEQ_EVFLG_NOTE_TWOARG), // SND_SEQ_EVENT_NOTE = 5
36 FIXED_EV(SND_SEQ_EVFLG_NOTE), // SND_SEQ_EVENT_NOTEON
37 FIXED_EV(SND_SEQ_EVFLG_NOTE), // SND_SEQ_EVENT_NOTEOFF
38 FIXED_EV(SND_SEQ_EVFLG_NOTE), // SND_SEQ_EVENT_KEYPRESS
39 0,
40 FIXED_EV(SND_SEQ_EVFLG_CONTROL),// SND_SEQ_EVENT_CONTROLLER = 10
41 FIXED_EV(SND_SEQ_EVFLG_CONTROL),// SND_SEQ_EVENT_PGMCHANGE
42 FIXED_EV(SND_SEQ_EVFLG_CONTROL),// SND_SEQ_EVENT_CHANPRESS
43 FIXED_EV(SND_SEQ_EVFLG_CONTROL),// SND_SEQ_EVENT_PITCHBEND
44 FIXED_EV(SND_SEQ_EVFLG_CONTROL),// SND_SEQ_EVENT_CONTROL14
45 FIXED_EV(SND_SEQ_EVFLG_CONTROL),// SND_SEQ_EVENT_NONREGPARAM
46 FIXED_EV(SND_SEQ_EVFLG_CONTROL),// SND_SEQ_EVENT_REGPARAM
47 0,
48 0,
49 0,
50 0, // = 20
51 0,
52 0,
53 0,
54 0,
55 0,
56 0,
57 0,
58 0,
59 0,
60 FIXED_EV(SND_SEQ_EVFLG_QUEUE), // SND_SEQ_EVENT_START = 30
61 FIXED_EV(SND_SEQ_EVFLG_QUEUE), // SND_SEQ_EVENT_CONTINUE
62 FIXED_EV(SND_SEQ_EVFLG_QUEUE), // SND_SEQ_EVENT_STOP
63 FIXED_EV(SND_SEQ_EVFLG_QUEUE) | _SND_SEQ_TYPE_OPT(SND_SEQ_EVFLG_QUEUE_TICK), // SND_SEQ_EVENT_SETPOS_TICK
64 FIXED_EV(SND_SEQ_EVFLG_QUEUE) | _SND_SEQ_TYPE_OPT(SND_SEQ_EVFLG_QUEUE_TIME), // SND_SEQ_EVENT_SETPOS_TIME
65 FIXED_EV(SND_SEQ_EVFLG_QUEUE) | _SND_SEQ_TYPE_OPT(SND_SEQ_EVFLG_QUEUE_VALUE),// SND_SEQ_EVENT_TEMPO
66 FIXED_EV(SND_SEQ_EVFLG_QUEUE) | _SND_SEQ_TYPE_OPT(SND_SEQ_EVFLG_QUEUE_VALUE),// SND_SEQ_EVENT_CLOCK
67 FIXED_EV(SND_SEQ_EVFLG_QUEUE) | _SND_SEQ_TYPE_OPT(SND_SEQ_EVFLG_QUEUE_VALUE),// SND_SEQ_EVENT_TICK
68 FIXED_EV(SND_SEQ_EVFLG_QUEUE) | _SND_SEQ_TYPE_OPT(SND_SEQ_EVFLG_QUEUE_VALUE),// SND_SEQ_EVENT_QUEUE_SKEW
69 FIXED_EV(SND_SEQ_EVFLG_QUEUE) | _SND_SEQ_TYPE_OPT(SND_SEQ_EVFLG_QUEUE_VALUE),// SND_SEQ_EVENT_SYNC_POS
70 FIXED_EV(SND_SEQ_EVFLG_NONE), // SND_SEQ_EVENT_TUNE_REQUEST = 40
71 FIXED_EV(SND_SEQ_EVFLG_NONE), // SND_SEQ_EVENT_RESET
72 FIXED_EV(SND_SEQ_EVFLG_NONE), // SND_SEQ_EVENT_SENSING
73 0,
74 0,
75 0,
76 0,
77 0,
78 0,
79 0,
80 FIXED_EV(SND_SEQ_EVFLG_RAW) | FIXED_EV(SND_SEQ_EVFLG_SYSTEM), // SND_SEQ_EVENT_ECHO = 50
81 FIXED_EV(SND_SEQ_EVFLG_RAW) | FIXED_EV(SND_SEQ_EVFLG_SYSTEM), // SND_SEQ_EVENT_OSS
82 0,
83 0,
84 0,
85 0,
86 0,
87 0,
88 0,
89 0,
90 FIXED_EV(SND_SEQ_EVFLG_MESSAGE), // SND_SEQ_EVENT_CLIENT_START = 60
91 FIXED_EV(SND_SEQ_EVFLG_MESSAGE), // SND_SEQ_EVENT_CLIENT_EXIT
92 FIXED_EV(SND_SEQ_EVFLG_MESSAGE), // SND_SEQ_EVENT_CLIENT_CHANGE
93 FIXED_EV(SND_SEQ_EVFLG_MESSAGE), // SND_SEQ_EVENT_PORT_START
94 FIXED_EV(SND_SEQ_EVFLG_MESSAGE), // SND_SEQ_EVENT_PORT_EXIT
95 FIXED_EV(SND_SEQ_EVFLG_MESSAGE), // SND_SEQ_EVENT_PORT_CHANGE
96 FIXED_EV(SND_SEQ_EVFLG_CONNECTION), // SND_SEQ_EVENT_PORT_SUBSCRIBED
97 FIXED_EV(SND_SEQ_EVFLG_CONNECTION), // SND_SEQ_EVENT_PORT_UNSUBSCRIBED
98 0,
99 0,
100 FIXED_EV(SND_SEQ_EVFLG_SAMPLE), // SND_SEQ_EVENT_SAMPLE = 70
101 FIXED_EV(SND_SEQ_EVFLG_SAMPLE), // SND_SEQ_EVENT_SAMPLE_CLUSTER
102 FIXED_EV(SND_SEQ_EVFLG_SAMPLE), // SND_SEQ_EVENT_SAMPLE_START
103 FIXED_EV(SND_SEQ_EVFLG_SAMPLE), // SND_SEQ_EVENT_SAMPLE_STOP
104 FIXED_EV(SND_SEQ_EVFLG_SAMPLE), // SND_SEQ_EVENT_SAMPLE_FREQ
105 FIXED_EV(SND_SEQ_EVFLG_SAMPLE), // SND_SEQ_EVENT_SAMPLE_VOLUME
106 FIXED_EV(SND_SEQ_EVFLG_SAMPLE), // SND_SEQ_EVENT_SAMPLE_LOOP
107 FIXED_EV(SND_SEQ_EVFLG_SAMPLE), // SND_SEQ_EVENT_SAMPLE_POSITION
108 FIXED_EV(SND_SEQ_EVFLG_SAMPLE), // SND_SEQ_EVENT_SAMPLE_PRIVATE1
109 0,
110 0, // = 80
111 0,
112 0,
113 0,
114 0,
115 0,
116 0,
117 0,
118 0,
119 0,
120 FIXED_EV(SND_SEQ_EVFLG_RAW) | FIXED_EV(SND_SEQ_EVFLG_USERS), // SND_SEQ_EVENT_USR0 = 90,
121 FIXED_EV(SND_SEQ_EVFLG_RAW) | FIXED_EV(SND_SEQ_EVFLG_USERS), // SND_SEQ_EVENT_USR1
122 FIXED_EV(SND_SEQ_EVFLG_RAW) | FIXED_EV(SND_SEQ_EVFLG_USERS), // SND_SEQ_EVENT_USR2
123 FIXED_EV(SND_SEQ_EVFLG_RAW) | FIXED_EV(SND_SEQ_EVFLG_USERS), // SND_SEQ_EVENT_USR3
124 FIXED_EV(SND_SEQ_EVFLG_RAW) | FIXED_EV(SND_SEQ_EVFLG_USERS), // SND_SEQ_EVENT_USR4
125 FIXED_EV(SND_SEQ_EVFLG_RAW) | FIXED_EV(SND_SEQ_EVFLG_USERS), // SND_SEQ_EVENT_USR5
126 FIXED_EV(SND_SEQ_EVFLG_RAW) | FIXED_EV(SND_SEQ_EVFLG_USERS), // SND_SEQ_EVENT_USR6
127 FIXED_EV(SND_SEQ_EVFLG_RAW) | FIXED_EV(SND_SEQ_EVFLG_USERS), // SND_SEQ_EVENT_USR7
128 FIXED_EV(SND_SEQ_EVFLG_RAW) | FIXED_EV(SND_SEQ_EVFLG_USERS), // SND_SEQ_EVENT_USR8
129 FIXED_EV(SND_SEQ_EVFLG_RAW) | FIXED_EV(SND_SEQ_EVFLG_USERS), // SND_SEQ_EVENT_USR9
130 _SND_SEQ_TYPE(SND_SEQ_EVFLG_INSTR) | _SND_SEQ_TYPE(SND_SEQ_EVFLG_VARUSR), // SND_SEQ_EVENT_INSTR_BEGIN = 100
131 _SND_SEQ_TYPE(SND_SEQ_EVFLG_INSTR) | _SND_SEQ_TYPE(SND_SEQ_EVFLG_VARUSR), // SND_SEQ_EVENT_INSTR_END
132 _SND_SEQ_TYPE(SND_SEQ_EVFLG_INSTR) | _SND_SEQ_TYPE(SND_SEQ_EVFLG_VARUSR), // SND_SEQ_EVENT_INSTR_INFO
133 _SND_SEQ_TYPE(SND_SEQ_EVFLG_INSTR) | _SND_SEQ_TYPE(SND_SEQ_EVFLG_VARUSR), // SND_SEQ_EVENT_INSTR_INFO_RESULT
134 _SND_SEQ_TYPE(SND_SEQ_EVFLG_INSTR) | _SND_SEQ_TYPE(SND_SEQ_EVFLG_VARUSR), // SND_SEQ_EVENT_INSTR_FINFO
135 _SND_SEQ_TYPE(SND_SEQ_EVFLG_INSTR) | _SND_SEQ_TYPE(SND_SEQ_EVFLG_VARUSR), // SND_SEQ_EVENT_INSTR_FINFO_RESULT
136 _SND_SEQ_TYPE(SND_SEQ_EVFLG_INSTR) | _SND_SEQ_TYPE(SND_SEQ_EVFLG_VARUSR), // SND_SEQ_EVENT_INSTR_RESET
137 _SND_SEQ_TYPE(SND_SEQ_EVFLG_INSTR) | _SND_SEQ_TYPE(SND_SEQ_EVFLG_VARUSR), // SND_SEQ_EVENT_INSTR_STATUS
138 _SND_SEQ_TYPE(SND_SEQ_EVFLG_INSTR) | _SND_SEQ_TYPE(SND_SEQ_EVFLG_VARUSR), // SND_SEQ_EVENT_INSTR_STATUS_RESULT
139 _SND_SEQ_TYPE(SND_SEQ_EVFLG_INSTR) | _SND_SEQ_TYPE(SND_SEQ_EVFLG_VARUSR), // SND_SEQ_EVENT_INSTR_PUT
140 _SND_SEQ_TYPE(SND_SEQ_EVFLG_INSTR) | _SND_SEQ_TYPE(SND_SEQ_EVFLG_VARUSR), // SND_SEQ_EVENT_INSTR_GET
141 _SND_SEQ_TYPE(SND_SEQ_EVFLG_INSTR) | _SND_SEQ_TYPE(SND_SEQ_EVFLG_VARUSR), // SND_SEQ_EVENT_INSTR_GET_RESULT
142 _SND_SEQ_TYPE(SND_SEQ_EVFLG_INSTR) | _SND_SEQ_TYPE(SND_SEQ_EVFLG_VARUSR), // SND_SEQ_EVENT_INSTR_FREE
143 _SND_SEQ_TYPE(SND_SEQ_EVFLG_INSTR) | _SND_SEQ_TYPE(SND_SEQ_EVFLG_VARUSR), // SND_SEQ_EVENT_INSTR_LIST
144 _SND_SEQ_TYPE(SND_SEQ_EVFLG_INSTR) | _SND_SEQ_TYPE(SND_SEQ_EVFLG_VARUSR), // SND_SEQ_EVENT_INSTR_LIST_RESULT
145 _SND_SEQ_TYPE(SND_SEQ_EVFLG_INSTR) | _SND_SEQ_TYPE(SND_SEQ_EVFLG_VARUSR), // SND_SEQ_EVENT_INSTR_CLUSTER
146 _SND_SEQ_TYPE(SND_SEQ_EVFLG_INSTR) | _SND_SEQ_TYPE(SND_SEQ_EVFLG_VARUSR), // SND_SEQ_EVENT_INSTR_CLUSTER_GET
147 _SND_SEQ_TYPE(SND_SEQ_EVFLG_INSTR) | _SND_SEQ_TYPE(SND_SEQ_EVFLG_VARUSR), // SND_SEQ_EVENT_INSTR_CLUSTER_RESULT
148 _SND_SEQ_TYPE(SND_SEQ_EVFLG_INSTR) | _SND_SEQ_TYPE(SND_SEQ_EVFLG_VARUSR), // SND_SEQ_EVENT_INSTR_END
149 _SND_SEQ_TYPE(SND_SEQ_EVFLG_INSTR) | _SND_SEQ_TYPE(SND_SEQ_EVFLG_VARUSR), // SND_SEQ_EVENT_INSTR_CHANGE
150 0, // = 120
151 0,
152 0,
153 0,
154 0,
155 0,
156 0,
157 0,
158 0,
159 0,
160 _SND_SEQ_TYPE(SND_SEQ_EVFLG_VARIABLE), // SND_SEQ_EVENT_SYSEX = 130
161 _SND_SEQ_TYPE(SND_SEQ_EVFLG_VARIABLE), // SND_SEQ_EVENT_BOUNCE
162 0,
163 0,
164 0,
165 _SND_SEQ_TYPE(SND_SEQ_EVFLG_VARIABLE) | _SND_SEQ_TYPE(SND_SEQ_EVFLG_USERS),// SND_SEQ_EVENT_USR_VAR0 = 135
166 _SND_SEQ_TYPE(SND_SEQ_EVFLG_VARIABLE) | _SND_SEQ_TYPE(SND_SEQ_EVFLG_USERS),// SND_SEQ_EVENT_USR_VAR1
167 _SND_SEQ_TYPE(SND_SEQ_EVFLG_VARIABLE) | _SND_SEQ_TYPE(SND_SEQ_EVFLG_USERS),// SND_SEQ_EVENT_USR_VAR2
168 _SND_SEQ_TYPE(SND_SEQ_EVFLG_VARIABLE) | _SND_SEQ_TYPE(SND_SEQ_EVFLG_USERS),// SND_SEQ_EVENT_USR_VAR3
169 _SND_SEQ_TYPE(SND_SEQ_EVFLG_VARIABLE) | _SND_SEQ_TYPE(SND_SEQ_EVFLG_USERS),// SND_SEQ_EVENT_USR_VAR4
170 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 140 -> 149
171 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 150 -> 159
172 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 160 -> 169
173 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 170 -> 179
174 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 180 -> 189
175 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 190 -> 199
176 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 200 -> 209
177 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 210 -> 219
178 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 220 -> 229
179 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 230 -> 239
180 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 240 -> 249
181 0, // = 250
182 0,
183 0,
184 0,
185 0,
186 FIXED_EV(SND_SEQ_EVFLG_NONE), // SND_SEQ_EVENT_NONE = 255
187 };
188
189 /*const unsigned int snd_seq_event_types[256] = {
190 [SND_SEQ_EVENT_SYSTEM ... SND_SEQ_EVENT_RESULT]
191 = FIXED_EV(SND_SEQ_EVFLG_RESULT),
192 [SND_SEQ_EVENT_NOTE]
193 = FIXED_EV(SND_SEQ_EVFLG_NOTE) | _SND_SEQ_TYPE_OPT(SND_SEQ_EVFLG_NOTE_TWOARG),
194 [SND_SEQ_EVENT_NOTEON ... SND_SEQ_EVENT_KEYPRESS]
195 = FIXED_EV(SND_SEQ_EVFLG_NOTE),
196 [SND_SEQ_EVENT_CONTROLLER ... SND_SEQ_EVENT_REGPARAM]
197 = FIXED_EV(SND_SEQ_EVFLG_CONTROL),
198 [SND_SEQ_EVENT_START ... SND_SEQ_EVENT_STOP]
199 = FIXED_EV(SND_SEQ_EVFLG_QUEUE),
200 [SND_SEQ_EVENT_SETPOS_TICK]
201 = FIXED_EV(SND_SEQ_EVFLG_QUEUE) | _SND_SEQ_TYPE_OPT(SND_SEQ_EVFLG_QUEUE_TICK),
202 [SND_SEQ_EVENT_SETPOS_TIME]
203 = FIXED_EV(SND_SEQ_EVFLG_QUEUE) | _SND_SEQ_TYPE_OPT(SND_SEQ_EVFLG_QUEUE_TIME),
204 [SND_SEQ_EVENT_TEMPO ... SND_SEQ_EVENT_SYNC_POS]
205 = FIXED_EV(SND_SEQ_EVFLG_QUEUE) | _SND_SEQ_TYPE_OPT(SND_SEQ_EVFLG_QUEUE_VALUE),
206 [SND_SEQ_EVENT_TUNE_REQUEST ... SND_SEQ_EVENT_SENSING]
207 = FIXED_EV(SND_SEQ_EVFLG_NONE),
208 [SND_SEQ_EVENT_ECHO ... SND_SEQ_EVENT_OSS]
209 = FIXED_EV(SND_SEQ_EVFLG_RAW) | FIXED_EV(SND_SEQ_EVFLG_SYSTEM),
210 [SND_SEQ_EVENT_CLIENT_START ... SND_SEQ_EVENT_PORT_CHANGE]
211 = FIXED_EV(SND_SEQ_EVFLG_MESSAGE),
212 [SND_SEQ_EVENT_PORT_SUBSCRIBED ... SND_SEQ_EVENT_PORT_UNSUBSCRIBED]
213 = FIXED_EV(SND_SEQ_EVFLG_CONNECTION),
214 [SND_SEQ_EVENT_SAMPLE ... SND_SEQ_EVENT_SAMPLE_PRIVATE1]
215 = FIXED_EV(SND_SEQ_EVFLG_SAMPLE),
216 [SND_SEQ_EVENT_USR0 ... SND_SEQ_EVENT_USR9]
217 = FIXED_EV(SND_SEQ_EVFLG_RAW) | FIXED_EV(SND_SEQ_EVFLG_USERS),
218 [SND_SEQ_EVENT_INSTR_BEGIN ... SND_SEQ_EVENT_INSTR_CHANGE]
219 = _SND_SEQ_TYPE(SND_SEQ_EVFLG_INSTR) | _SND_SEQ_TYPE(SND_SEQ_EVFLG_VARUSR),
220 [SND_SEQ_EVENT_SYSEX ... SND_SEQ_EVENT_BOUNCE]
221 = _SND_SEQ_TYPE(SND_SEQ_EVFLG_VARIABLE),
222 [SND_SEQ_EVENT_USR_VAR0 ... SND_SEQ_EVENT_USR_VAR4]
223 = _SND_SEQ_TYPE(SND_SEQ_EVFLG_VARIABLE) | _SND_SEQ_TYPE(SND_SEQ_EVFLG_USERS),
224 [SND_SEQ_EVENT_NONE]
225 = FIXED_EV(SND_SEQ_EVFLG_NONE),
226 };*/
227
228 /**
229 * \file seq/seq_midi_event.c
230 * \brief MIDI byte <-> sequencer event coder
231 * \author Takashi Iwai <tiwai@suse.de>
232 * \author Jaroslav Kysela <perex@suse.cz>
233 * \date 2000-2001
234 */
235
236 /*
237 * MIDI byte <-> sequencer event coder
238 *
239 * Copyright (C) 1998,99,2000 Takashi Iwai <tiwai@suse.de>,
240 * Jaroslav Kysela <perex@suse.cz>
241 *
242 *
243 * This library is free software; you can redistribute it and/or modify
244 * it under the terms of the GNU Lesser General Public License as
245 * published by the Free Software Foundation; either version 2.1 of
246 * the License, or (at your option) any later version.
247 *
248 * This program is distributed in the hope that it will be useful,
249 * but WITHOUT ANY WARRANTY; without even the implied warranty of
250 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
251 * GNU Lesser General Public License for more details.
252 *
253 * You should have received a copy of the GNU Lesser General Public
254 * License along with this library; if not, write to the Free Software
255 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
256 */
257
258 /* midi status */
259 struct snd_midi_event {
260 size_t qlen; /* queue length */
261 size_t read; /* chars read */
262 int type; /* current event type */
263 unsigned char lastcmd;
264 unsigned char nostat;
265 size_t bufsize;
266 unsigned char *buf; /* input buffer */
267 };
268
269
270 /* queue type */
271 /* from 0 to 7 are normal commands (note off, on, etc.) */
272 #define ST_NOTEOFF 0
273 #define ST_NOTEON 1
274 #define ST_SPECIAL 8
275 #define ST_SYSEX ST_SPECIAL
276 /* from 8 to 15 are events for 0xf0-0xf7 */
277
278
279 /* status event types */
280 typedef void (*event_encode_t)(snd_midi_event_t *dev, snd_seq_event_t *ev);
281 typedef void (*event_decode_t)(const snd_seq_event_t *ev, unsigned char *buf);
282
283 /*
284 * prototypes
285 */
286 static void note_event(snd_midi_event_t *dev, snd_seq_event_t *ev);
287 static void one_param_ctrl_event(snd_midi_event_t *dev, snd_seq_event_t *ev);
288 static void pitchbend_ctrl_event(snd_midi_event_t *dev, snd_seq_event_t *ev);
289 static void two_param_ctrl_event(snd_midi_event_t *dev, snd_seq_event_t *ev);
290 static void one_param_event(snd_midi_event_t *dev, snd_seq_event_t *ev);
291 static void songpos_event(snd_midi_event_t *dev, snd_seq_event_t *ev);
292 static void note_decode(const snd_seq_event_t *ev, unsigned char *buf);
293 static void one_param_decode(const snd_seq_event_t *ev, unsigned char *buf);
294 static void pitchbend_decode(const snd_seq_event_t *ev, unsigned char *buf);
295 static void two_param_decode(const snd_seq_event_t *ev, unsigned char *buf);
296 static void songpos_decode(const snd_seq_event_t *ev, unsigned char *buf);
297
298 /*
299 * event list
300 */
301 static struct status_event_list_t {
302 int event;
303 int qlen;
304 event_encode_t encode;
305 event_decode_t decode;
306 } status_event[] = {
307 /* 0x80 - 0xf0 */
308 {SND_SEQ_EVENT_NOTEOFF, 2, note_event, note_decode},
309 {SND_SEQ_EVENT_NOTEON, 2, note_event, note_decode},
310 {SND_SEQ_EVENT_KEYPRESS, 2, note_event, note_decode},
311 {SND_SEQ_EVENT_CONTROLLER, 2, two_param_ctrl_event, two_param_decode},
312 {SND_SEQ_EVENT_PGMCHANGE, 1, one_param_ctrl_event, one_param_decode},
313 {SND_SEQ_EVENT_CHANPRESS, 1, one_param_ctrl_event, one_param_decode},
314 {SND_SEQ_EVENT_PITCHBEND, 2, pitchbend_ctrl_event, pitchbend_decode},
315 {SND_SEQ_EVENT_NONE, 0, NULL, NULL}, /* 0xf0 */
316 /* 0xf0 - 0xff */
317 {SND_SEQ_EVENT_SYSEX, 1, NULL, NULL}, /* sysex: 0xf0 */
318 {SND_SEQ_EVENT_QFRAME, 1, one_param_event, one_param_decode}, /* 0xf1 */
319 {SND_SEQ_EVENT_SONGPOS, 2, songpos_event, songpos_decode}, /* 0xf2 */
320 {SND_SEQ_EVENT_SONGSEL, 1, one_param_event, one_param_decode}, /* 0xf3 */
321 {SND_SEQ_EVENT_NONE, 0, NULL, NULL}, /* 0xf4 */
322 {SND_SEQ_EVENT_NONE, 0, NULL, NULL}, /* 0xf5 */
323 {SND_SEQ_EVENT_TUNE_REQUEST, 0, NULL, NULL}, /* 0xf6 */
324 {SND_SEQ_EVENT_NONE, 0, NULL, NULL}, /* 0xf7 */
325 {SND_SEQ_EVENT_CLOCK, 0, NULL, NULL}, /* 0xf8 */
326 {SND_SEQ_EVENT_NONE, 0, NULL, NULL}, /* 0xf9 */
327 {SND_SEQ_EVENT_START, 0, NULL, NULL}, /* 0xfa */
328 {SND_SEQ_EVENT_CONTINUE, 0, NULL, NULL}, /* 0xfb */
329 {SND_SEQ_EVENT_STOP, 0, NULL, NULL}, /* 0xfc */
330 {SND_SEQ_EVENT_NONE, 0, NULL, NULL}, /* 0xfd */
331 {SND_SEQ_EVENT_SENSING, 0, NULL, NULL}, /* 0xfe */
332 {SND_SEQ_EVENT_RESET, 0, NULL, NULL}, /* 0xff */
333 };
334
335 #ifdef UNNEEDED_BY_DSSI
336 static int extra_decode_ctrl14(snd_midi_event_t *dev, unsigned char *buf, int len, const snd_seq_event_t *ev);
337 static int extra_decode_xrpn(snd_midi_event_t *dev, unsigned char *buf, int count, const snd_seq_event_t *ev);
338
339 static struct extra_event_list_t {
340 int event;
341 int (*decode)(snd_midi_event_t *dev, unsigned char *buf, int len, const snd_seq_event_t *ev);
342 } extra_event[] = {
343 {SND_SEQ_EVENT_CONTROL14, extra_decode_ctrl14},
344 {SND_SEQ_EVENT_NONREGPARAM, extra_decode_xrpn},
345 {SND_SEQ_EVENT_REGPARAM, extra_decode_xrpn},
346 };
347
348 #define numberof(ary) (sizeof(ary)/sizeof(ary[0]))
349 #endif /* UNNEEDED_BY_DSSI */
350
351 /**
352 * \brief Initialize MIDI event parser
353 * \param bufsize buffer size for MIDI message
354 * \param rdev allocated MIDI event parser
355 * \return 0 on success otherwise a negative error code
356 *
357 * Allocates and initializes MIDI event parser.
358 */
359 int snd_midi_event_new(size_t bufsize, snd_midi_event_t **rdev)
360 {
361 snd_midi_event_t *dev;
362
363 *rdev = NULL;
364 dev = (snd_midi_event_t *)calloc(1, sizeof(snd_midi_event_t));
365 if (dev == NULL)
366 return -ENOMEM;
367 if (bufsize > 0) {
368 dev->buf = malloc(bufsize);
369 if (dev->buf == NULL) {
370 free(dev);
371 return -ENOMEM;
372 }
373 }
374 dev->bufsize = bufsize;
375 dev->lastcmd = 0xff;
376 *rdev = dev;
377 return 0;
378 }
379
380 /**
381 * \brief Free MIDI event parser
382 * \param rdev MIDI event parser
383 * \return 0 on success otherwise a negative error code
384 *
385 * Frees MIDI event parser.
386 */
387 void snd_midi_event_free(snd_midi_event_t *dev)
388 {
389 if (dev != NULL) {
390 if (dev->buf)
391 free(dev->buf);
392 free(dev);
393 }
394 }
395
396 #ifdef UNNEEDED_BY_DSSI
397 /**
398 * \brief Enable/disable MIDI command merging
399 * \param dev MIDI event parser
400 * \param on 0 - enable MIDI command merging, 1 - always pass the command
401 *
402 * Enable/disable MIDI command merging
403 */
404 void snd_midi_event_no_status(snd_midi_event_t *dev, int on)
405 {
406 dev->nostat = on ? 1 : 0;
407 }
408 #endif /* UNNEEDED_BY_DSSI */
409
410 /*
411 * initialize record
412 */
413 //inline static void reset_encode(snd_midi_event_t *dev)
414 static void reset_encode(snd_midi_event_t *dev)
415 {
416 dev->read = 0;
417 dev->qlen = 0;
418 dev->type = 0;
419 }
420
421 /**
422 * \brief Reset MIDI encode parser
423 * \param dev MIDI event parser
424 * \return 0 on success otherwise a negative error code
425 *
426 * Resets MIDI encode parser
427 */
428 void snd_midi_event_reset_encode(snd_midi_event_t *dev)
429 {
430 reset_encode(dev);
431 }
432
433 #ifdef UNNEEDED_BY_DSSI
434 /**
435 * \brief Reset MIDI decode parser
436 * \param dev MIDI event parser
437 * \return 0 on success otherwise a negative error code
438 *
439 * Resets MIDI decode parser
440 */
441 void snd_midi_event_reset_decode(snd_midi_event_t *dev)
442 {
443 dev->lastcmd = 0xff;
444 }
445
446 /**
447 * \brief Initializes MIDI parsers
448 * \param dev MIDI event parser
449 * \return 0 on success otherwise a negative error code
450 *
451 * Initializes MIDI parsers (both encode and decode)
452 */
453 void snd_midi_event_init(snd_midi_event_t *dev)
454 {
455 snd_midi_event_reset_encode(dev);
456 snd_midi_event_reset_decode(dev);
457 }
458
459 /**
460 * \brief Resize MIDI message (event) buffer
461 * \param dev MIDI event parser
462 * \param bufsize new requested buffer size
463 * \return 0 on success otherwise a negative error code
464 *
465 * Resizes MIDI message (event) buffer.
466 */
467 int snd_midi_event_resize_buffer(snd_midi_event_t *dev, size_t bufsize)
468 {
469 unsigned char *new_buf, *old_buf;
470
471 if (bufsize == dev->bufsize)
472 return 0;
473 new_buf = malloc(bufsize);
474 if (new_buf == NULL)
475 return -ENOMEM;
476 old_buf = dev->buf;
477 dev->buf = new_buf;
478 dev->bufsize = bufsize;
479 reset_encode(dev);
480 if (old_buf)
481 free(old_buf);
482 return 0;
483 }
484 #endif /* UNNEEDED_BY_DSSI */
485
486 /**
487 * \brief Read bytes and encode to sequencer event if finished
488 * \param dev MIDI event parser
489 * \param buf MIDI byte stream
490 * \param count count of bytes of MIDI byte stream to encode
491 * \param ev Result - sequencer event
492 * \return count of encoded bytes otherwise a negative error code
493 *
494 * Read bytes and encode to sequencer event if finished.
495 * If complete sequencer event is available, ev->type is not
496 * equal to #SND_SEQ_EVENT_NONE.
497 */
498 long snd_midi_event_encode(snd_midi_event_t *dev, const unsigned char *buf, long count, snd_seq_event_t *ev)
499 {
500 long result = 0;
501 int rc;
502
503 ev->type = SND_SEQ_EVENT_NONE;
504
505 while (count-- > 0) {
506 rc = snd_midi_event_encode_byte(dev, *buf++, ev);
507 result++;
508 if (rc < 0)
509 return rc;
510 else if (rc > 0)
511 return result;
512 }
513
514 return result;
515 }
516
517 /**
518 * \brief Read one byte and encode to sequencer event if finished
519 * \param dev MIDI event parser
520 * \param c a byte of MIDI stream
521 * \param ev Result - sequencer event
522 * \return 1 - sequencer event is completed, 0 - next byte is required for completion, otherwise a negative error code
523 *
524 * Read byte and encode to sequencer event if finished.
525 */
526 int snd_midi_event_encode_byte(snd_midi_event_t *dev, int c, snd_seq_event_t *ev)
527 {
528 int rc = 0;
529
530 c &= 0xff;
531
532 if (c >= MIDI_CMD_COMMON_CLOCK) {
533 /* real-time event */
534 ev->type = status_event[ST_SPECIAL + c - 0xf0].event;
535 ev->flags &= ~SNDRV_SEQ_EVENT_LENGTH_MASK;
536 ev->flags |= SNDRV_SEQ_EVENT_LENGTH_FIXED;
537 return 1;
538 }
539
540 if (dev->qlen > 0) {
541 /* rest of command */
542 dev->buf[dev->read++] = c;
543 if (dev->type != ST_SYSEX)
544 dev->qlen--;
545 } else {
546 /* new command */
547 dev->read = 1;
548 if (c & 0x80) {
549 dev->buf[0] = c;
550 if ((c & 0xf0) == 0xf0) /* special events */
551 dev->type = (c & 0x0f) + ST_SPECIAL;
552 else
553 dev->type = (c >> 4) & 0x07;
554 dev->qlen = status_event[dev->type].qlen;
555 } else {
556 /* process this byte as argument */
557 dev->buf[dev->read++] = c;
558 dev->qlen = status_event[dev->type].qlen - 1;
559 }
560 }
561 if (dev->qlen == 0) {
562 ev->type = status_event[dev->type].event;
563 ev->flags &= ~SNDRV_SEQ_EVENT_LENGTH_MASK;
564 ev->flags |= SNDRV_SEQ_EVENT_LENGTH_FIXED;
565 if (status_event[dev->type].encode) /* set data values */
566 status_event[dev->type].encode(dev, ev);
567 rc = 1;
568 } else if (dev->type == ST_SYSEX) {
569 if (c == MIDI_CMD_COMMON_SYSEX_END ||
570 dev->read >= dev->bufsize) {
571 ev->flags &= ~SNDRV_SEQ_EVENT_LENGTH_MASK;
572 ev->flags |= SNDRV_SEQ_EVENT_LENGTH_VARIABLE;
573 ev->type = SNDRV_SEQ_EVENT_SYSEX;
574 ev->data.ext.len = dev->read;
575 ev->data.ext.ptr = dev->buf;
576 if (c != MIDI_CMD_COMMON_SYSEX_END)
577 dev->read = 0; /* continue to parse */
578 else
579 reset_encode(dev); /* all parsed */
580 rc = 1;
581 }
582 }
583
584 return rc;
585 }
586
587 /* encode note event */
588 static void note_event(snd_midi_event_t *dev, snd_seq_event_t *ev)
589 {
590 ev->data.note.channel = dev->buf[0] & 0x0f;
591 ev->data.note.note = dev->buf[1];
592 ev->data.note.velocity = dev->buf[2];
593 }
594
595 /* encode one parameter controls */
596 static void one_param_ctrl_event(snd_midi_event_t *dev, snd_seq_event_t *ev)
597 {
598 ev->data.control.channel = dev->buf[0] & 0x0f;
599 ev->data.control.value = dev->buf[1];
600 }
601
602 /* encode pitch wheel change */
603 static void pitchbend_ctrl_event(snd_midi_event_t *dev, snd_seq_event_t *ev)
604 {
605 ev->data.control.channel = dev->buf[0] & 0x0f;
606 ev->data.control.value = (int)dev->buf[2] * 128 + (int)dev->buf[1] - 8192;
607 }
608
609 /* encode midi control change */
610 static void two_param_ctrl_event(snd_midi_event_t *dev, snd_seq_event_t *ev)
611 {
612 ev->data.control.channel = dev->buf[0] & 0x0f;
613 ev->data.control.param = dev->buf[1];
614 ev->data.control.value = dev->buf[2];
615 }
616
617 /* encode one parameter value*/
618 static void one_param_event(snd_midi_event_t *dev, snd_seq_event_t *ev)
619 {
620 ev->data.control.value = dev->buf[1];
621 }
622
623 /* encode song position */
624 static void songpos_event(snd_midi_event_t *dev, snd_seq_event_t *ev)
625 {
626 ev->data.control.value = (int)dev->buf[2] * 128 + (int)dev->buf[1];
627 }
628
629 #ifdef UNNEEDED_BY_DSSI
630 /**
631 * \brief Decode sequencer event to MIDI byte stream
632 * \param dev MIDI event parser
633 * \param buf Result - MIDI byte stream
634 * \param count Available bytes in MIDI byte stream
635 * \param ev Event to decode
636 * \return count of decoded bytes otherwise a negative error code
637 *
638 * Decode sequencer event to MIDI byte stream.
639 */
640 long snd_midi_event_decode(snd_midi_event_t *dev, unsigned char *buf, long count, const snd_seq_event_t *ev)
641 {
642 int cmd;
643 long qlen;
644 unsigned int type;
645
646 if (ev->type == SNDRV_SEQ_EVENT_NONE)
647 return -ENOENT;
648
649 for (type = 0; type < numberof(status_event); type++) {
650 if (ev->type == status_event[type].event)
651 goto __found;
652 }
653 for (type = 0; type < numberof(extra_event); type++) {
654 if (ev->type == extra_event[type].event)
655 return extra_event[type].decode(dev, buf, count, ev);
656 }
657 return -ENOENT;
658
659 __found:
660 if (type >= ST_SPECIAL)
661 cmd = 0xf0 + (type - ST_SPECIAL);
662 else
663 /* data.note.channel and data.control.channel is identical */
664 cmd = 0x80 | (type << 4) | (ev->data.note.channel & 0x0f);
665
666
667 if (cmd == MIDI_CMD_COMMON_SYSEX) {
668 qlen = ev->data.ext.len;
669 if (count < qlen)
670 return -ENOMEM;
671 switch (ev->flags & SNDRV_SEQ_EVENT_LENGTH_MASK) {
672 case SNDRV_SEQ_EVENT_LENGTH_FIXED:
673 return -EINVAL; /* invalid event */
674 }
675 memcpy(buf, ev->data.ext.ptr, qlen);
676 return qlen;
677 } else {
678 unsigned char xbuf[4];
679
680 if ((cmd & 0xf0) == 0xf0 || dev->lastcmd != cmd || dev->nostat) {
681 dev->lastcmd = cmd;
682 xbuf[0] = cmd;
683 if (status_event[type].decode)
684 status_event[type].decode(ev, xbuf + 1);
685 qlen = status_event[type].qlen + 1;
686 } else {
687 if (status_event[type].decode)
688 status_event[type].decode(ev, xbuf + 0);
689 qlen = status_event[type].qlen;
690 }
691 if (count < qlen)
692 return -ENOMEM;
693 memcpy(buf, xbuf, qlen);
694 return qlen;
695 }
696 }
697 #endif /* UNNEEDED_BY_DSSI */
698
699 /* decode note event */
700 static void note_decode(const snd_seq_event_t *ev, unsigned char *buf)
701 {
702 buf[0] = ev->data.note.note & 0x7f;
703 buf[1] = ev->data.note.velocity & 0x7f;
704 }
705
706 /* decode one parameter controls */
707 static void one_param_decode(const snd_seq_event_t *ev, unsigned char *buf)
708 {
709 buf[0] = ev->data.control.value & 0x7f;
710 }
711
712 /* decode pitch wheel change */
713 static void pitchbend_decode(const snd_seq_event_t *ev, unsigned char *buf)
714 {
715 int value = ev->data.control.value + 8192;
716 buf[0] = value & 0x7f;
717 buf[1] = (value >> 7) & 0x7f;
718 }
719
720 /* decode midi control change */
721 static void two_param_decode(const snd_seq_event_t *ev, unsigned char *buf)
722 {
723 buf[0] = ev->data.control.param & 0x7f;
724 buf[1] = ev->data.control.value & 0x7f;
725 }
726
727 /* decode song position */
728 static void songpos_decode(const snd_seq_event_t *ev, unsigned char *buf)
729 {
730 buf[0] = ev->data.control.value & 0x7f;
731 buf[1] = (ev->data.control.value >> 7) & 0x7f;
732 }
733
734 #ifdef UNNEEDED_BY_DSSI
735 /* decode 14bit control */
736 static int extra_decode_ctrl14(snd_midi_event_t *dev, unsigned char *buf, int count, const snd_seq_event_t *ev)
737 {
738 unsigned char cmd;
739 int idx = 0;
740
741 cmd = MIDI_CMD_CONTROL|(ev->data.control.channel & 0x0f);
742 if (ev->data.control.param < 32) {
743 if (count < 4)
744 return -ENOMEM;
745 if (dev->nostat && count < 6)
746 return -ENOMEM;
747 if (cmd != dev->lastcmd || dev->nostat) {
748 if (count < 5)
749 return -ENOMEM;
750 buf[idx++] = dev->lastcmd = cmd;
751 }
752 buf[idx++] = ev->data.control.param;
753 buf[idx++] = (ev->data.control.value >> 7) & 0x7f;
754 if (dev->nostat)
755 buf[idx++] = cmd;
756 buf[idx++] = ev->data.control.param + 32;
757 buf[idx++] = ev->data.control.value & 0x7f;
758 } else {
759 if (count < 2)
760 return -ENOMEM;
761 if (cmd != dev->lastcmd || dev->nostat) {
762 if (count < 3)
763 return -ENOMEM;
764 buf[idx++] = dev->lastcmd = cmd;
765 }
766 buf[idx++] = ev->data.control.param & 0x7f;
767 buf[idx++] = ev->data.control.value & 0x7f;
768 }
769 return idx;
770 }
771
772 /* decode reg/nonreg param */
773 static int extra_decode_xrpn(snd_midi_event_t *dev, unsigned char *buf, int count, const snd_seq_event_t *ev)
774 {
775 unsigned char cmd;
776 char *cbytes;
777 static char cbytes_nrpn[4] = { MIDI_CTL_NONREG_PARM_NUM_MSB,
778 MIDI_CTL_NONREG_PARM_NUM_LSB,
779 MIDI_CTL_MSB_DATA_ENTRY,
780 MIDI_CTL_LSB_DATA_ENTRY };
781 static char cbytes_rpn[4] = { MIDI_CTL_REGIST_PARM_NUM_MSB,
782 MIDI_CTL_REGIST_PARM_NUM_LSB,
783 MIDI_CTL_MSB_DATA_ENTRY,
784 MIDI_CTL_LSB_DATA_ENTRY };
785 unsigned char bytes[4];
786 int idx = 0, i;
787
788 if (count < 8)
789 return -ENOMEM;
790 if (dev->nostat && count < 12)
791 return -ENOMEM;
792 cmd = MIDI_CMD_CONTROL|(ev->data.control.channel & 0x0f);
793 bytes[0] = ev->data.control.param & 0x007f;
794 bytes[1] = (ev->data.control.param & 0x3f80) >> 7;
795 bytes[2] = ev->data.control.value & 0x007f;
796 bytes[3] = (ev->data.control.value & 0x3f80) >> 7;
797 if (cmd != dev->lastcmd && !dev->nostat) {
798 if (count < 9)
799 return -ENOMEM;
800 buf[idx++] = dev->lastcmd = cmd;
801 }
802 cbytes = ev->type == SND_SEQ_EVENT_NONREGPARAM ? cbytes_nrpn : cbytes_rpn;
803 for (i = 0; i < 4; i++) {
804 if (dev->nostat)
805 buf[idx++] = dev->lastcmd = cmd;
806 buf[idx++] = cbytes[i];
807 buf[idx++] = bytes[i];
808 }
809 return idx;
810 }
811 #endif /* UNNEEDED_BY_DSSI */