sound/core/seq/seq_midi

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

DEFINITIONS
