2 * MIDI byte <-> sequencer event coder
4 * Copyright (C) 1998,99 Takashi Iwai <tiwai@suse.de>,
5 * Jaroslav Kysela <perex@suse.cz>
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.
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.
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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
22 #include <sound/driver.h>
23 #include <linux/slab.h>
24 #include <linux/errno.h>
25 #include <linux/string.h>
26 #include <sound/core.h>
27 #include <sound/seq_kernel.h>
28 #include <sound/seq_midi_event.h>
29 #include <sound/asoundef.h>
31 MODULE_AUTHOR("Takashi Iwai <tiwai@suse.de>, Jaroslav Kysela <perex@suse.cz>");
32 MODULE_DESCRIPTION("MIDI byte <-> sequencer event coder");
33 MODULE_LICENSE("GPL");
36 /* from 0 to 7 are normal commands (note off, on, etc.) */
40 #define ST_SYSEX ST_SPECIAL
41 /* from 8 to 15 are events for 0xf0-0xf7 */
44 /* status event types */
45 typedef void (*event_encode_t
)(snd_midi_event_t
*dev
, snd_seq_event_t
*ev
);
46 typedef void (*event_decode_t
)(snd_seq_event_t
*ev
, unsigned char *buf
);
51 static void note_event(snd_midi_event_t
*dev
, snd_seq_event_t
*ev
);
52 static void one_param_ctrl_event(snd_midi_event_t
*dev
, snd_seq_event_t
*ev
);
53 static void pitchbend_ctrl_event(snd_midi_event_t
*dev
, snd_seq_event_t
*ev
);
54 static void two_param_ctrl_event(snd_midi_event_t
*dev
, snd_seq_event_t
*ev
);
55 static void one_param_event(snd_midi_event_t
*dev
, snd_seq_event_t
*ev
);
56 static void songpos_event(snd_midi_event_t
*dev
, snd_seq_event_t
*ev
);
57 static void note_decode(snd_seq_event_t
*ev
, unsigned char *buf
);
58 static void one_param_decode(snd_seq_event_t
*ev
, unsigned char *buf
);
59 static void pitchbend_decode(snd_seq_event_t
*ev
, unsigned char *buf
);
60 static void two_param_decode(snd_seq_event_t
*ev
, unsigned char *buf
);
61 static void songpos_decode(snd_seq_event_t
*ev
, unsigned char *buf
);
66 static struct status_event_list_t
{
69 event_encode_t encode
;
70 event_decode_t decode
;
73 {SNDRV_SEQ_EVENT_NOTEOFF
, 2, note_event
, note_decode
},
74 {SNDRV_SEQ_EVENT_NOTEON
, 2, note_event
, note_decode
},
75 {SNDRV_SEQ_EVENT_KEYPRESS
, 2, note_event
, note_decode
},
76 {SNDRV_SEQ_EVENT_CONTROLLER
, 2, two_param_ctrl_event
, two_param_decode
},
77 {SNDRV_SEQ_EVENT_PGMCHANGE
, 1, one_param_ctrl_event
, one_param_decode
},
78 {SNDRV_SEQ_EVENT_CHANPRESS
, 1, one_param_ctrl_event
, one_param_decode
},
79 {SNDRV_SEQ_EVENT_PITCHBEND
, 2, pitchbend_ctrl_event
, pitchbend_decode
},
80 {SNDRV_SEQ_EVENT_NONE
, 0, NULL
, NULL
}, /* 0xf0 */
82 {SNDRV_SEQ_EVENT_SYSEX
, 1, NULL
, NULL
}, /* sysex: 0xf0 */
83 {SNDRV_SEQ_EVENT_QFRAME
, 1, one_param_event
, one_param_decode
}, /* 0xf1 */
84 {SNDRV_SEQ_EVENT_SONGPOS
, 2, songpos_event
, songpos_decode
}, /* 0xf2 */
85 {SNDRV_SEQ_EVENT_SONGSEL
, 1, one_param_event
, one_param_decode
}, /* 0xf3 */
86 {SNDRV_SEQ_EVENT_NONE
, 0, NULL
, NULL
}, /* 0xf4 */
87 {SNDRV_SEQ_EVENT_NONE
, 0, NULL
, NULL
}, /* 0xf5 */
88 {SNDRV_SEQ_EVENT_TUNE_REQUEST
, 0, NULL
, NULL
}, /* 0xf6 */
89 {SNDRV_SEQ_EVENT_NONE
, 0, NULL
, NULL
}, /* 0xf7 */
90 {SNDRV_SEQ_EVENT_CLOCK
, 0, NULL
, NULL
}, /* 0xf8 */
91 {SNDRV_SEQ_EVENT_NONE
, 0, NULL
, NULL
}, /* 0xf9 */
92 {SNDRV_SEQ_EVENT_START
, 0, NULL
, NULL
}, /* 0xfa */
93 {SNDRV_SEQ_EVENT_CONTINUE
, 0, NULL
, NULL
}, /* 0xfb */
94 {SNDRV_SEQ_EVENT_STOP
, 0, NULL
, NULL
}, /* 0xfc */
95 {SNDRV_SEQ_EVENT_NONE
, 0, NULL
, NULL
}, /* 0xfd */
96 {SNDRV_SEQ_EVENT_SENSING
, 0, NULL
, NULL
}, /* 0xfe */
97 {SNDRV_SEQ_EVENT_RESET
, 0, NULL
, NULL
}, /* 0xff */
100 static int extra_decode_ctrl14(snd_midi_event_t
*dev
, unsigned char *buf
, int len
, snd_seq_event_t
*ev
);
101 static int extra_decode_xrpn(snd_midi_event_t
*dev
, unsigned char *buf
, int count
, snd_seq_event_t
*ev
);
103 static struct extra_event_list_t
{
105 int (*decode
)(snd_midi_event_t
*dev
, unsigned char *buf
, int len
, snd_seq_event_t
*ev
);
107 {SNDRV_SEQ_EVENT_CONTROL14
, extra_decode_ctrl14
},
108 {SNDRV_SEQ_EVENT_NONREGPARAM
, extra_decode_xrpn
},
109 {SNDRV_SEQ_EVENT_REGPARAM
, extra_decode_xrpn
},
116 int snd_midi_event_new(int bufsize
, snd_midi_event_t
**rdev
)
118 snd_midi_event_t
*dev
;
121 dev
= kcalloc(1, sizeof(*dev
), GFP_KERNEL
);
125 dev
->buf
= kmalloc(bufsize
, GFP_KERNEL
);
126 if (dev
->buf
== NULL
) {
131 dev
->bufsize
= bufsize
;
133 spin_lock_init(&dev
->lock
);
138 void snd_midi_event_free(snd_midi_event_t
*dev
)
149 static inline void reset_encode(snd_midi_event_t
*dev
)
156 void snd_midi_event_reset_encode(snd_midi_event_t
*dev
)
160 spin_lock_irqsave(&dev
->lock
, flags
);
162 spin_unlock_irqrestore(&dev
->lock
, flags
);
165 void snd_midi_event_reset_decode(snd_midi_event_t
*dev
)
169 spin_lock_irqsave(&dev
->lock
, flags
);
171 spin_unlock_irqrestore(&dev
->lock
, flags
);
175 void snd_midi_event_init(snd_midi_event_t
*dev
)
177 snd_midi_event_reset_encode(dev
);
178 snd_midi_event_reset_decode(dev
);
182 void snd_midi_event_no_status(snd_midi_event_t
*dev
, int on
)
184 dev
->nostat
= on
? 1 : 0;
191 int snd_midi_event_resize_buffer(snd_midi_event_t
*dev
, int bufsize
)
193 unsigned char *new_buf
, *old_buf
;
196 if (bufsize
== dev
->bufsize
)
198 new_buf
= kmalloc(bufsize
, GFP_KERNEL
);
201 spin_lock_irqsave(&dev
->lock
, flags
);
204 dev
->bufsize
= bufsize
;
206 spin_unlock_irqrestore(&dev
->lock
, flags
);
213 * read bytes and encode to sequencer event if finished
214 * return the size of encoded bytes
216 long snd_midi_event_encode(snd_midi_event_t
*dev
, unsigned char *buf
, long count
, snd_seq_event_t
*ev
)
221 ev
->type
= SNDRV_SEQ_EVENT_NONE
;
223 while (count
-- > 0) {
224 rc
= snd_midi_event_encode_byte(dev
, *buf
++, ev
);
236 * read one byte and encode to sequencer event:
237 * return 1 if MIDI bytes are encoded to an event
238 * 0 data is not finished
241 int snd_midi_event_encode_byte(snd_midi_event_t
*dev
, int c
, snd_seq_event_t
*ev
)
248 if (c
>= MIDI_CMD_COMMON_CLOCK
) {
249 /* real-time event */
250 ev
->type
= status_event
[ST_SPECIAL
+ c
- 0xf0].event
;
251 ev
->flags
&= ~SNDRV_SEQ_EVENT_LENGTH_MASK
;
252 ev
->flags
|= SNDRV_SEQ_EVENT_LENGTH_FIXED
;
256 spin_lock_irqsave(&dev
->lock
, flags
);
258 /* rest of command */
259 dev
->buf
[dev
->read
++] = c
;
260 if (dev
->type
!= ST_SYSEX
)
267 if ((c
& 0xf0) == 0xf0) /* special events */
268 dev
->type
= (c
& 0x0f) + ST_SPECIAL
;
270 dev
->type
= (c
>> 4) & 0x07;
271 dev
->qlen
= status_event
[dev
->type
].qlen
;
273 /* process this byte as argument */
274 dev
->buf
[dev
->read
++] = c
;
275 dev
->qlen
= status_event
[dev
->type
].qlen
- 1;
278 if (dev
->qlen
== 0) {
279 ev
->type
= status_event
[dev
->type
].event
;
280 ev
->flags
&= ~SNDRV_SEQ_EVENT_LENGTH_MASK
;
281 ev
->flags
|= SNDRV_SEQ_EVENT_LENGTH_FIXED
;
282 if (status_event
[dev
->type
].encode
) /* set data values */
283 status_event
[dev
->type
].encode(dev
, ev
);
285 } else if (dev
->type
== ST_SYSEX
) {
286 if (c
== MIDI_CMD_COMMON_SYSEX_END
||
287 dev
->read
>= dev
->bufsize
) {
288 ev
->flags
&= ~SNDRV_SEQ_EVENT_LENGTH_MASK
;
289 ev
->flags
|= SNDRV_SEQ_EVENT_LENGTH_VARIABLE
;
290 ev
->type
= SNDRV_SEQ_EVENT_SYSEX
;
291 ev
->data
.ext
.len
= dev
->read
;
292 ev
->data
.ext
.ptr
= dev
->buf
;
293 if (c
!= MIDI_CMD_COMMON_SYSEX_END
)
294 dev
->read
= 0; /* continue to parse */
296 reset_encode(dev
); /* all parsed */
301 spin_unlock_irqrestore(&dev
->lock
, flags
);
305 /* encode note event */
306 static void note_event(snd_midi_event_t
*dev
, snd_seq_event_t
*ev
)
308 ev
->data
.note
.channel
= dev
->buf
[0] & 0x0f;
309 ev
->data
.note
.note
= dev
->buf
[1];
310 ev
->data
.note
.velocity
= dev
->buf
[2];
313 /* encode one parameter controls */
314 static void one_param_ctrl_event(snd_midi_event_t
*dev
, snd_seq_event_t
*ev
)
316 ev
->data
.control
.channel
= dev
->buf
[0] & 0x0f;
317 ev
->data
.control
.value
= dev
->buf
[1];
320 /* encode pitch wheel change */
321 static void pitchbend_ctrl_event(snd_midi_event_t
*dev
, snd_seq_event_t
*ev
)
323 ev
->data
.control
.channel
= dev
->buf
[0] & 0x0f;
324 ev
->data
.control
.value
= (int)dev
->buf
[2] * 128 + (int)dev
->buf
[1] - 8192;
327 /* encode midi control change */
328 static void two_param_ctrl_event(snd_midi_event_t
*dev
, snd_seq_event_t
*ev
)
330 ev
->data
.control
.channel
= dev
->buf
[0] & 0x0f;
331 ev
->data
.control
.param
= dev
->buf
[1];
332 ev
->data
.control
.value
= dev
->buf
[2];
335 /* encode one parameter value*/
336 static void one_param_event(snd_midi_event_t
*dev
, snd_seq_event_t
*ev
)
338 ev
->data
.control
.value
= dev
->buf
[1];
341 /* encode song position */
342 static void songpos_event(snd_midi_event_t
*dev
, snd_seq_event_t
*ev
)
344 ev
->data
.control
.value
= (int)dev
->buf
[2] * 128 + (int)dev
->buf
[1];
348 * decode from a sequencer event to midi bytes
349 * return the size of decoded midi events
351 long snd_midi_event_decode(snd_midi_event_t
*dev
, unsigned char *buf
, long count
, snd_seq_event_t
*ev
)
353 unsigned int cmd
, type
;
355 if (ev
->type
== SNDRV_SEQ_EVENT_NONE
)
358 for (type
= 0; type
< ARRAY_SIZE(status_event
); type
++) {
359 if (ev
->type
== status_event
[type
].event
)
362 for (type
= 0; type
< ARRAY_SIZE(extra_event
); type
++) {
363 if (ev
->type
== extra_event
[type
].event
)
364 return extra_event
[type
].decode(dev
, buf
, count
, ev
);
369 if (type
>= ST_SPECIAL
)
370 cmd
= 0xf0 + (type
- ST_SPECIAL
);
372 /* data.note.channel and data.control.channel is identical */
373 cmd
= 0x80 | (type
<< 4) | (ev
->data
.note
.channel
& 0x0f);
376 if (cmd
== MIDI_CMD_COMMON_SYSEX
) {
377 snd_midi_event_reset_decode(dev
);
378 return snd_seq_expand_var_event(ev
, count
, buf
, 1, 0);
381 unsigned char xbuf
[4];
384 spin_lock_irqsave(&dev
->lock
, flags
);
385 if ((cmd
& 0xf0) == 0xf0 || dev
->lastcmd
!= cmd
|| dev
->nostat
) {
387 spin_unlock_irqrestore(&dev
->lock
, flags
);
389 if (status_event
[type
].decode
)
390 status_event
[type
].decode(ev
, xbuf
+ 1);
391 qlen
= status_event
[type
].qlen
+ 1;
393 spin_unlock_irqrestore(&dev
->lock
, flags
);
394 if (status_event
[type
].decode
)
395 status_event
[type
].decode(ev
, xbuf
+ 0);
396 qlen
= status_event
[type
].qlen
;
400 memcpy(buf
, xbuf
, qlen
);
406 /* decode note event */
407 static void note_decode(snd_seq_event_t
*ev
, unsigned char *buf
)
409 buf
[0] = ev
->data
.note
.note
& 0x7f;
410 buf
[1] = ev
->data
.note
.velocity
& 0x7f;
413 /* decode one parameter controls */
414 static void one_param_decode(snd_seq_event_t
*ev
, unsigned char *buf
)
416 buf
[0] = ev
->data
.control
.value
& 0x7f;
419 /* decode pitch wheel change */
420 static void pitchbend_decode(snd_seq_event_t
*ev
, unsigned char *buf
)
422 int value
= ev
->data
.control
.value
+ 8192;
423 buf
[0] = value
& 0x7f;
424 buf
[1] = (value
>> 7) & 0x7f;
427 /* decode midi control change */
428 static void two_param_decode(snd_seq_event_t
*ev
, unsigned char *buf
)
430 buf
[0] = ev
->data
.control
.param
& 0x7f;
431 buf
[1] = ev
->data
.control
.value
& 0x7f;
434 /* decode song position */
435 static void songpos_decode(snd_seq_event_t
*ev
, unsigned char *buf
)
437 buf
[0] = ev
->data
.control
.value
& 0x7f;
438 buf
[1] = (ev
->data
.control
.value
>> 7) & 0x7f;
441 /* decode 14bit control */
442 static int extra_decode_ctrl14(snd_midi_event_t
*dev
, unsigned char *buf
, int count
, snd_seq_event_t
*ev
)
447 cmd
= MIDI_CMD_CONTROL
|(ev
->data
.control
.channel
& 0x0f);
448 if (ev
->data
.control
.param
< 0x20) {
451 if (dev
->nostat
&& count
< 6)
453 if (cmd
!= dev
->lastcmd
|| dev
->nostat
) {
456 buf
[idx
++] = dev
->lastcmd
= cmd
;
458 buf
[idx
++] = ev
->data
.control
.param
;
459 buf
[idx
++] = (ev
->data
.control
.value
>> 7) & 0x7f;
462 buf
[idx
++] = ev
->data
.control
.param
+ 0x20;
463 buf
[idx
++] = ev
->data
.control
.value
& 0x7f;
467 if (cmd
!= dev
->lastcmd
|| dev
->nostat
) {
470 buf
[idx
++] = dev
->lastcmd
= cmd
;
472 buf
[idx
++] = ev
->data
.control
.param
& 0x7f;
473 buf
[idx
++] = ev
->data
.control
.value
& 0x7f;
478 /* decode reg/nonreg param */
479 static int extra_decode_xrpn(snd_midi_event_t
*dev
, unsigned char *buf
, int count
, snd_seq_event_t
*ev
)
483 static char cbytes_nrpn
[4] = { MIDI_CTL_NONREG_PARM_NUM_MSB
,
484 MIDI_CTL_NONREG_PARM_NUM_LSB
,
485 MIDI_CTL_MSB_DATA_ENTRY
,
486 MIDI_CTL_LSB_DATA_ENTRY
};
487 static char cbytes_rpn
[4] = { MIDI_CTL_REGIST_PARM_NUM_MSB
,
488 MIDI_CTL_REGIST_PARM_NUM_LSB
,
489 MIDI_CTL_MSB_DATA_ENTRY
,
490 MIDI_CTL_LSB_DATA_ENTRY
};
491 unsigned char bytes
[4];
496 if (dev
->nostat
&& count
< 12)
498 cmd
= MIDI_CMD_CONTROL
|(ev
->data
.control
.channel
& 0x0f);
499 bytes
[0] = ev
->data
.control
.param
& 0x007f;
500 bytes
[1] = (ev
->data
.control
.param
& 0x3f80) >> 7;
501 bytes
[2] = ev
->data
.control
.value
& 0x007f;
502 bytes
[3] = (ev
->data
.control
.value
& 0x3f80) >> 7;
503 if (cmd
!= dev
->lastcmd
&& !dev
->nostat
) {
506 buf
[idx
++] = dev
->lastcmd
= cmd
;
508 cbytes
= ev
->type
== SNDRV_SEQ_EVENT_NONREGPARAM
? cbytes_nrpn
: cbytes_rpn
;
509 for (i
= 0; i
< 4; i
++) {
511 buf
[idx
++] = dev
->lastcmd
= cmd
;
512 buf
[idx
++] = cbytes
[i
];
513 buf
[idx
++] = bytes
[i
];
522 EXPORT_SYMBOL(snd_midi_event_new
);
523 EXPORT_SYMBOL(snd_midi_event_free
);
524 EXPORT_SYMBOL(snd_midi_event_reset_encode
);
525 EXPORT_SYMBOL(snd_midi_event_reset_decode
);
526 EXPORT_SYMBOL(snd_midi_event_no_status
);
527 EXPORT_SYMBOL(snd_midi_event_encode
);
528 EXPORT_SYMBOL(snd_midi_event_encode_byte
);
529 EXPORT_SYMBOL(snd_midi_event_decode
);
531 static int __init
alsa_seq_midi_event_init(void)
536 static void __exit
alsa_seq_midi_event_exit(void)
540 module_init(alsa_seq_midi_event_init
)
541 module_exit(alsa_seq_midi_event_exit
)