Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
seq_midi_emul.c
Go to the documentation of this file.
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  snd_printd("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  snd_printd("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  /*snd_printd("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  /* Switches */
273  if ((control >=64 && control <=69) || (control >= 80 && control <= 83)) {
274  /* These are all switches; either off or on so set to 0 or 127 */
275  value = (value >= 64)? 127: 0;
276  }
277  chan->control[control] = value;
278 
279  switch (control) {
280  case MIDI_CTL_SUSTAIN:
281  if (value == 0) {
282  /* Sustain has been released, turn off held notes */
283  for (i = 0; i < 128; i++) {
284  if (chan->note[i] & SNDRV_MIDI_NOTE_RELEASED) {
285  chan->note[i] = SNDRV_MIDI_NOTE_OFF;
286  if (ops->note_off)
287  ops->note_off(drv, i, 0, chan);
288  }
289  }
290  }
291  break;
292  case MIDI_CTL_PORTAMENTO:
293  break;
294  case MIDI_CTL_SOSTENUTO:
295  if (value) {
296  /* Mark each note that is currently held down */
297  for (i = 0; i < 128; i++) {
298  if (chan->note[i] & SNDRV_MIDI_NOTE_ON)
299  chan->note[i] |= SNDRV_MIDI_NOTE_SOSTENUTO;
300  }
301  } else {
302  /* release all notes that were held */
303  for (i = 0; i < 128; i++) {
304  if (chan->note[i] & SNDRV_MIDI_NOTE_SOSTENUTO) {
305  chan->note[i] &= ~SNDRV_MIDI_NOTE_SOSTENUTO;
306  if (chan->note[i] & SNDRV_MIDI_NOTE_RELEASED) {
307  chan->note[i] = SNDRV_MIDI_NOTE_OFF;
308  if (ops->note_off)
309  ops->note_off(drv, i, 0, chan);
310  }
311  }
312  }
313  }
314  break;
315  case MIDI_CTL_MSB_DATA_ENTRY:
316  chan->control[MIDI_CTL_LSB_DATA_ENTRY] = 0;
317  /* go through here */
318  case MIDI_CTL_LSB_DATA_ENTRY:
319  if (chan->param_type == SNDRV_MIDI_PARAM_TYPE_REGISTERED)
320  rpn(ops, drv, chan, chset);
321  else
322  nrpn(ops, drv, chan, chset);
323  break;
324  case MIDI_CTL_REGIST_PARM_NUM_LSB:
325  case MIDI_CTL_REGIST_PARM_NUM_MSB:
326  chan->param_type = SNDRV_MIDI_PARAM_TYPE_REGISTERED;
327  break;
328  case MIDI_CTL_NONREG_PARM_NUM_LSB:
329  case MIDI_CTL_NONREG_PARM_NUM_MSB:
330  chan->param_type = SNDRV_MIDI_PARAM_TYPE_NONREGISTERED;
331  break;
332 
333  case MIDI_CTL_ALL_SOUNDS_OFF:
334  all_sounds_off(ops, drv, chan);
335  break;
336 
337  case MIDI_CTL_ALL_NOTES_OFF:
338  all_notes_off(ops, drv, chan);
339  break;
340 
341  case MIDI_CTL_MSB_BANK:
342  if (chset->midi_mode == SNDRV_MIDI_MODE_XG) {
343  if (value == 127)
344  chan->drum_channel = 1;
345  else
346  chan->drum_channel = 0;
347  }
348  break;
349  case MIDI_CTL_LSB_BANK:
350  break;
351 
352  case MIDI_CTL_RESET_CONTROLLERS:
353  snd_midi_reset_controllers(chan);
354  break;
355 
356  case MIDI_CTL_SOFT_PEDAL:
357  case MIDI_CTL_LEGATO_FOOTSWITCH:
358  case MIDI_CTL_HOLD2:
359  case MIDI_CTL_SC1_SOUND_VARIATION:
360  case MIDI_CTL_SC2_TIMBRE:
361  case MIDI_CTL_SC3_RELEASE_TIME:
362  case MIDI_CTL_SC4_ATTACK_TIME:
363  case MIDI_CTL_SC5_BRIGHTNESS:
364  case MIDI_CTL_E1_REVERB_DEPTH:
365  case MIDI_CTL_E2_TREMOLO_DEPTH:
366  case MIDI_CTL_E3_CHORUS_DEPTH:
367  case MIDI_CTL_E4_DETUNE_DEPTH:
368  case MIDI_CTL_E5_PHASER_DEPTH:
369  goto notyet;
370  notyet:
371  default:
372  if (ops->control)
373  ops->control(drv, control, chan);
374  break;
375  }
376 }
377 
378 
379 /*
380  * initialize the MIDI status
381  */
382 void
383 snd_midi_channel_set_clear(struct snd_midi_channel_set *chset)
384 {
385  int i;
386 
387  chset->midi_mode = SNDRV_MIDI_MODE_GM;
388  chset->gs_master_volume = 127;
389 
390  for (i = 0; i < chset->max_channels; i++) {
391  struct snd_midi_channel *chan = chset->channels + i;
392  memset(chan->note, 0, sizeof(chan->note));
393 
394  chan->midi_aftertouch = 0;
395  chan->midi_pressure = 0;
396  chan->midi_program = 0;
397  chan->midi_pitchbend = 0;
398  snd_midi_reset_controllers(chan);
399  chan->gm_rpn_pitch_bend_range = 256; /* 2 semitones */
400  chan->gm_rpn_fine_tuning = 0;
401  chan->gm_rpn_coarse_tuning = 0;
402 
403  if (i == 9)
404  chan->drum_channel = 1;
405  else
406  chan->drum_channel = 0;
407  }
408 }
409 
410 /*
411  * Process a rpn message.
412  */
413 static void
414 rpn(struct snd_midi_op *ops, void *drv, struct snd_midi_channel *chan,
415  struct snd_midi_channel_set *chset)
416 {
417  int type;
418  int val;
419 
420  if (chset->midi_mode != SNDRV_MIDI_MODE_NONE) {
421  type = (chan->control[MIDI_CTL_REGIST_PARM_NUM_MSB] << 8) |
422  chan->control[MIDI_CTL_REGIST_PARM_NUM_LSB];
423  val = (chan->control[MIDI_CTL_MSB_DATA_ENTRY] << 7) |
424  chan->control[MIDI_CTL_LSB_DATA_ENTRY];
425 
426  switch (type) {
427  case 0x0000: /* Pitch bend sensitivity */
428  /* MSB only / 1 semitone per 128 */
429  chan->gm_rpn_pitch_bend_range = val;
430  break;
431 
432  case 0x0001: /* fine tuning: */
433  /* MSB/LSB, 8192=center, 100/8192 cent step */
434  chan->gm_rpn_fine_tuning = val - 8192;
435  break;
436 
437  case 0x0002: /* coarse tuning */
438  /* MSB only / 8192=center, 1 semitone per 128 */
439  chan->gm_rpn_coarse_tuning = val - 8192;
440  break;
441 
442  case 0x7F7F: /* "lock-in" RPN */
443  /* ignored */
444  break;
445  }
446  }
447  /* should call nrpn or rpn callback here.. */
448 }
449 
450 /*
451  * Process an nrpn message.
452  */
453 static void
454 nrpn(struct snd_midi_op *ops, void *drv, struct snd_midi_channel *chan,
455  struct snd_midi_channel_set *chset)
456 {
457  /* parse XG NRPNs here if possible */
458  if (ops->nrpn)
459  ops->nrpn(drv, chan, chset);
460 }
461 
462 
463 /*
464  * convert channel parameter in GS sysex
465  */
466 static int
467 get_channel(unsigned char cmd)
468 {
469  int p = cmd & 0x0f;
470  if (p == 0)
471  p = 9;
472  else if (p < 10)
473  p--;
474  return p;
475 }
476 
477 
478 /*
479  * Process a sysex message.
480  */
481 static void
482 sysex(struct snd_midi_op *ops, void *private, unsigned char *buf, int len,
483  struct snd_midi_channel_set *chset)
484 {
485  /* GM on */
486  static unsigned char gm_on_macro[] = {
487  0x7e,0x7f,0x09,0x01,
488  };
489  /* XG on */
490  static unsigned char xg_on_macro[] = {
491  0x43,0x10,0x4c,0x00,0x00,0x7e,0x00,
492  };
493  /* GS prefix
494  * drum channel: XX=0x1?(channel), YY=0x15, ZZ=on/off
495  * reverb mode: XX=0x01, YY=0x30, ZZ=0-7
496  * chorus mode: XX=0x01, YY=0x38, ZZ=0-7
497  * master vol: XX=0x00, YY=0x04, ZZ=0-127
498  */
499  static unsigned char gs_pfx_macro[] = {
500  0x41,0x10,0x42,0x12,0x40,/*XX,YY,ZZ*/
501  };
502 
503  int parsed = SNDRV_MIDI_SYSEX_NOT_PARSED;
504 
505  if (len <= 0 || buf[0] != 0xf0)
506  return;
507  /* skip first byte */
508  buf++;
509  len--;
510 
511  /* GM on */
512  if (len >= (int)sizeof(gm_on_macro) &&
513  memcmp(buf, gm_on_macro, sizeof(gm_on_macro)) == 0) {
514  if (chset->midi_mode != SNDRV_MIDI_MODE_GS &&
515  chset->midi_mode != SNDRV_MIDI_MODE_XG) {
516  chset->midi_mode = SNDRV_MIDI_MODE_GM;
517  reset_all_channels(chset);
518  parsed = SNDRV_MIDI_SYSEX_GM_ON;
519  }
520  }
521 
522  /* GS macros */
523  else if (len >= 8 &&
524  memcmp(buf, gs_pfx_macro, sizeof(gs_pfx_macro)) == 0) {
525  if (chset->midi_mode != SNDRV_MIDI_MODE_GS &&
526  chset->midi_mode != SNDRV_MIDI_MODE_XG)
527  chset->midi_mode = SNDRV_MIDI_MODE_GS;
528 
529  if (buf[5] == 0x00 && buf[6] == 0x7f && buf[7] == 0x00) {
530  /* GS reset */
531  parsed = SNDRV_MIDI_SYSEX_GS_RESET;
532  reset_all_channels(chset);
533  }
534 
535  else if ((buf[5] & 0xf0) == 0x10 && buf[6] == 0x15) {
536  /* drum pattern */
537  int p = get_channel(buf[5]);
538  if (p < chset->max_channels) {
539  parsed = SNDRV_MIDI_SYSEX_GS_DRUM_CHANNEL;
540  if (buf[7])
541  chset->channels[p].drum_channel = 1;
542  else
543  chset->channels[p].drum_channel = 0;
544  }
545 
546  } else if ((buf[5] & 0xf0) == 0x10 && buf[6] == 0x21) {
547  /* program */
548  int p = get_channel(buf[5]);
549  if (p < chset->max_channels &&
550  ! chset->channels[p].drum_channel) {
551  parsed = SNDRV_MIDI_SYSEX_GS_DRUM_CHANNEL;
552  chset->channels[p].midi_program = buf[7];
553  }
554 
555  } else if (buf[5] == 0x01 && buf[6] == 0x30) {
556  /* reverb mode */
557  parsed = SNDRV_MIDI_SYSEX_GS_REVERB_MODE;
558  chset->gs_reverb_mode = buf[7];
559 
560  } else if (buf[5] == 0x01 && buf[6] == 0x38) {
561  /* chorus mode */
562  parsed = SNDRV_MIDI_SYSEX_GS_CHORUS_MODE;
563  chset->gs_chorus_mode = buf[7];
564 
565  } else if (buf[5] == 0x00 && buf[6] == 0x04) {
566  /* master volume */
567  parsed = SNDRV_MIDI_SYSEX_GS_MASTER_VOLUME;
568  chset->gs_master_volume = buf[7];
569 
570  }
571  }
572 
573  /* XG on */
574  else if (len >= (int)sizeof(xg_on_macro) &&
575  memcmp(buf, xg_on_macro, sizeof(xg_on_macro)) == 0) {
576  int i;
577  chset->midi_mode = SNDRV_MIDI_MODE_XG;
578  parsed = SNDRV_MIDI_SYSEX_XG_ON;
579  /* reset CC#0 for drums */
580  for (i = 0; i < chset->max_channels; i++) {
581  if (chset->channels[i].drum_channel)
582  chset->channels[i].control[MIDI_CTL_MSB_BANK] = 127;
583  else
584  chset->channels[i].control[MIDI_CTL_MSB_BANK] = 0;
585  }
586  }
587 
588  if (ops->sysex)
589  ops->sysex(private, buf - 1, len + 1, parsed, chset);
590 }
591 
592 /*
593  * all sound off
594  */
595 static void
596 all_sounds_off(struct snd_midi_op *ops, void *drv, struct snd_midi_channel *chan)
597 {
598  int n;
599 
600  if (! ops->note_terminate)
601  return;
602  for (n = 0; n < 128; n++) {
603  if (chan->note[n]) {
604  ops->note_terminate(drv, n, chan);
605  chan->note[n] = 0;
606  }
607  }
608 }
609 
610 /*
611  * all notes off
612  */
613 static void
614 all_notes_off(struct snd_midi_op *ops, void *drv, struct snd_midi_channel *chan)
615 {
616  int n;
617 
618  if (! ops->note_off)
619  return;
620  for (n = 0; n < 128; n++) {
621  if (chan->note[n] == SNDRV_MIDI_NOTE_ON)
622  note_off(ops, drv, chan, n, 0);
623  }
624 }
625 
626 /*
627  * Initialise a single midi channel control block.
628  */
629 static void snd_midi_channel_init(struct snd_midi_channel *p, int n)
630 {
631  if (p == NULL)
632  return;
633 
634  memset(p, 0, sizeof(struct snd_midi_channel));
635  p->private = NULL;
636  p->number = n;
637 
638  snd_midi_reset_controllers(p);
639  p->gm_rpn_pitch_bend_range = 256; /* 2 semitones */
640  p->gm_rpn_fine_tuning = 0;
641  p->gm_rpn_coarse_tuning = 0;
642 
643  if (n == 9)
644  p->drum_channel = 1; /* Default ch 10 as drums */
645 }
646 
647 /*
648  * Allocate and initialise a set of midi channel control blocks.
649  */
650 static struct snd_midi_channel *snd_midi_channel_init_set(int n)
651 {
652  struct snd_midi_channel *chan;
653  int i;
654 
655  chan = kmalloc(n * sizeof(struct snd_midi_channel), GFP_KERNEL);
656  if (chan) {
657  for (i = 0; i < n; i++)
658  snd_midi_channel_init(chan+i, i);
659  }
660 
661  return chan;
662 }
663 
664 /*
665  * reset all midi channels
666  */
667 static void
668 reset_all_channels(struct snd_midi_channel_set *chset)
669 {
670  int ch;
671  for (ch = 0; ch < chset->max_channels; ch++) {
672  struct snd_midi_channel *chan = chset->channels + ch;
673  snd_midi_reset_controllers(chan);
674  chan->gm_rpn_pitch_bend_range = 256; /* 2 semitones */
675  chan->gm_rpn_fine_tuning = 0;
676  chan->gm_rpn_coarse_tuning = 0;
677 
678  if (ch == 9)
679  chan->drum_channel = 1;
680  else
681  chan->drum_channel = 0;
682  }
683 }
684 
685 
686 /*
687  * Allocate and initialise a midi channel set.
688  */
689 struct snd_midi_channel_set *snd_midi_channel_alloc_set(int n)
690 {
691  struct snd_midi_channel_set *chset;
692 
693  chset = kmalloc(sizeof(*chset), GFP_KERNEL);
694  if (chset) {
695  chset->channels = snd_midi_channel_init_set(n);
696  chset->private_data = NULL;
697  chset->max_channels = n;
698  }
699  return chset;
700 }
701 
702 /*
703  * Reset the midi controllers on a particular channel to default values.
704  */
705 static void snd_midi_reset_controllers(struct snd_midi_channel *chan)
706 {
707  memset(chan->control, 0, sizeof(chan->control));
708  chan->gm_volume = 127;
709  chan->gm_expression = 127;
710  chan->gm_pan = 64;
711 }
712 
713 
714 /*
715  * Free a midi channel set.
716  */
717 void snd_midi_channel_free_set(struct snd_midi_channel_set *chset)
718 {
719  if (chset == NULL)
720  return;
721  kfree(chset->channels);
722  kfree(chset);
723 }
724 
725 static int __init alsa_seq_midi_emul_init(void)
726 {
727  return 0;
728 }
729 
730 static void __exit alsa_seq_midi_emul_exit(void)
731 {
732 }
733 
734 module_init(alsa_seq_midi_emul_init)
735 module_exit(alsa_seq_midi_emul_exit)
736 
737 EXPORT_SYMBOL(snd_midi_process_event);
738 EXPORT_SYMBOL(snd_midi_channel_set_clear);
739 EXPORT_SYMBOL(snd_midi_channel_alloc_set);
740 EXPORT_SYMBOL(snd_midi_channel_free_set);
Generated on Thu Jan 10 2013 15:04:05 for Linux Kernel by   doxygen 1.8.2