Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 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; |
Takashi Iwai | ecca82b | 2005-09-09 14:20:49 +0200 | [diff] [blame] | 121 | dev = kzalloc(sizeof(*dev), GFP_KERNEL); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 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 | */ |
Jesper Juhl | 77933d7 | 2005-07-27 11:46:09 -0700 | [diff] [blame] | 149 | static inline void reset_encode(snd_midi_event_t *dev) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 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 | |
Adrian Bunk | 123992f | 2005-05-18 18:02:04 +0200 | [diff] [blame] | 174 | #if 0 |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 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 | } |
Adrian Bunk | 123992f | 2005-05-18 18:02:04 +0200 | [diff] [blame] | 180 | #endif /* 0 */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 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 | */ |
Adrian Bunk | 123992f | 2005-05-18 18:02:04 +0200 | [diff] [blame] | 190 | #if 0 |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 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 | } |
Adrian Bunk | 123992f | 2005-05-18 18:02:04 +0200 | [diff] [blame] | 210 | #endif /* 0 */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 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); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 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) |