1 /* 2 * MIDI byte <-> sequencer event coder 3 * 4 * Copyright (C) 1998,99 Takashi Iwai <tiwai@suse.de>, 5 * Jaroslav Kysela <perex@suse.cz> 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 20 */ 21 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> 30 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"); 34 35 /* queue type */ 36 /* from 0 to 7 are normal commands (note off, on, etc.) */ 37 #define ST_NOTEOFF 0 38 #define ST_NOTEON 1 39 #define ST_SPECIAL 8 40 #define ST_SYSEX ST_SPECIAL 41 /* from 8 to 15 are events for 0xf0-0xf7 */ 42 43 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); 47 48 /* 49 * prototypes 50 */ 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); 62 63 /* 64 * event list 65 */ 66 static struct status_event_list_t { 67 int event; 68 int qlen; 69 event_encode_t encode; 70 event_decode_t decode; 71 } status_event[] = { 72 /* 0x80 - 0xf0 */ 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 */ 81 /* 0xf0 - 0xff */ 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 */ 98 }; 99 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); 102 103 static struct extra_event_list_t { 104 int event; 105 int (*decode)(snd_midi_event_t *dev, unsigned char *buf, int len, snd_seq_event_t *ev); 106 } extra_event[] = { 107 {SNDRV_SEQ_EVENT_CONTROL14, extra_decode_ctrl14}, 108 {SNDRV_SEQ_EVENT_NONREGPARAM, extra_decode_xrpn}, 109 {SNDRV_SEQ_EVENT_REGPARAM, extra_decode_xrpn}, 110 }; 111 112 /* 113 * new/delete record 114 */ 115 116 int snd_midi_event_new(int bufsize, snd_midi_event_t **rdev) 117 { 118 snd_midi_event_t *dev; 119 120 *rdev = NULL; 121 dev = kcalloc(1, sizeof(*dev), GFP_KERNEL); 122 if (dev == NULL) 123 return -ENOMEM; 124 if (bufsize > 0) { 125 dev->buf = kmalloc(bufsize, GFP_KERNEL); 126 if (dev->buf == NULL) { 127 kfree(dev); 128 return -ENOMEM; 129 } 130 } 131 dev->bufsize = bufsize; 132 dev->lastcmd = 0xff; 133 spin_lock_init(&dev->lock); 134 *rdev = dev; 135 return 0; 136 } 137 138 void snd_midi_event_free(snd_midi_event_t *dev) 139 { 140 if (dev != NULL) { 141 kfree(dev->buf); 142 kfree(dev); 143 } 144 } 145 146 /* 147 * initialize record 148 */ 149 inline static void reset_encode(snd_midi_event_t *dev) 150 { 151 dev->read = 0; 152 dev->qlen = 0; 153 dev->type = 0; 154 } 155 156 void snd_midi_event_reset_encode(snd_midi_event_t *dev) 157 { 158 unsigned long flags; 159 160 spin_lock_irqsave(&dev->lock, flags); 161 reset_encode(dev); 162 spin_unlock_irqrestore(&dev->lock, flags); 163 } 164 165 void snd_midi_event_reset_decode(snd_midi_event_t *dev) 166 { 167 unsigned long flags; 168 169 spin_lock_irqsave(&dev->lock, flags); 170 dev->lastcmd = 0xff; 171 spin_unlock_irqrestore(&dev->lock, flags); 172 } 173 174 #if 0 175 void snd_midi_event_init(snd_midi_event_t *dev) 176 { 177 snd_midi_event_reset_encode(dev); 178 snd_midi_event_reset_decode(dev); 179 } 180 #endif /* 0 */ 181 182 void snd_midi_event_no_status(snd_midi_event_t *dev, int on) 183 { 184 dev->nostat = on ? 1 : 0; 185 } 186 187 /* 188 * resize buffer 189 */ 190 #if 0 191 int snd_midi_event_resize_buffer(snd_midi_event_t *dev, int bufsize) 192 { 193 unsigned char *new_buf, *old_buf; 194 unsigned long flags; 195 196 if (bufsize == dev->bufsize) 197 return 0; 198 new_buf = kmalloc(bufsize, GFP_KERNEL); 199 if (new_buf == NULL) 200 return -ENOMEM; 201 spin_lock_irqsave(&dev->lock, flags); 202 old_buf = dev->buf; 203 dev->buf = new_buf; 204 dev->bufsize = bufsize; 205 reset_encode(dev); 206 spin_unlock_irqrestore(&dev->lock, flags); 207 kfree(old_buf); 208 return 0; 209 } 210 #endif /* 0 */ 211 212 /* 213 * read bytes and encode to sequencer event if finished 214 * return the size of encoded bytes 215 */ 216 long snd_midi_event_encode(snd_midi_event_t *dev, unsigned char *buf, long count, snd_seq_event_t *ev) 217 { 218 long result = 0; 219 int rc; 220 221 ev->type = SNDRV_SEQ_EVENT_NONE; 222 223 while (count-- > 0) { 224 rc = snd_midi_event_encode_byte(dev, *buf++, ev); 225 result++; 226 if (rc < 0) 227 return rc; 228 else if (rc > 0) 229 return result; 230 } 231 232 return result; 233 } 234 235 /* 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 239 * negative for error 240 */ 241 int snd_midi_event_encode_byte(snd_midi_event_t *dev, int c, snd_seq_event_t *ev) 242 { 243 int rc = 0; 244 unsigned long flags; 245 246 c &= 0xff; 247 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; 253 return 1; 254 } 255 256 spin_lock_irqsave(&dev->lock, flags); 257 if (dev->qlen > 0) { 258 /* rest of command */ 259 dev->buf[dev->read++] = c; 260 if (dev->type != ST_SYSEX) 261 dev->qlen--; 262 } else { 263 /* new command */ 264 dev->read = 1; 265 if (c & 0x80) { 266 dev->buf[0] = c; 267 if ((c & 0xf0) == 0xf0) /* special events */ 268 dev->type = (c & 0x0f) + ST_SPECIAL; 269 else 270 dev->type = (c >> 4) & 0x07; 271 dev->qlen = status_event[dev->type].qlen; 272 } else { 273 /* process this byte as argument */ 274 dev->buf[dev->read++] = c; 275 dev->qlen = status_event[dev->type].qlen - 1; 276 } 277 } 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); 284 rc = 1; 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 */ 295 else 296 reset_encode(dev); /* all parsed */ 297 rc = 1; 298 } 299 } 300 301 spin_unlock_irqrestore(&dev->lock, flags); 302 return rc; 303 } 304 305 /* encode note event */ 306 static void note_event(snd_midi_event_t *dev, snd_seq_event_t *ev) 307 { 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]; 311 } 312 313 /* encode one parameter controls */ 314 static void one_param_ctrl_event(snd_midi_event_t *dev, snd_seq_event_t *ev) 315 { 316 ev->data.control.channel = dev->buf[0] & 0x0f; 317 ev->data.control.value = dev->buf[1]; 318 } 319 320 /* encode pitch wheel change */ 321 static void pitchbend_ctrl_event(snd_midi_event_t *dev, snd_seq_event_t *ev) 322 { 323 ev->data.control.channel = dev->buf[0] & 0x0f; 324 ev->data.control.value = (int)dev->buf[2] * 128 + (int)dev->buf[1] - 8192; 325 } 326 327 /* encode midi control change */ 328 static void two_param_ctrl_event(snd_midi_event_t *dev, snd_seq_event_t *ev) 329 { 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]; 333 } 334 335 /* encode one parameter value*/ 336 static void one_param_event(snd_midi_event_t *dev, snd_seq_event_t *ev) 337 { 338 ev->data.control.value = dev->buf[1]; 339 } 340 341 /* encode song position */ 342 static void songpos_event(snd_midi_event_t *dev, snd_seq_event_t *ev) 343 { 344 ev->data.control.value = (int)dev->buf[2] * 128 + (int)dev->buf[1]; 345 } 346 347 /* 348 * decode from a sequencer event to midi bytes 349 * return the size of decoded midi events 350 */ 351 long snd_midi_event_decode(snd_midi_event_t *dev, unsigned char *buf, long count, snd_seq_event_t *ev) 352 { 353 unsigned int cmd, type; 354 355 if (ev->type == SNDRV_SEQ_EVENT_NONE) 356 return -ENOENT; 357 358 for (type = 0; type < ARRAY_SIZE(status_event); type++) { 359 if (ev->type == status_event[type].event) 360 goto __found; 361 } 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); 365 } 366 return -ENOENT; 367 368 __found: 369 if (type >= ST_SPECIAL) 370 cmd = 0xf0 + (type - ST_SPECIAL); 371 else 372 /* data.note.channel and data.control.channel is identical */ 373 cmd = 0x80 | (type << 4) | (ev->data.note.channel & 0x0f); 374 375 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); 379 } else { 380 int qlen; 381 unsigned char xbuf[4]; 382 unsigned long flags; 383 384 spin_lock_irqsave(&dev->lock, flags); 385 if ((cmd & 0xf0) == 0xf0 || dev->lastcmd != cmd || dev->nostat) { 386 dev->lastcmd = cmd; 387 spin_unlock_irqrestore(&dev->lock, flags); 388 xbuf[0] = cmd; 389 if (status_event[type].decode) 390 status_event[type].decode(ev, xbuf + 1); 391 qlen = status_event[type].qlen + 1; 392 } else { 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; 397 } 398 if (count < qlen) 399 return -ENOMEM; 400 memcpy(buf, xbuf, qlen); 401 return qlen; 402 } 403 } 404 405 406 /* decode note event */ 407 static void note_decode(snd_seq_event_t *ev, unsigned char *buf) 408 { 409 buf[0] = ev->data.note.note & 0x7f; 410 buf[1] = ev->data.note.velocity & 0x7f; 411 } 412 413 /* decode one parameter controls */ 414 static void one_param_decode(snd_seq_event_t *ev, unsigned char *buf) 415 { 416 buf[0] = ev->data.control.value & 0x7f; 417 } 418 419 /* decode pitch wheel change */ 420 static void pitchbend_decode(snd_seq_event_t *ev, unsigned char *buf) 421 { 422 int value = ev->data.control.value + 8192; 423 buf[0] = value & 0x7f; 424 buf[1] = (value >> 7) & 0x7f; 425 } 426 427 /* decode midi control change */ 428 static void two_param_decode(snd_seq_event_t *ev, unsigned char *buf) 429 { 430 buf[0] = ev->data.control.param & 0x7f; 431 buf[1] = ev->data.control.value & 0x7f; 432 } 433 434 /* decode song position */ 435 static void songpos_decode(snd_seq_event_t *ev, unsigned char *buf) 436 { 437 buf[0] = ev->data.control.value & 0x7f; 438 buf[1] = (ev->data.control.value >> 7) & 0x7f; 439 } 440 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) 443 { 444 unsigned char cmd; 445 int idx = 0; 446 447 cmd = MIDI_CMD_CONTROL|(ev->data.control.channel & 0x0f); 448 if (ev->data.control.param < 0x20) { 449 if (count < 4) 450 return -ENOMEM; 451 if (dev->nostat && count < 6) 452 return -ENOMEM; 453 if (cmd != dev->lastcmd || dev->nostat) { 454 if (count < 5) 455 return -ENOMEM; 456 buf[idx++] = dev->lastcmd = cmd; 457 } 458 buf[idx++] = ev->data.control.param; 459 buf[idx++] = (ev->data.control.value >> 7) & 0x7f; 460 if (dev->nostat) 461 buf[idx++] = cmd; 462 buf[idx++] = ev->data.control.param + 0x20; 463 buf[idx++] = ev->data.control.value & 0x7f; 464 } else { 465 if (count < 2) 466 return -ENOMEM; 467 if (cmd != dev->lastcmd || dev->nostat) { 468 if (count < 3) 469 return -ENOMEM; 470 buf[idx++] = dev->lastcmd = cmd; 471 } 472 buf[idx++] = ev->data.control.param & 0x7f; 473 buf[idx++] = ev->data.control.value & 0x7f; 474 } 475 return idx; 476 } 477 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) 480 { 481 unsigned char cmd; 482 char *cbytes; 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]; 492 int idx = 0, i; 493 494 if (count < 8) 495 return -ENOMEM; 496 if (dev->nostat && count < 12) 497 return -ENOMEM; 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) { 504 if (count < 9) 505 return -ENOMEM; 506 buf[idx++] = dev->lastcmd = cmd; 507 } 508 cbytes = ev->type == SNDRV_SEQ_EVENT_NONREGPARAM ? cbytes_nrpn : cbytes_rpn; 509 for (i = 0; i < 4; i++) { 510 if (dev->nostat) 511 buf[idx++] = dev->lastcmd = cmd; 512 buf[idx++] = cbytes[i]; 513 buf[idx++] = bytes[i]; 514 } 515 return idx; 516 } 517 518 /* 519 * exports 520 */ 521 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); 530 531 static int __init alsa_seq_midi_event_init(void) 532 { 533 return 0; 534 } 535 536 static void __exit alsa_seq_midi_event_exit(void) 537 { 538 } 539 540 module_init(alsa_seq_midi_event_init) 541 module_exit(alsa_seq_midi_event_exit) 542