sound/synth/emux/emux_synth.c

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