~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/sound/core/seq/seq_midi_emul.c

Version: ~ [ linux-5.4-rc7 ] ~ [ linux-5.3.11 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.84 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.154 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.201 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.201 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.77 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 /*
  2  *  GM/GS/XG midi module.
  3  *
  4  *  Copyright (C) 1999 Steve Ratcliffe
  5  *
  6  *  Based on awe_wave.c by Takashi Iwai
  7  *
  8  *   This program is free software; you can redistribute it and/or modify
  9  *   it under the terms of the GNU General Public License as published by
 10  *   the Free Software Foundation; either version 2 of the License, or
 11  *   (at your option) any later version.
 12  *
 13  *   This program is distributed in the hope that it will be useful,
 14  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 15  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 16  *   GNU General Public License for more details.
 17  *
 18  *   You should have received a copy of the GNU General Public License
 19  *   along with this program; if not, write to the Free Software
 20  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
 21  *
 22  */
 23 /*
 24  * This module is used to keep track of the current midi state.
 25  * It can be used for drivers that are required to emulate midi when
 26  * the hardware doesn't.
 27  *
 28  * It was written for a AWE64 driver, but there should be no AWE specific
 29  * code in here.  If there is it should be reported as a bug.
 30  */
 31 
 32 #include <linux/init.h>
 33 #include <linux/slab.h>
 34 #include <linux/string.h>
 35 #include <linux/module.h>
 36 #include <sound/core.h>
 37 #include <sound/seq_kernel.h>
 38 #include <sound/seq_midi_emul.h>
 39 #include <sound/initval.h>
 40 #include <sound/asoundef.h>
 41 
 42 MODULE_AUTHOR("Takashi Iwai / Steve Ratcliffe");
 43 MODULE_DESCRIPTION("Advanced Linux Sound Architecture sequencer MIDI emulation.");
 44 MODULE_LICENSE("GPL");
 45 
 46 /* Prototypes for static functions */
 47 static void note_off(struct snd_midi_op *ops, void *drv,
 48                      struct snd_midi_channel *chan,
 49                      int note, int vel);
 50 static void do_control(struct snd_midi_op *ops, void *private,
 51                        struct snd_midi_channel_set *chset,
 52                        struct snd_midi_channel *chan,
 53                        int control, int value);
 54 static void rpn(struct snd_midi_op *ops, void *drv, struct snd_midi_channel *chan,
 55                 struct snd_midi_channel_set *chset);
 56 static void nrpn(struct snd_midi_op *ops, void *drv, struct snd_midi_channel *chan,
 57                  struct snd_midi_channel_set *chset);
 58 static void sysex(struct snd_midi_op *ops, void *private, unsigned char *sysex,
 59                   int len, struct snd_midi_channel_set *chset);
 60 static void all_sounds_off(struct snd_midi_op *ops, void *private,
 61                            struct snd_midi_channel *chan);
 62 static void all_notes_off(struct snd_midi_op *ops, void *private,
 63                           struct snd_midi_channel *chan);
 64 static void snd_midi_reset_controllers(struct snd_midi_channel *chan);
 65 static void reset_all_channels(struct snd_midi_channel_set *chset);
 66 
 67 
 68 /*
 69  * Process an event in a driver independent way.  This means dealing
 70  * with RPN, NRPN, SysEx etc that are defined for common midi applications
 71  * such as GM, GS and XG.
 72  * There modes that this module will run in are:
 73  *   Generic MIDI - no interpretation at all, it will just save current values
 74  *                  of controllers etc.
 75  *   GM - You can use all gm_ prefixed elements of chan.  Controls, RPN, NRPN,
 76  *        SysEx will be interpreded as defined in General Midi.
 77  *   GS - You can use all gs_ prefixed elements of chan. Codes for GS will be
 78  *        interpreted.
 79  *   XG - You can use all xg_ prefixed elements of chan.  Codes for XG will
 80  *        be interpreted.
 81  */
 82 void
 83 snd_midi_process_event(struct snd_midi_op *ops,
 84                        struct snd_seq_event *ev,
 85                        struct snd_midi_channel_set *chanset)
 86 {
 87         struct snd_midi_channel *chan;
 88         void *drv;
 89         int dest_channel = 0;
 90 
 91         if (ev == NULL || chanset == NULL) {
 92                 pr_debug("ALSA: seq_midi_emul: ev or chanbase NULL (snd_midi_process_event)\n");
 93                 return;
 94         }
 95         if (chanset->channels == NULL)
 96                 return;
 97 
 98         if (snd_seq_ev_is_channel_type(ev)) {
 99                 dest_channel = ev->data.note.channel;
100                 if (dest_channel >= chanset->max_channels) {
101                         pr_debug("ALSA: seq_midi_emul: dest channel is %d, max is %d\n",
102                                    dest_channel, chanset->max_channels);
103                         return;
104                 }
105         }
106 
107         chan = chanset->channels + dest_channel;
108         drv  = chanset->private_data;
109 
110         /* EVENT_NOTE should be processed before queued */
111         if (ev->type == SNDRV_SEQ_EVENT_NOTE)
112                 return;
113 
114         /* Make sure that we don't have a note on that should really be
115          * a note off */
116         if (ev->type == SNDRV_SEQ_EVENT_NOTEON && ev->data.note.velocity == 0)
117                 ev->type = SNDRV_SEQ_EVENT_NOTEOFF;
118 
119         /* Make sure the note is within array range */
120         if (ev->type == SNDRV_SEQ_EVENT_NOTEON ||
121             ev->type == SNDRV_SEQ_EVENT_NOTEOFF ||
122             ev->type == SNDRV_SEQ_EVENT_KEYPRESS) {
123                 if (ev->data.note.note >= 128)
124                         return;
125         }
126 
127         switch (ev->type) {
128         case SNDRV_SEQ_EVENT_NOTEON:
129                 if (chan->note[ev->data.note.note] & SNDRV_MIDI_NOTE_ON) {
130                         if (ops->note_off)
131                                 ops->note_off(drv, ev->data.note.note, 0, chan);
132                 }
133                 chan->note[ev->data.note.note] = SNDRV_MIDI_NOTE_ON;
134                 if (ops->note_on)
135                         ops->note_on(drv, ev->data.note.note, ev->data.note.velocity, chan);
136                 break;
137         case SNDRV_SEQ_EVENT_NOTEOFF:
138                 if (! (chan->note[ev->data.note.note] & SNDRV_MIDI_NOTE_ON))
139                         break;
140                 if (ops->note_off)
141                         note_off(ops, drv, chan, ev->data.note.note, ev->data.note.velocity);
142                 break;
143         case SNDRV_SEQ_EVENT_KEYPRESS:
144                 if (ops->key_press)
145                         ops->key_press(drv, ev->data.note.note, ev->data.note.velocity, chan);
146                 break;
147         case SNDRV_SEQ_EVENT_CONTROLLER:
148                 do_control(ops, drv, chanset, chan,
149                            ev->data.control.param, ev->data.control.value);
150                 break;
151         case SNDRV_SEQ_EVENT_PGMCHANGE:
152                 chan->midi_program = ev->data.control.value;
153                 break;
154         case SNDRV_SEQ_EVENT_PITCHBEND:
155                 chan->midi_pitchbend = ev->data.control.value;
156                 if (ops->control)
157                         ops->control(drv, MIDI_CTL_PITCHBEND, chan);
158                 break;
159         case SNDRV_SEQ_EVENT_CHANPRESS:
160                 chan->midi_pressure = ev->data.control.value;
161                 if (ops->control)
162                         ops->control(drv, MIDI_CTL_CHAN_PRESSURE, chan);
163                 break;
164         case SNDRV_SEQ_EVENT_CONTROL14:
165                 /* Best guess is that this is any of the 14 bit controller values */
166                 if (ev->data.control.param < 32) {
167                         /* set low part first */
168                         chan->control[ev->data.control.param + 32] =
169                                 ev->data.control.value & 0x7f;
170                         do_control(ops, drv, chanset, chan,
171                                    ev->data.control.param,
172                                    ((ev->data.control.value>>7) & 0x7f));
173                 } else
174                         do_control(ops, drv, chanset, chan,
175                                    ev->data.control.param,
176                                    ev->data.control.value);
177                 break;
178         case SNDRV_SEQ_EVENT_NONREGPARAM:
179                 /* Break it back into its controller values */
180                 chan->param_type = SNDRV_MIDI_PARAM_TYPE_NONREGISTERED;
181                 chan->control[MIDI_CTL_MSB_DATA_ENTRY]
182                         = (ev->data.control.value >> 7) & 0x7f;
183                 chan->control[MIDI_CTL_LSB_DATA_ENTRY]
184                         = ev->data.control.value & 0x7f;
185                 chan->control[MIDI_CTL_NONREG_PARM_NUM_MSB]
186                         = (ev->data.control.param >> 7) & 0x7f;
187                 chan->control[MIDI_CTL_NONREG_PARM_NUM_LSB]
188                         = ev->data.control.param & 0x7f;
189                 nrpn(ops, drv, chan, chanset);
190                 break;
191         case SNDRV_SEQ_EVENT_REGPARAM:
192                 /* Break it back into its controller values */
193                 chan->param_type = SNDRV_MIDI_PARAM_TYPE_REGISTERED;
194                 chan->control[MIDI_CTL_MSB_DATA_ENTRY]
195                         = (ev->data.control.value >> 7) & 0x7f;
196                 chan->control[MIDI_CTL_LSB_DATA_ENTRY]
197                         = ev->data.control.value & 0x7f;
198                 chan->control[MIDI_CTL_REGIST_PARM_NUM_MSB]
199                         = (ev->data.control.param >> 7) & 0x7f;
200                 chan->control[MIDI_CTL_REGIST_PARM_NUM_LSB]
201                         = ev->data.control.param & 0x7f;
202                 rpn(ops, drv, chan, chanset);
203                 break;
204         case SNDRV_SEQ_EVENT_SYSEX:
205                 if ((ev->flags & SNDRV_SEQ_EVENT_LENGTH_MASK) == SNDRV_SEQ_EVENT_LENGTH_VARIABLE) {
206                         unsigned char sysexbuf[64];
207                         int len;
208                         len = snd_seq_expand_var_event(ev, sizeof(sysexbuf), sysexbuf, 1, 0);
209                         if (len > 0)
210                                 sysex(ops, drv, sysexbuf, len, chanset);
211                 }
212                 break;
213         case SNDRV_SEQ_EVENT_SONGPOS:
214         case SNDRV_SEQ_EVENT_SONGSEL:
215         case SNDRV_SEQ_EVENT_CLOCK:
216         case SNDRV_SEQ_EVENT_START:
217         case SNDRV_SEQ_EVENT_CONTINUE:
218         case SNDRV_SEQ_EVENT_STOP:
219         case SNDRV_SEQ_EVENT_QFRAME:
220         case SNDRV_SEQ_EVENT_TEMPO:
221         case SNDRV_SEQ_EVENT_TIMESIGN:
222         case SNDRV_SEQ_EVENT_KEYSIGN:
223                 goto not_yet;
224         case SNDRV_SEQ_EVENT_SENSING:
225                 break;
226         case SNDRV_SEQ_EVENT_CLIENT_START:
227         case SNDRV_SEQ_EVENT_CLIENT_EXIT:
228         case SNDRV_SEQ_EVENT_CLIENT_CHANGE:
229         case SNDRV_SEQ_EVENT_PORT_START:
230         case SNDRV_SEQ_EVENT_PORT_EXIT:
231         case SNDRV_SEQ_EVENT_PORT_CHANGE:
232         case SNDRV_SEQ_EVENT_ECHO:
233         not_yet:
234         default:
235                 /*pr_debug("ALSA: seq_midi_emul: Unimplemented event %d\n", ev->type);*/
236                 break;
237         }
238 }
239 
240 
241 /*
242  * release note
243  */
244 static void
245 note_off(struct snd_midi_op *ops, void *drv, struct snd_midi_channel *chan,
246          int note, int vel)
247 {
248         if (chan->gm_hold) {
249                 /* Hold this note until pedal is turned off */
250                 chan->note[note] |= SNDRV_MIDI_NOTE_RELEASED;
251         } else if (chan->note[note] & SNDRV_MIDI_NOTE_SOSTENUTO) {
252                 /* Mark this note as release; it will be turned off when sostenuto
253                  * is turned off */
254                 chan->note[note] |= SNDRV_MIDI_NOTE_RELEASED;
255         } else {
256                 chan->note[note] = 0;
257                 if (ops->note_off)
258                         ops->note_off(drv, note, vel, chan);
259         }
260 }
261 
262 /*
263  * Do all driver independent operations for this controller and pass
264  * events that need to take place immediately to the driver.
265  */
266 static void
267 do_control(struct snd_midi_op *ops, void *drv, struct snd_midi_channel_set *chset,
268            struct snd_midi_channel *chan, int control, int value)
269 {
270         int  i;
271 
272         if (control >= ARRAY_SIZE(chan->control))
273                 return;
274 
275         /* Switches */
276         if ((control >=64 && control <=69) || (control >= 80 && control <= 83)) {
277                 /* These are all switches; either off or on so set to 0 or 127 */
278                 value = (value >= 64)? 127: 0;
279         }
280         chan->control[control] = value;
281 
282         switch (control) {
283         case MIDI_CTL_SUSTAIN:
284                 if (value == 0) {
285                         /* Sustain has been released, turn off held notes */
286                         for (i = 0; i < 128; i++) {
287                                 if (chan->note[i] & SNDRV_MIDI_NOTE_RELEASED) {
288                                         chan->note[i] = SNDRV_MIDI_NOTE_OFF;
289                                         if (ops->note_off)
290                                                 ops->note_off(drv, i, 0, chan);
291                                 }
292                         }
293                 }
294                 break;
295         case MIDI_CTL_PORTAMENTO:
296                 break;
297         case MIDI_CTL_SOSTENUTO:
298                 if (value) {
299                         /* Mark each note that is currently held down */
300                         for (i = 0; i < 128; i++) {
301                                 if (chan->note[i] & SNDRV_MIDI_NOTE_ON)
302                                         chan->note[i] |= SNDRV_MIDI_NOTE_SOSTENUTO;
303                         }
304                 } else {
305                         /* release all notes that were held */
306                         for (i = 0; i < 128; i++) {
307                                 if (chan->note[i] & SNDRV_MIDI_NOTE_SOSTENUTO) {
308                                         chan->note[i] &= ~SNDRV_MIDI_NOTE_SOSTENUTO;
309                                         if (chan->note[i] & SNDRV_MIDI_NOTE_RELEASED) {
310                                                 chan->note[i] = SNDRV_MIDI_NOTE_OFF;
311                                                 if (ops->note_off)
312                                                         ops->note_off(drv, i, 0, chan);
313                                         }
314                                 }
315                         }
316                 }
317                 break;
318         case MIDI_CTL_MSB_DATA_ENTRY:
319                 chan->control[MIDI_CTL_LSB_DATA_ENTRY] = 0;
320                 /* go through here */
321         case MIDI_CTL_LSB_DATA_ENTRY:
322                 if (chan->param_type == SNDRV_MIDI_PARAM_TYPE_REGISTERED)
323                         rpn(ops, drv, chan, chset);
324                 else
325                         nrpn(ops, drv, chan, chset);
326                 break;
327         case MIDI_CTL_REGIST_PARM_NUM_LSB:
328         case MIDI_CTL_REGIST_PARM_NUM_MSB:
329                 chan->param_type = SNDRV_MIDI_PARAM_TYPE_REGISTERED;
330                 break;
331         case MIDI_CTL_NONREG_PARM_NUM_LSB:
332         case MIDI_CTL_NONREG_PARM_NUM_MSB:
333                 chan->param_type = SNDRV_MIDI_PARAM_TYPE_NONREGISTERED;
334                 break;
335 
336         case MIDI_CTL_ALL_SOUNDS_OFF:
337                 all_sounds_off(ops, drv, chan);
338                 break;
339 
340         case MIDI_CTL_ALL_NOTES_OFF:
341                 all_notes_off(ops, drv, chan);
342                 break;
343 
344         case MIDI_CTL_MSB_BANK:
345                 if (chset->midi_mode == SNDRV_MIDI_MODE_XG) {
346                         if (value == 127)
347                                 chan->drum_channel = 1;
348                         else
349                                 chan->drum_channel = 0;
350                 }
351                 break;
352         case MIDI_CTL_LSB_BANK:
353                 break;
354 
355         case MIDI_CTL_RESET_CONTROLLERS:
356                 snd_midi_reset_controllers(chan);
357                 break;
358 
359         case MIDI_CTL_SOFT_PEDAL:
360         case MIDI_CTL_LEGATO_FOOTSWITCH:
361         case MIDI_CTL_HOLD2:
362         case MIDI_CTL_SC1_SOUND_VARIATION:
363         case MIDI_CTL_SC2_TIMBRE:
364         case MIDI_CTL_SC3_RELEASE_TIME:
365         case MIDI_CTL_SC4_ATTACK_TIME:
366         case MIDI_CTL_SC5_BRIGHTNESS:
367         case MIDI_CTL_E1_REVERB_DEPTH:
368         case MIDI_CTL_E2_TREMOLO_DEPTH:
369         case MIDI_CTL_E3_CHORUS_DEPTH:
370         case MIDI_CTL_E4_DETUNE_DEPTH:
371         case MIDI_CTL_E5_PHASER_DEPTH:
372                 goto notyet;
373         notyet:
374         default:
375                 if (ops->control)
376                         ops->control(drv, control, chan);
377                 break;
378         }
379 }
380 
381 
382 /*
383  * initialize the MIDI status
384  */
385 void
386 snd_midi_channel_set_clear(struct snd_midi_channel_set *chset)
387 {
388         int i;
389 
390         chset->midi_mode = SNDRV_MIDI_MODE_GM;
391         chset->gs_master_volume = 127;
392 
393         for (i = 0; i < chset->max_channels; i++) {
394                 struct snd_midi_channel *chan = chset->channels + i;
395                 memset(chan->note, 0, sizeof(chan->note));
396 
397                 chan->midi_aftertouch = 0;
398                 chan->midi_pressure = 0;
399                 chan->midi_program = 0;
400                 chan->midi_pitchbend = 0;
401                 snd_midi_reset_controllers(chan);
402                 chan->gm_rpn_pitch_bend_range = 256; /* 2 semitones */
403                 chan->gm_rpn_fine_tuning = 0;
404                 chan->gm_rpn_coarse_tuning = 0;
405 
406                 if (i == 9)
407                         chan->drum_channel = 1;
408                 else
409                         chan->drum_channel = 0;
410         }
411 }
412 
413 /*
414  * Process a rpn message.
415  */
416 static void
417 rpn(struct snd_midi_op *ops, void *drv, struct snd_midi_channel *chan,
418     struct snd_midi_channel_set *chset)
419 {
420         int type;
421         int val;
422 
423         if (chset->midi_mode != SNDRV_MIDI_MODE_NONE) {
424                 type = (chan->control[MIDI_CTL_REGIST_PARM_NUM_MSB] << 8) |
425                         chan->control[MIDI_CTL_REGIST_PARM_NUM_LSB];
426                 val = (chan->control[MIDI_CTL_MSB_DATA_ENTRY] << 7) |
427                         chan->control[MIDI_CTL_LSB_DATA_ENTRY];
428 
429                 switch (type) {
430                 case 0x0000: /* Pitch bend sensitivity */
431                         /* MSB only / 1 semitone per 128 */
432                         chan->gm_rpn_pitch_bend_range = val;
433                         break;
434                                         
435                 case 0x0001: /* fine tuning: */
436                         /* MSB/LSB, 8192=center, 100/8192 cent step */
437                         chan->gm_rpn_fine_tuning = val - 8192;
438                         break;
439 
440                 case 0x0002: /* coarse tuning */
441                         /* MSB only / 8192=center, 1 semitone per 128 */
442                         chan->gm_rpn_coarse_tuning = val - 8192;
443                         break;
444 
445                 case 0x7F7F: /* "lock-in" RPN */
446                         /* ignored */
447                         break;
448                 }
449         }
450         /* should call nrpn or rpn callback here.. */
451 }
452 
453 /*
454  * Process an nrpn message.
455  */
456 static void
457 nrpn(struct snd_midi_op *ops, void *drv, struct snd_midi_channel *chan,
458      struct snd_midi_channel_set *chset)
459 {
460         /* parse XG NRPNs here if possible */
461         if (ops->nrpn)
462                 ops->nrpn(drv, chan, chset);
463 }
464 
465 
466 /*
467  * convert channel parameter in GS sysex
468  */
469 static int
470 get_channel(unsigned char cmd)
471 {
472         int p = cmd & 0x0f;
473         if (p == 0)
474                 p = 9;
475         else if (p < 10)
476                 p--;
477         return p;
478 }
479 
480 
481 /*
482  * Process a sysex message.
483  */
484 static void
485 sysex(struct snd_midi_op *ops, void *private, unsigned char *buf, int len,
486       struct snd_midi_channel_set *chset)
487 {
488         /* GM on */
489         static unsigned char gm_on_macro[] = {
490                 0x7e,0x7f,0x09,0x01,
491         };
492         /* XG on */
493         static unsigned char xg_on_macro[] = {
494                 0x43,0x10,0x4c,0x00,0x00,0x7e,0x00,
495         };
496         /* GS prefix
497          * drum channel: XX=0x1?(channel), YY=0x15, ZZ=on/off
498          * reverb mode: XX=0x01, YY=0x30, ZZ=0-7
499          * chorus mode: XX=0x01, YY=0x38, ZZ=0-7
500          * master vol:  XX=0x00, YY=0x04, ZZ=0-127
501          */
502         static unsigned char gs_pfx_macro[] = {
503                 0x41,0x10,0x42,0x12,0x40,/*XX,YY,ZZ*/
504         };
505 
506         int parsed = SNDRV_MIDI_SYSEX_NOT_PARSED;
507 
508         if (len <= 0 || buf[0] != 0xf0)
509                 return;
510         /* skip first byte */
511         buf++;
512         len--;
513 
514         /* GM on */
515         if (len >= (int)sizeof(gm_on_macro) &&
516             memcmp(buf, gm_on_macro, sizeof(gm_on_macro)) == 0) {
517                 if (chset->midi_mode != SNDRV_MIDI_MODE_GS &&
518                     chset->midi_mode != SNDRV_MIDI_MODE_XG) {
519                         chset->midi_mode = SNDRV_MIDI_MODE_GM;
520                         reset_all_channels(chset);
521                         parsed = SNDRV_MIDI_SYSEX_GM_ON;
522                 }
523         }
524 
525         /* GS macros */
526         else if (len >= 8 &&
527                  memcmp(buf, gs_pfx_macro, sizeof(gs_pfx_macro)) == 0) {
528                 if (chset->midi_mode != SNDRV_MIDI_MODE_GS &&
529                     chset->midi_mode != SNDRV_MIDI_MODE_XG)
530                         chset->midi_mode = SNDRV_MIDI_MODE_GS;
531 
532                 if (buf[5] == 0x00 && buf[6] == 0x7f && buf[7] == 0x00) {
533                         /* GS reset */
534                         parsed = SNDRV_MIDI_SYSEX_GS_RESET;
535                         reset_all_channels(chset);
536                 }
537 
538                 else if ((buf[5] & 0xf0) == 0x10 && buf[6] == 0x15) {
539                         /* drum pattern */
540                         int p = get_channel(buf[5]);
541                         if (p < chset->max_channels) {
542                                 parsed = SNDRV_MIDI_SYSEX_GS_DRUM_CHANNEL;
543                                 if (buf[7])
544                                         chset->channels[p].drum_channel = 1;
545                                 else
546                                         chset->channels[p].drum_channel = 0;
547                         }
548 
549                 } else if ((buf[5] & 0xf0) == 0x10 && buf[6] == 0x21) {
550                         /* program */
551                         int p = get_channel(buf[5]);
552                         if (p < chset->max_channels &&
553                             ! chset->channels[p].drum_channel) {
554                                 parsed = SNDRV_MIDI_SYSEX_GS_DRUM_CHANNEL;
555                                 chset->channels[p].midi_program = buf[7];
556                         }
557 
558                 } else if (buf[5] == 0x01 && buf[6] == 0x30) {
559                         /* reverb mode */
560                         parsed = SNDRV_MIDI_SYSEX_GS_REVERB_MODE;
561                         chset->gs_reverb_mode = buf[7];
562 
563                 } else if (buf[5] == 0x01 && buf[6] == 0x38) {
564                         /* chorus mode */
565                         parsed = SNDRV_MIDI_SYSEX_GS_CHORUS_MODE;
566                         chset->gs_chorus_mode = buf[7];
567 
568                 } else if (buf[5] == 0x00 && buf[6] == 0x04) {
569                         /* master volume */
570                         parsed = SNDRV_MIDI_SYSEX_GS_MASTER_VOLUME;
571                         chset->gs_master_volume = buf[7];
572 
573                 }
574         }
575 
576         /* XG on */
577         else if (len >= (int)sizeof(xg_on_macro) &&
578                  memcmp(buf, xg_on_macro, sizeof(xg_on_macro)) == 0) {
579                 int i;
580                 chset->midi_mode = SNDRV_MIDI_MODE_XG;
581                 parsed = SNDRV_MIDI_SYSEX_XG_ON;
582                 /* reset CC#0 for drums */
583                 for (i = 0; i < chset->max_channels; i++) {
584                         if (chset->channels[i].drum_channel)
585                                 chset->channels[i].control[MIDI_CTL_MSB_BANK] = 127;
586                         else
587                                 chset->channels[i].control[MIDI_CTL_MSB_BANK] = 0;
588                 }
589         }
590 
591         if (ops->sysex)
592                 ops->sysex(private, buf - 1, len + 1, parsed, chset);
593 }
594 
595 /*
596  * all sound off
597  */
598 static void
599 all_sounds_off(struct snd_midi_op *ops, void *drv, struct snd_midi_channel *chan)
600 {
601         int n;
602 
603         if (! ops->note_terminate)
604                 return;
605         for (n = 0; n < 128; n++) {
606                 if (chan->note[n]) {
607                         ops->note_terminate(drv, n, chan);
608                         chan->note[n] = 0;
609                 }
610         }
611 }
612 
613 /*
614  * all notes off
615  */
616 static void
617 all_notes_off(struct snd_midi_op *ops, void *drv, struct snd_midi_channel *chan)
618 {
619         int n;
620 
621         if (! ops->note_off)
622                 return;
623         for (n = 0; n < 128; n++) {
624                 if (chan->note[n] == SNDRV_MIDI_NOTE_ON)
625                         note_off(ops, drv, chan, n, 0);
626         }
627 }
628 
629 /*
630  * Initialise a single midi channel control block.
631  */
632 static void snd_midi_channel_init(struct snd_midi_channel *p, int n)
633 {
634         if (p == NULL)
635                 return;
636 
637         memset(p, 0, sizeof(struct snd_midi_channel));
638         p->private = NULL;
639         p->number = n;
640 
641         snd_midi_reset_controllers(p);
642         p->gm_rpn_pitch_bend_range = 256; /* 2 semitones */
643         p->gm_rpn_fine_tuning = 0;
644         p->gm_rpn_coarse_tuning = 0;
645 
646         if (n == 9)
647                 p->drum_channel = 1;    /* Default ch 10 as drums */
648 }
649 
650 /*
651  * Allocate and initialise a set of midi channel control blocks.
652  */
653 static struct snd_midi_channel *snd_midi_channel_init_set(int n)
654 {
655         struct snd_midi_channel *chan;
656         int  i;
657 
658         chan = kmalloc(n * sizeof(struct snd_midi_channel), GFP_KERNEL);
659         if (chan) {
660                 for (i = 0; i < n; i++)
661                         snd_midi_channel_init(chan+i, i);
662         }
663 
664         return chan;
665 }
666 
667 /*
668  * reset all midi channels
669  */
670 static void
671 reset_all_channels(struct snd_midi_channel_set *chset)
672 {
673         int ch;
674         for (ch = 0; ch < chset->max_channels; ch++) {
675                 struct snd_midi_channel *chan = chset->channels + ch;
676                 snd_midi_reset_controllers(chan);
677                 chan->gm_rpn_pitch_bend_range = 256; /* 2 semitones */
678                 chan->gm_rpn_fine_tuning = 0;
679                 chan->gm_rpn_coarse_tuning = 0;
680 
681                 if (ch == 9)
682                         chan->drum_channel = 1;
683                 else
684                         chan->drum_channel = 0;
685         }
686 }
687 
688 
689 /*
690  * Allocate and initialise a midi channel set.
691  */
692 struct snd_midi_channel_set *snd_midi_channel_alloc_set(int n)
693 {
694         struct snd_midi_channel_set *chset;
695 
696         chset = kmalloc(sizeof(*chset), GFP_KERNEL);
697         if (chset) {
698                 chset->channels = snd_midi_channel_init_set(n);
699                 chset->private_data = NULL;
700                 chset->max_channels = n;
701         }
702         return chset;
703 }
704 
705 /*
706  * Reset the midi controllers on a particular channel to default values.
707  */
708 static void snd_midi_reset_controllers(struct snd_midi_channel *chan)
709 {
710         memset(chan->control, 0, sizeof(chan->control));
711         chan->gm_volume = 127;
712         chan->gm_expression = 127;
713         chan->gm_pan = 64;
714 }
715 
716 
717 /*
718  * Free a midi channel set.
719  */
720 void snd_midi_channel_free_set(struct snd_midi_channel_set *chset)
721 {
722         if (chset == NULL)
723                 return;
724         kfree(chset->channels);
725         kfree(chset);
726 }
727 
728 static int __init alsa_seq_midi_emul_init(void)
729 {
730         return 0;
731 }
732 
733 static void __exit alsa_seq_midi_emul_exit(void)
734 {
735 }
736 
737 module_init(alsa_seq_midi_emul_init)
738 module_exit(alsa_seq_midi_emul_exit)
739 
740 EXPORT_SYMBOL(snd_midi_process_event);
741 EXPORT_SYMBOL(snd_midi_channel_set_clear);
742 EXPORT_SYMBOL(snd_midi_channel_alloc_set);
743 EXPORT_SYMBOL(snd_midi_channel_free_set);
744 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp