synth/emux/emux_synth.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  *  Midi synth routines for the Emu8k/Emu10k1
   4  *
   5  *  Copyright (C) 1999 Steve Ratcliffe
   6  *  Copyright (c) 1999-2000 Takashi Iwai <tiwai@suse.de>
   7  *
   8  *  Contains code based on awe_wave.c by Takashi Iwai
   9  */
  10
  11 #include <linux/export.h>
  12 #include "emux_voice.h"
  13 #include <sound/asoundef.h>
  14
  15 /*
  16  * Prototypes
  17  */
  18
  19 /*
  20  * Ensure a value is between two points
  21  * macro evaluates its args more than once, so changed to upper-case.
  22  */
  23 #define LIMITVALUE(x, a, b) do { if ((x) < (a)) (x) = (a); else if ((x) > (b)) (x) = (b); } while (0)
  24 #define LIMITMAX(x, a) do {if ((x) > (a)) (x) = (a); } while (0)
  25
  26 static int get_zone(struct snd_emux *emu, struct snd_emux_port *port,
  27                     int *notep, int vel, struct snd_midi_channel *chan,
  28                     struct snd_sf_zone **table);
  29 static int get_bank(struct snd_emux_port *port, struct snd_midi_channel *chan);
  30 static void terminate_note1(struct snd_emux *emu, int note,
  31                             struct snd_midi_channel *chan, int free);
  32 static void exclusive_note_off(struct snd_emux *emu, struct snd_emux_port *port,
  33                                int exclass);
  34 static void terminate_voice(struct snd_emux *emu, struct snd_emux_voice *vp, int free);
  35 static void update_voice(struct snd_emux *emu, struct snd_emux_voice *vp, int update);
  36 static void setup_voice(struct snd_emux_voice *vp);
  37 static int calc_pan(struct snd_emux_voice *vp);
  38 static int calc_volume(struct snd_emux_voice *vp);
  39 static int calc_pitch(struct snd_emux_voice *vp);
  40
  41
  42 /*
  43  * Start a note.
  44  */
  45 void
  46 snd_emux_note_on(void *p, int note, int vel, struct snd_midi_channel *chan)
  47 {
  48         struct snd_emux *emu;
  49         int i, key, nvoices;
  50         struct snd_emux_voice *vp;
  51         struct snd_sf_zone *table[SNDRV_EMUX_MAX_MULTI_VOICES];
  52         unsigned long flags;
  53         struct snd_emux_port *port;
  54
  55         port = p;
  56         if (snd_BUG_ON(!port || !chan))
  57                 return;
  58
  59         emu = port->emu;
  60         if (snd_BUG_ON(!emu || !emu->ops.get_voice || !emu->ops.trigger))
  61                 return;
  62
  63         key = note; /* remember the original note */
  64         nvoices = get_zone(emu, port, &note, vel, chan, table);
  65         if (! nvoices)
  66                 return;
  67
  68         /* exclusive note off */
  69         for (i = 0; i < nvoices; i++) {
  70                 struct snd_sf_zone *zp = table[i];
  71                 if (zp && zp->v.exclusiveClass)
  72                         exclusive_note_off(emu, port, zp->v.exclusiveClass);
  73         }
  74
  75 #if 0 // seems not necessary
  76         /* Turn off the same note on the same channel. */
  77         terminate_note1(emu, key, chan, 0);
  78 #endif
  79
  80         spin_lock_irqsave(&emu->voice_lock, flags);
  81         for (i = 0; i < nvoices; i++) {
  82
  83                 /* set up each voice parameter */
  84                 /* at this stage, we don't trigger the voice yet. */
  85
  86                 if (table[i] == NULL)
  87                         continue;
  88
  89                 vp = emu->ops.get_voice(emu, port);
  90                 if (vp == NULL || vp->ch < 0)
  91                         continue;
  92                 if (STATE_IS_PLAYING(vp->state))
  93                         emu->ops.terminate(vp);
  94
  95                 vp->time = emu->use_time++;
  96                 vp->chan = chan;
  97                 vp->port = port;
  98                 vp->key = key;
  99                 vp->note = note;
 100                 vp->velocity = vel;
 101                 vp->zone = table[i];
 102                 if (vp->zone->sample)
 103                         vp->block = vp->zone->sample->block;
 104                 else
 105                         vp->block = NULL;
 106
 107                 setup_voice(vp);
 108
 109                 vp->state = SNDRV_EMUX_ST_STANDBY;
 110                 if (emu->ops.prepare) {
 111                         vp->state = SNDRV_EMUX_ST_OFF;
 112                         if (emu->ops.prepare(vp) >= 0)
 113                                 vp->state = SNDRV_EMUX_ST_STANDBY;
 114                 }
 115         }
 116
 117         /* start envelope now */
 118         for (i = 0; i < emu->max_voices; i++) {
 119                 vp = &emu->voices[i];
 120                 if (vp->state == SNDRV_EMUX_ST_STANDBY &&
 121                     vp->chan == chan) {
 122                         emu->ops.trigger(vp);
 123                         vp->state = SNDRV_EMUX_ST_ON;
 124                         vp->ontime = jiffies; /* remember the trigger timing */
 125                 }
 126         }
 127         spin_unlock_irqrestore(&emu->voice_lock, flags);
 128
 129 #ifdef SNDRV_EMUX_USE_RAW_EFFECT
 130         if (port->port_mode == SNDRV_EMUX_PORT_MODE_OSS_SYNTH) {
 131                 /* clear voice position for the next note on this channel */
 132                 struct snd_emux_effect_table *fx = chan->private;
 133                 if (fx) {
 134                         fx->flag[EMUX_FX_SAMPLE_START] = 0;
 135                         fx->flag[EMUX_FX_COARSE_SAMPLE_START] = 0;
 136                 }
 137         }
 138 #endif
 139 }
 140
 141 /*
 142  * Release a note in response to a midi note off.
 143  */
 144 void
 145 snd_emux_note_off(void *p, int note, int vel, struct snd_midi_channel *chan)
 146 {
 147         int ch;
 148         struct snd_emux *emu;
 149         struct snd_emux_voice *vp;
 150         unsigned long flags;
 151         struct snd_emux_port *port;
 152
 153         port = p;
 154         if (snd_BUG_ON(!port || !chan))
 155                 return;
 156
 157         emu = port->emu;
 158         if (snd_BUG_ON(!emu || !emu->ops.release))
 159                 return;
 160
 161         spin_lock_irqsave(&emu->voice_lock, flags);
 162         for (ch = 0; ch < emu->max_voices; ch++) {
 163                 vp = &emu->voices[ch];
 164                 if (STATE_IS_PLAYING(vp->state) &&
 165                     vp->chan == chan && vp->key == note) {
 166                         vp->state = SNDRV_EMUX_ST_RELEASED;
 167                         if (vp->ontime == jiffies) {
 168                                 /* if note-off is sent too shortly after
 169                                  * note-on, emuX engine cannot produce the sound
 170                                  * correctly.  so we'll release this note
 171                                  * a bit later via timer callback.
 172                                  */
 173                                 vp->state = SNDRV_EMUX_ST_PENDING;
 174                                 if (! emu->timer_active) {
 175                                         mod_timer(&emu->tlist, jiffies + 1);
 176                                         emu->timer_active = 1;
 177                                 }
 178                         } else
 179                                 /* ok now release the note */
 180                                 emu->ops.release(vp);
 181                 }
 182         }
 183         spin_unlock_irqrestore(&emu->voice_lock, flags);
 184 }
 185
 186 /*
 187  * timer callback
 188  *
 189  * release the pending note-offs
 190  */
 191 void snd_emux_timer_callback(struct timer_list *t)
 192 {
 193         struct snd_emux *emu = from_timer(emu, t, tlist);
 194         struct snd_emux_voice *vp;
 195         unsigned long flags;
 196         int ch, do_again = 0;
 197
 198         spin_lock_irqsave(&emu->voice_lock, flags);
 199         for (ch = 0; ch < emu->max_voices; ch++) {
 200                 vp = &emu->voices[ch];
 201                 if (vp->state == SNDRV_EMUX_ST_PENDING) {
 202                         if (vp->ontime == jiffies)
 203                                 do_again++; /* release this at the next interrupt */
 204                         else {
 205                                 emu->ops.release(vp);
 206                                 vp->state = SNDRV_EMUX_ST_RELEASED;
 207                         }
 208                 }
 209         }
 210         if (do_again) {
 211                 mod_timer(&emu->tlist, jiffies + 1);
 212                 emu->timer_active = 1;
 213         } else
 214                 emu->timer_active = 0;
 215         spin_unlock_irqrestore(&emu->voice_lock, flags);
 216 }
 217
 218 /*
 219  * key pressure change
 220  */
 221 void
 222 snd_emux_key_press(void *p, int note, int vel, struct snd_midi_channel *chan)
 223 {
 224         int ch;
 225         struct snd_emux *emu;
 226         struct snd_emux_voice *vp;
 227         unsigned long flags;
 228         struct snd_emux_port *port;
 229
 230         port = p;
 231         if (snd_BUG_ON(!port || !chan))
 232                 return;
 233
 234         emu = port->emu;
 235         if (snd_BUG_ON(!emu || !emu->ops.update))
 236                 return;
 237
 238         spin_lock_irqsave(&emu->voice_lock, flags);
 239         for (ch = 0; ch < emu->max_voices; ch++) {
 240                 vp = &emu->voices[ch];
 241                 if (vp->state == SNDRV_EMUX_ST_ON &&
 242                     vp->chan == chan && vp->key == note) {
 243                         vp->velocity = vel;
 244                         update_voice(emu, vp, SNDRV_EMUX_UPDATE_VOLUME);
 245                 }
 246         }
 247         spin_unlock_irqrestore(&emu->voice_lock, flags);
 248 }
 249
 250
 251 /*
 252  * Modulate the voices which belong to the channel
 253  */
 254 void
 255 snd_emux_update_channel(struct snd_emux_port *port, struct snd_midi_channel *chan, int update)
 256 {
 257         struct snd_emux *emu;
 258         struct snd_emux_voice *vp;
 259         int i;
 260         unsigned long flags;
 261
 262         if (! update)
 263                 return;
 264
 265         emu = port->emu;
 266         if (snd_BUG_ON(!emu || !emu->ops.update))
 267                 return;
 268
 269         spin_lock_irqsave(&emu->voice_lock, flags);
 270         for (i = 0; i < emu->max_voices; i++) {
 271                 vp = &emu->voices[i];
 272                 if (vp->chan == chan)
 273                         update_voice(emu, vp, update);
 274         }
 275         spin_unlock_irqrestore(&emu->voice_lock, flags);
 276 }
 277
 278 /*
 279  * Modulate all the voices which belong to the port.
 280  */
 281 void
 282 snd_emux_update_port(struct snd_emux_port *port, int update)
 283 {
 284         struct snd_emux *emu;
 285         struct snd_emux_voice *vp;
 286         int i;
 287         unsigned long flags;
 288
 289         if (! update)
 290                 return;
 291
 292         emu = port->emu;
 293         if (snd_BUG_ON(!emu || !emu->ops.update))
 294                 return;
 295
 296         spin_lock_irqsave(&emu->voice_lock, flags);
 297         for (i = 0; i < emu->max_voices; i++) {
 298                 vp = &emu->voices[i];
 299                 if (vp->port == port)
 300                         update_voice(emu, vp, update);
 301         }
 302         spin_unlock_irqrestore(&emu->voice_lock, flags);
 303 }
 304
 305
 306 /*
 307  * Deal with a controller type event.  This includes all types of
 308  * control events, not just the midi controllers
 309  */
 310 void
 311 snd_emux_control(void *p, int type, struct snd_midi_channel *chan)
 312 {
 313         struct snd_emux_port *port;
 314
 315         port = p;
 316         if (snd_BUG_ON(!port || !chan))
 317                 return;
 318
 319         switch (type) {
 320         case MIDI_CTL_MSB_MAIN_VOLUME:
 321         case MIDI_CTL_MSB_EXPRESSION:
 322                 snd_emux_update_channel(port, chan, SNDRV_EMUX_UPDATE_VOLUME);
 323                 break;
 324
 325         case MIDI_CTL_MSB_PAN:
 326                 snd_emux_update_channel(port, chan, SNDRV_EMUX_UPDATE_PAN);
 327                 break;
 328
 329         case MIDI_CTL_SOFT_PEDAL:
 330 #ifdef SNDRV_EMUX_USE_RAW_EFFECT
 331                 /* FIXME: this is an emulation */
 332                 if (chan->control[type] >= 64)
 333                         snd_emux_send_effect(port, chan, EMUX_FX_CUTOFF, -160,
 334                                      EMUX_FX_FLAG_ADD);
 335                 else
 336                         snd_emux_send_effect(port, chan, EMUX_FX_CUTOFF, 0,
 337                                      EMUX_FX_FLAG_OFF);
 338 #endif
 339                 break;
 340
 341         case MIDI_CTL_PITCHBEND:
 342                 snd_emux_update_channel(port, chan, SNDRV_EMUX_UPDATE_PITCH);
 343                 break;
 344
 345         case MIDI_CTL_MSB_MODWHEEL:
 346         case MIDI_CTL_CHAN_PRESSURE:
 347                 snd_emux_update_channel(port, chan,
 348                                         SNDRV_EMUX_UPDATE_FMMOD |
 349                                         SNDRV_EMUX_UPDATE_FM2FRQ2);
 350                 break;
 351
 352         }
 353
 354         if (port->chset.midi_mode == SNDRV_MIDI_MODE_XG) {
 355                 snd_emux_xg_control(port, chan, type);
 356         }
 357 }
 358
 359
 360 /*
 361  * terminate note - if free flag is true, free the terminated voice
 362  */
 363 static void
 364 terminate_note1(struct snd_emux *emu, int note, struct snd_midi_channel *chan, int free)
 365 {
 366         int  i;
 367         struct snd_emux_voice *vp;
 368         unsigned long flags;
 369
 370         spin_lock_irqsave(&emu->voice_lock, flags);
 371         for (i = 0; i < emu->max_voices; i++) {
 372                 vp = &emu->voices[i];
 373                 if (STATE_IS_PLAYING(vp->state) && vp->chan == chan &&
 374                     vp->key == note)
 375                         terminate_voice(emu, vp, free);
 376         }
 377         spin_unlock_irqrestore(&emu->voice_lock, flags);
 378 }
 379
 380
 381 /*
 382  * terminate note - exported for midi emulation
 383  */
 384 void
 385 snd_emux_terminate_note(void *p, int note, struct snd_midi_channel *chan)
 386 {
 387         struct snd_emux *emu;
 388         struct snd_emux_port *port;
 389
 390         port = p;
 391         if (snd_BUG_ON(!port || !chan))
 392                 return;
 393
 394         emu = port->emu;
 395         if (snd_BUG_ON(!emu || !emu->ops.terminate))
 396                 return;
 397
 398         terminate_note1(emu, note, chan, 1);
 399 }
 400
 401
 402 /*
 403  * Terminate all the notes
 404  */
 405 void
 406 snd_emux_terminate_all(struct snd_emux *emu)
 407 {
 408         int i;
 409         struct snd_emux_voice *vp;
 410         unsigned long flags;
 411
 412         spin_lock_irqsave(&emu->voice_lock, flags);
 413         for (i = 0; i < emu->max_voices; i++) {
 414                 vp = &emu->voices[i];
 415                 if (STATE_IS_PLAYING(vp->state))
 416                         terminate_voice(emu, vp, 0);
 417                 if (vp->state == SNDRV_EMUX_ST_OFF) {
 418                         if (emu->ops.free_voice)
 419                                 emu->ops.free_voice(vp);
 420                         if (emu->ops.reset)
 421                                 emu->ops.reset(emu, i);
 422                 }
 423                 vp->time = 0;
 424         }
 425         /* initialize allocation time */
 426         emu->use_time = 0;
 427         spin_unlock_irqrestore(&emu->voice_lock, flags);
 428 }
 429
 430 EXPORT_SYMBOL(snd_emux_terminate_all);
 431
 432 /*
 433  * Terminate all voices associated with the given port
 434  */
 435 void
 436 snd_emux_sounds_off_all(struct snd_emux_port *port)
 437 {
 438         int i;
 439         struct snd_emux *emu;
 440         struct snd_emux_voice *vp;
 441         unsigned long flags;
 442
 443         if (snd_BUG_ON(!port))
 444                 return;
 445         emu = port->emu;
 446         if (snd_BUG_ON(!emu || !emu->ops.terminate))
 447                 return;
 448
 449         spin_lock_irqsave(&emu->voice_lock, flags);
 450         for (i = 0; i < emu->max_voices; i++) {
 451                 vp = &emu->voices[i];
 452                 if (STATE_IS_PLAYING(vp->state) &&
 453                     vp->port == port)
 454                         terminate_voice(emu, vp, 0);
 455                 if (vp->state == SNDRV_EMUX_ST_OFF) {
 456                         if (emu->ops.free_voice)
 457                                 emu->ops.free_voice(vp);
 458                         if (emu->ops.reset)
 459                                 emu->ops.reset(emu, i);
 460                 }
 461         }
 462         spin_unlock_irqrestore(&emu->voice_lock, flags);
 463 }
 464
 465
 466 /*
 467  * Terminate all voices that have the same exclusive class.  This
 468  * is mainly for drums.
 469  */
 470 static void
 471 exclusive_note_off(struct snd_emux *emu, struct snd_emux_port *port, int exclass)
 472 {
 473         struct snd_emux_voice *vp;
 474         int  i;
 475         unsigned long flags;
 476
 477         spin_lock_irqsave(&emu->voice_lock, flags);
 478         for (i = 0; i < emu->max_voices; i++) {
 479                 vp = &emu->voices[i];
 480                 if (STATE_IS_PLAYING(vp->state) && vp->port == port &&
 481                     vp->reg.exclusiveClass == exclass) {
 482                         terminate_voice(emu, vp, 0);
 483                 }
 484         }
 485         spin_unlock_irqrestore(&emu->voice_lock, flags);
 486 }
 487
 488 /*
 489  * terminate a voice
 490  * if free flag is true, call free_voice after termination
 491  */
 492 static void
 493 terminate_voice(struct snd_emux *emu, struct snd_emux_voice *vp, int free)
 494 {
 495         emu->ops.terminate(vp);
 496         vp->time = emu->use_time++;
 497         vp->chan = NULL;
 498         vp->port = NULL;
 499         vp->zone = NULL;
 500         vp->block = NULL;
 501         vp->state = SNDRV_EMUX_ST_OFF;
 502         if (free && emu->ops.free_voice)
 503                 emu->ops.free_voice(vp);
 504 }
 505
 506
 507 /*
 508  * Modulate the voice
 509  */
 510 static void
 511 update_voice(struct snd_emux *emu, struct snd_emux_voice *vp, int update)
 512 {
 513         if (!STATE_IS_PLAYING(vp->state))
 514                 return;
 515
 516         if (vp->chan == NULL || vp->port == NULL)
 517                 return;
 518         if (update & SNDRV_EMUX_UPDATE_VOLUME)
 519                 calc_volume(vp);
 520         if (update & SNDRV_EMUX_UPDATE_PITCH)
 521                 calc_pitch(vp);
 522         if (update & SNDRV_EMUX_UPDATE_PAN) {
 523                 if (! calc_pan(vp) && (update == SNDRV_EMUX_UPDATE_PAN))
 524                         return;
 525         }
 526         emu->ops.update(vp, update);
 527 }
 528
 529
 530 #if 0 // not used
 531 /* table for volume target calculation */
 532 static const unsigned short voltarget[16] = {
 533         0xEAC0, 0xE0C8, 0xD740, 0xCE20, 0xC560, 0xBD08, 0xB500, 0xAD58,
 534         0xA5F8, 0x9EF0, 0x9830, 0x91C0, 0x8B90, 0x85A8, 0x8000, 0x7A90
 535 };
 536 #endif
 537
 538 #define LO_BYTE(v)      ((v) & 0xff)
 539 #define HI_BYTE(v)      (((v) >> 8) & 0xff)
 540
 541 /*
 542  * Sets up the voice structure by calculating some values that
 543  * will be needed later.
 544  */
 545 static void
 546 setup_voice(struct snd_emux_voice *vp)
 547 {
 548         struct soundfont_voice_parm *parm;
 549         int pitch;
 550
 551         /* copy the original register values */
 552         vp->reg = vp->zone->v;
 553
 554 #ifdef SNDRV_EMUX_USE_RAW_EFFECT
 555         snd_emux_setup_effect(vp);
 556 #endif
 557
 558         /* reset status */
 559         vp->apan = -1;
 560         vp->avol = -1;
 561         vp->apitch = -1;
 562
 563         calc_volume(vp);
 564         calc_pitch(vp);
 565         calc_pan(vp);
 566
 567         parm = &vp->reg.parm;
 568
 569         /* compute filter target and correct modulation parameters */
 570         if (LO_BYTE(parm->modatkhld) >= 0x80 && parm->moddelay >= 0x8000) {
 571                 parm->moddelay = 0xbfff;
 572                 pitch = (HI_BYTE(parm->pefe) << 4) + vp->apitch;
 573                 if (pitch > 0xffff)
 574                         pitch = 0xffff;
 575                 /* calculate filter target */
 576                 vp->ftarget = parm->cutoff + LO_BYTE(parm->pefe);
 577                 LIMITVALUE(vp->ftarget, 0, 255);
 578                 vp->ftarget <<= 8;
 579         } else {
 580                 vp->ftarget = parm->cutoff;
 581                 vp->ftarget <<= 8;
 582                 pitch = vp->apitch;
 583         }
 584
 585         /* compute pitch target */
 586         if (pitch != 0xffff) {
 587                 vp->ptarget = 1 << (pitch >> 12);
 588                 if (pitch & 0x800) vp->ptarget += (vp->ptarget*0x102e)/0x2710;
 589                 if (pitch & 0x400) vp->ptarget += (vp->ptarget*0x764)/0x2710;
 590                 if (pitch & 0x200) vp->ptarget += (vp->ptarget*0x389)/0x2710;
 591                 vp->ptarget += (vp->ptarget >> 1);
 592                 if (vp->ptarget > 0xffff) vp->ptarget = 0xffff;
 593         } else
 594                 vp->ptarget = 0xffff;
 595
 596         if (LO_BYTE(parm->modatkhld) >= 0x80) {
 597                 parm->modatkhld &= ~0xff;
 598                 parm->modatkhld |= 0x7f;
 599         }
 600
 601         /* compute volume target and correct volume parameters */
 602         vp->vtarget = 0;
 603 #if 0 /* FIXME: this leads to some clicks.. */
 604         if (LO_BYTE(parm->volatkhld) >= 0x80 && parm->voldelay >= 0x8000) {
 605                 parm->voldelay = 0xbfff;
 606                 vp->vtarget = voltarget[vp->avol % 0x10] >> (vp->avol >> 4);
 607         }
 608 #endif
 609
 610         if (LO_BYTE(parm->volatkhld) >= 0x80) {
 611                 parm->volatkhld &= ~0xff;
 612                 parm->volatkhld |= 0x7f;
 613         }
 614 }
 615
 616 /*
 617  * calculate pitch parameter
 618  */
 619 static const unsigned char pan_volumes[256] = {
 620 0x00,0x03,0x06,0x09,0x0c,0x0f,0x12,0x14,0x17,0x1a,0x1d,0x20,0x22,0x25,0x28,0x2a,
 621 0x2d,0x30,0x32,0x35,0x37,0x3a,0x3c,0x3f,0x41,0x44,0x46,0x49,0x4b,0x4d,0x50,0x52,
 622 0x54,0x57,0x59,0x5b,0x5d,0x60,0x62,0x64,0x66,0x68,0x6a,0x6c,0x6f,0x71,0x73,0x75,
 623 0x77,0x79,0x7b,0x7c,0x7e,0x80,0x82,0x84,0x86,0x88,0x89,0x8b,0x8d,0x8f,0x90,0x92,
 624 0x94,0x96,0x97,0x99,0x9a,0x9c,0x9e,0x9f,0xa1,0xa2,0xa4,0xa5,0xa7,0xa8,0xaa,0xab,
 625 0xad,0xae,0xaf,0xb1,0xb2,0xb3,0xb5,0xb6,0xb7,0xb9,0xba,0xbb,0xbc,0xbe,0xbf,0xc0,
 626 0xc1,0xc2,0xc3,0xc5,0xc6,0xc7,0xc8,0xc9,0xca,0xcb,0xcc,0xcd,0xce,0xcf,0xd0,0xd1,
 627 0xd2,0xd3,0xd4,0xd5,0xd6,0xd7,0xd7,0xd8,0xd9,0xda,0xdb,0xdc,0xdc,0xdd,0xde,0xdf,
 628 0xdf,0xe0,0xe1,0xe2,0xe2,0xe3,0xe4,0xe4,0xe5,0xe6,0xe6,0xe7,0xe8,0xe8,0xe9,0xe9,
 629 0xea,0xeb,0xeb,0xec,0xec,0xed,0xed,0xee,0xee,0xef,0xef,0xf0,0xf0,0xf1,0xf1,0xf1,
 630 0xf2,0xf2,0xf3,0xf3,0xf3,0xf4,0xf4,0xf5,0xf5,0xf5,0xf6,0xf6,0xf6,0xf7,0xf7,0xf7,
 631 0xf7,0xf8,0xf8,0xf8,0xf9,0xf9,0xf9,0xf9,0xf9,0xfa,0xfa,0xfa,0xfa,0xfb,0xfb,0xfb,
 632 0xfb,0xfb,0xfc,0xfc,0xfc,0xfc,0xfc,0xfc,0xfc,0xfd,0xfd,0xfd,0xfd,0xfd,0xfd,0xfd,
 633 0xfd,0xfe,0xfe,0xfe,0xfe,0xfe,0xfe,0xfe,0xfe,0xfe,0xfe,0xfe,0xfe,0xfe,0xfe,0xfe,
 634 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
 635 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
 636 };
 637
 638 static int
 639 calc_pan(struct snd_emux_voice *vp)
 640 {
 641         struct snd_midi_channel *chan = vp->chan;
 642         int pan;
 643
 644         /* pan & loop start (pan 8bit, MSB, 0:right, 0xff:left) */
 645         if (vp->reg.fixpan > 0) /* 0-127 */
 646                 pan = 255 - (int)vp->reg.fixpan * 2;
 647         else {
 648                 pan = chan->control[MIDI_CTL_MSB_PAN] - 64;
 649                 if (vp->reg.pan >= 0) /* 0-127 */
 650                         pan += vp->reg.pan - 64;
 651                 pan = 127 - (int)pan * 2;
 652         }
 653         LIMITVALUE(pan, 0, 255);
 654
 655         if (vp->emu->linear_panning) {
 656                 /* assuming linear volume */
 657                 if (pan != vp->apan) {
 658                         vp->apan = pan;
 659                         if (pan == 0)
 660                                 vp->aaux = 0xff;
 661                         else
 662                                 vp->aaux = (-pan) & 0xff;
 663                         return 1;
 664                 } else
 665                         return 0;
 666         } else {
 667                 /* using volume table */
 668                 if (vp->apan != (int)pan_volumes[pan]) {
 669                         vp->apan = pan_volumes[pan];
 670                         vp->aaux = pan_volumes[255 - pan];
 671                         return 1;
 672                 }
 673                 return 0;
 674         }
 675 }
 676
 677
 678 /*
 679  * calculate volume attenuation
 680  *
 681  * Voice volume is controlled by volume attenuation parameter.
 682  * So volume becomes maximum when avol is 0 (no attenuation), and
 683  * minimum when 255 (-96dB or silence).
 684  */
 685
 686 /* tables for volume->attenuation calculation */
 687 static const unsigned char voltab1[128] = {
 688    0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63,
 689    0x63, 0x2b, 0x29, 0x28, 0x27, 0x26, 0x25, 0x24, 0x23, 0x22,
 690    0x21, 0x20, 0x1f, 0x1e, 0x1e, 0x1d, 0x1c, 0x1b, 0x1b, 0x1a,
 691    0x19, 0x19, 0x18, 0x17, 0x17, 0x16, 0x16, 0x15, 0x15, 0x14,
 692    0x14, 0x13, 0x13, 0x13, 0x12, 0x12, 0x11, 0x11, 0x11, 0x10,
 693    0x10, 0x10, 0x0f, 0x0f, 0x0f, 0x0e, 0x0e, 0x0e, 0x0e, 0x0d,
 694    0x0d, 0x0d, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0b, 0x0b, 0x0b,
 695    0x0b, 0x0a, 0x0a, 0x0a, 0x0a, 0x09, 0x09, 0x09, 0x09, 0x09,
 696    0x08, 0x08, 0x08, 0x08, 0x08, 0x07, 0x07, 0x07, 0x07, 0x06,
 697    0x06, 0x06, 0x06, 0x06, 0x05, 0x05, 0x05, 0x05, 0x05, 0x04,
 698    0x04, 0x04, 0x04, 0x04, 0x03, 0x03, 0x03, 0x03, 0x03, 0x02,
 699    0x02, 0x02, 0x02, 0x02, 0x02, 0x01, 0x01, 0x01, 0x01, 0x01,
 700    0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
 701 };
 702
 703 static const unsigned char voltab2[128] = {
 704    0x32, 0x31, 0x30, 0x2f, 0x2e, 0x2d, 0x2c, 0x2b, 0x2a, 0x2a,
 705    0x29, 0x28, 0x27, 0x26, 0x25, 0x24, 0x24, 0x23, 0x22, 0x21,
 706    0x21, 0x20, 0x1f, 0x1e, 0x1e, 0x1d, 0x1c, 0x1c, 0x1b, 0x1a,
 707    0x1a, 0x19, 0x19, 0x18, 0x18, 0x17, 0x16, 0x16, 0x15, 0x15,
 708    0x14, 0x14, 0x13, 0x13, 0x13, 0x12, 0x12, 0x11, 0x11, 0x10,
 709    0x10, 0x10, 0x0f, 0x0f, 0x0f, 0x0e, 0x0e, 0x0e, 0x0d, 0x0d,
 710    0x0d, 0x0c, 0x0c, 0x0c, 0x0b, 0x0b, 0x0b, 0x0b, 0x0a, 0x0a,
 711    0x0a, 0x0a, 0x09, 0x09, 0x09, 0x09, 0x09, 0x08, 0x08, 0x08,
 712    0x08, 0x08, 0x07, 0x07, 0x07, 0x07, 0x07, 0x06, 0x06, 0x06,
 713    0x06, 0x06, 0x06, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
 714    0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x03, 0x03, 0x03, 0x03,
 715    0x03, 0x03, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x01, 0x01,
 716    0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00
 717 };
 718
 719 static const unsigned char expressiontab[128] = {
 720    0x7f, 0x6c, 0x62, 0x5a, 0x54, 0x50, 0x4b, 0x48, 0x45, 0x42,
 721    0x40, 0x3d, 0x3b, 0x39, 0x38, 0x36, 0x34, 0x33, 0x31, 0x30,
 722    0x2f, 0x2d, 0x2c, 0x2b, 0x2a, 0x29, 0x28, 0x27, 0x26, 0x25,
 723    0x24, 0x24, 0x23, 0x22, 0x21, 0x21, 0x20, 0x1f, 0x1e, 0x1e,
 724    0x1d, 0x1d, 0x1c, 0x1b, 0x1b, 0x1a, 0x1a, 0x19, 0x18, 0x18,
 725    0x17, 0x17, 0x16, 0x16, 0x15, 0x15, 0x15, 0x14, 0x14, 0x13,
 726    0x13, 0x12, 0x12, 0x11, 0x11, 0x11, 0x10, 0x10, 0x0f, 0x0f,
 727    0x0f, 0x0e, 0x0e, 0x0e, 0x0d, 0x0d, 0x0d, 0x0c, 0x0c, 0x0c,
 728    0x0b, 0x0b, 0x0b, 0x0a, 0x0a, 0x0a, 0x09, 0x09, 0x09, 0x09,
 729    0x08, 0x08, 0x08, 0x07, 0x07, 0x07, 0x07, 0x06, 0x06, 0x06,
 730    0x06, 0x05, 0x05, 0x05, 0x04, 0x04, 0x04, 0x04, 0x04, 0x03,
 731    0x03, 0x03, 0x03, 0x02, 0x02, 0x02, 0x02, 0x01, 0x01, 0x01,
 732    0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
 733 };
 734
 735 /*
 736  * Magic to calculate the volume (actually attenuation) from all the
 737  * voice and channels parameters.
 738  */
 739 static int
 740 calc_volume(struct snd_emux_voice *vp)
 741 {
 742         int vol;
 743         int main_vol, expression_vol, master_vol;
 744         struct snd_midi_channel *chan = vp->chan;
 745         struct snd_emux_port *port = vp->port;
 746
 747         expression_vol = chan->control[MIDI_CTL_MSB_EXPRESSION];
 748         LIMITMAX(vp->velocity, 127);
 749         LIMITVALUE(expression_vol, 0, 127);
 750         if (port->port_mode == SNDRV_EMUX_PORT_MODE_OSS_SYNTH) {
 751                 /* 0 - 127 */
 752                 main_vol = chan->control[MIDI_CTL_MSB_MAIN_VOLUME];
 753                 vol = (vp->velocity * main_vol * expression_vol) / (127*127);
 754                 vol = vol * vp->reg.amplitude / 127;
 755
 756                 LIMITVALUE(vol, 0, 127);
 757
 758                 /* calc to attenuation */
 759                 vol = snd_sf_vol_table[vol];
 760
 761         } else {
 762                 main_vol = chan->control[MIDI_CTL_MSB_MAIN_VOLUME] * vp->reg.amplitude / 127;
 763                 LIMITVALUE(main_vol, 0, 127);
 764
 765                 vol = voltab1[main_vol] + voltab2[vp->velocity];
 766                 vol = (vol * 8) / 3;
 767                 vol += vp->reg.attenuation;
 768                 vol += ((0x100 - vol) * expressiontab[expression_vol])/128;
 769         }
 770
 771         master_vol = port->chset.gs_master_volume;
 772         LIMITVALUE(master_vol, 0, 127);
 773         vol += snd_sf_vol_table[master_vol];
 774         vol += port->volume_atten;
 775
 776 #ifdef SNDRV_EMUX_USE_RAW_EFFECT
 777         if (chan->private) {
 778                 struct snd_emux_effect_table *fx = chan->private;
 779                 vol += fx->val[EMUX_FX_ATTEN];
 780         }
 781 #endif
 782
 783         LIMITVALUE(vol, 0, 255);
 784         if (vp->avol == vol)
 785                 return 0; /* value unchanged */
 786
 787         vp->avol = vol;
 788         if (!SF_IS_DRUM_BANK(get_bank(port, chan))
 789             && LO_BYTE(vp->reg.parm.volatkhld) < 0x7d) {
 790                 int atten;
 791                 if (vp->velocity < 70)
 792                         atten = 70;
 793                 else
 794                         atten = vp->velocity;
 795                 vp->acutoff = (atten * vp->reg.parm.cutoff + 0xa0) >> 7;
 796         } else {
 797                 vp->acutoff = vp->reg.parm.cutoff;
 798         }
 799
 800         return 1; /* value changed */
 801 }
 802
 803 /*
 804  * calculate pitch offset
 805  *
 806  * 0xE000 is no pitch offset at 44100Hz sample.
 807  * Every 4096 is one octave.
 808  */
 809
 810 static int
 811 calc_pitch(struct snd_emux_voice *vp)
 812 {
 813         struct snd_midi_channel *chan = vp->chan;
 814         int offset;
 815
 816         /* calculate offset */
 817         if (vp->reg.fixkey >= 0) {
 818                 offset = (vp->reg.fixkey - vp->reg.root) * 4096 / 12;
 819         } else {
 820                 offset = (vp->note - vp->reg.root) * 4096 / 12;
 821         }
 822         offset = (offset * vp->reg.scaleTuning) / 100;
 823         offset += vp->reg.tune * 4096 / 1200;
 824         if (chan->midi_pitchbend != 0) {
 825                 /* (128 * 8192: 1 semitone) ==> (4096: 12 semitones) */
 826                 offset += chan->midi_pitchbend * chan->gm_rpn_pitch_bend_range / 3072;
 827         }
 828
 829         /* tuning via RPN:
 830          *   coarse = -8192 to 8192 (100 cent per 128)
 831          *   fine = -8192 to 8192 (max=100cent)
 832          */
 833         /* 4096 = 1200 cents in emu8000 parameter */
 834         offset += chan->gm_rpn_coarse_tuning * 4096 / (12 * 128);
 835         offset += chan->gm_rpn_fine_tuning / 24;
 836
 837 #ifdef SNDRV_EMUX_USE_RAW_EFFECT
 838         /* add initial pitch correction */
 839         if (chan->private) {
 840                 struct snd_emux_effect_table *fx = chan->private;
 841                 if (fx->flag[EMUX_FX_INIT_PITCH])
 842                         offset += fx->val[EMUX_FX_INIT_PITCH];
 843         }
 844 #endif
 845
 846         /* 0xe000: root pitch */
 847         offset += 0xe000 + vp->reg.rate_offset;
 848         if (vp->emu->ops.get_pitch_shift)
 849                 offset += vp->emu->ops.get_pitch_shift(vp->emu);
 850         LIMITVALUE(offset, 0, 0xffff);
 851         if (offset == vp->apitch)
 852                 return 0; /* unchanged */
 853         vp->apitch = offset;
 854         return 1; /* value changed */
 855 }
 856
 857 /*
 858  * Get the bank number assigned to the channel
 859  */
 860 static int
 861 get_bank(struct snd_emux_port *port, struct snd_midi_channel *chan)
 862 {
 863         int val;
 864
 865         switch (port->chset.midi_mode) {
 866         case SNDRV_MIDI_MODE_XG:
 867                 val = chan->control[MIDI_CTL_MSB_BANK];
 868                 if (val == 127)
 869                         return 128; /* return drum bank */
 870                 return chan->control[MIDI_CTL_LSB_BANK];
 871
 872         case SNDRV_MIDI_MODE_GS:
 873                 if (chan->drum_channel)
 874                         return 128;
 875                 /* ignore LSB (bank map) */
 876                 return chan->control[MIDI_CTL_MSB_BANK];
 877
 878         default:
 879                 if (chan->drum_channel)
 880                         return 128;
 881                 return chan->control[MIDI_CTL_MSB_BANK];
 882         }
 883 }
 884
 885
 886 /* Look for the zones matching with the given note and velocity.
 887  * The resultant zones are stored on table.
 888  */
 889 static int
 890 get_zone(struct snd_emux *emu, struct snd_emux_port *port,
 891          int *notep, int vel, struct snd_midi_channel *chan,
 892          struct snd_sf_zone **table)
 893 {
 894         int preset, bank, def_preset, def_bank;
 895
 896         bank = get_bank(port, chan);
 897         preset = chan->midi_program;
 898
 899         if (SF_IS_DRUM_BANK(bank)) {
 900                 def_preset = port->ctrls[EMUX_MD_DEF_DRUM];
 901                 def_bank = bank;
 902         } else {
 903                 def_preset = preset;
 904                 def_bank = port->ctrls[EMUX_MD_DEF_BANK];
 905         }
 906
 907         return snd_soundfont_search_zone(emu->sflist, notep, vel, preset, bank,
 908                                          def_preset, def_bank,
 909                                          table, SNDRV_EMUX_MAX_MULTI_VOICES);
 910 }
 911
 912 /*
 913  */
 914 void
 915 snd_emux_init_voices(struct snd_emux *emu)
 916 {
 917         struct snd_emux_voice *vp;
 918         int i;
 919         unsigned long flags;
 920
 921         spin_lock_irqsave(&emu->voice_lock, flags);
 922         for (i = 0; i < emu->max_voices; i++) {
 923                 vp = &emu->voices[i];
 924                 vp->ch = -1; /* not used */
 925                 vp->state = SNDRV_EMUX_ST_OFF;
 926                 vp->chan = NULL;
 927                 vp->port = NULL;
 928                 vp->time = 0;
 929                 vp->emu = emu;
 930                 vp->hw = emu->hw;
 931         }
 932         spin_unlock_irqrestore(&emu->voice_lock, flags);
 933 }
 934
 935 /*
 936  */
 937 void snd_emux_lock_voice(struct snd_emux *emu, int voice)
 938 {
 939         unsigned long flags;
 940
 941         spin_lock_irqsave(&emu->voice_lock, flags);
 942         if (emu->voices[voice].state == SNDRV_EMUX_ST_OFF)
 943                 emu->voices[voice].state = SNDRV_EMUX_ST_LOCKED;
 944         else
 945                 snd_printk(KERN_WARNING
 946                            "invalid voice for lock %d (state = %x)\n",
 947                            voice, emu->voices[voice].state);
 948         spin_unlock_irqrestore(&emu->voice_lock, flags);
 949 }
 950
 951 EXPORT_SYMBOL(snd_emux_lock_voice);
 952
 953 /*
 954  */
 955 void snd_emux_unlock_voice(struct snd_emux *emu, int voice)
 956 {
 957         unsigned long flags;
 958
 959         spin_lock_irqsave(&emu->voice_lock, flags);
 960         if (emu->voices[voice].state == SNDRV_EMUX_ST_LOCKED)
 961                 emu->voices[voice].state = SNDRV_EMUX_ST_OFF;
 962         else
 963                 snd_printk(KERN_WARNING
 964                            "invalid voice for unlock %d (state = %x)\n",
 965                            voice, emu->voices[voice].state);
 966         spin_unlock_irqrestore(&emu->voice_lock, flags);
 967 }
 968
 969 EXPORT_SYMBOL(snd_emux_unlock_voice);