git.oblomov.eu Git - linux-2.6/blob - 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(snd_emux_t *emu, snd_emux_port_t *port, int *notep, int vel, snd_midi_channel_t *chan, snd_sf_zone_t **table);
  40 static int get_bank(snd_emux_port_t *port, snd_midi_channel_t *chan);
  41 static void terminate_note1(snd_emux_t *emu, int note, snd_midi_channel_t *chan, int free);
  42 static void exclusive_note_off(snd_emux_t *emu, snd_emux_port_t *port, int exclass);
  43 static void terminate_voice(snd_emux_t *emu, snd_emux_voice_t *vp, int free);
  44 static void update_voice(snd_emux_t *emu, snd_emux_voice_t *vp, int update);
  45 static void setup_voice(snd_emux_voice_t *vp);
  46 static int calc_pan(snd_emux_voice_t *vp);
  47 static int calc_volume(snd_emux_voice_t *vp);
  48 static int calc_pitch(snd_emux_voice_t *vp);
  49
  50
  51 /*
  52  * Start a note.
  53  */
  54 void
  55 snd_emux_note_on(void *p, int note, int vel, snd_midi_channel_t *chan)
  56 {
  57         snd_emux_t *emu;
  58         int i, key, nvoices;
  59         snd_emux_voice_t *vp;
  60         snd_sf_zone_t *table[SNDRV_EMUX_MAX_MULTI_VOICES];
  61         unsigned long flags;
  62         snd_emux_port_t *port;
  63
  64         port = p;
  65         snd_assert(port != NULL && chan != NULL, return);
  66
  67         emu = port->emu;
  68         snd_assert(emu != NULL, return);
  69         snd_assert(emu->ops.get_voice != NULL, return);
  70         snd_assert(emu->ops.trigger != NULL, return);
  71
  72         key = note; /* remember the original note */
  73         nvoices = get_zone(emu, port, &note, vel, chan, table);
  74         if (! nvoices)
  75                 return;
  76
  77         /* exclusive note off */
  78         for (i = 0; i < nvoices; i++) {
  79                 snd_sf_zone_t *zp = table[i];
  80                 if (zp && zp->v.exclusiveClass)
  81                         exclusive_note_off(emu, port, zp->v.exclusiveClass);
  82         }
  83
  84 #if 0 // seems not necessary
  85         /* Turn off the same note on the same channel. */
  86         terminate_note1(emu, key, chan, 0);
  87 #endif
  88
  89         spin_lock_irqsave(&emu->voice_lock, flags);
  90         for (i = 0; i < nvoices; i++) {
  91
  92                 /* set up each voice parameter */
  93                 /* at this stage, we don't trigger the voice yet. */
  94
  95                 if (table[i] == NULL)
  96                         continue;
  97
  98                 vp = emu->ops.get_voice(emu, port);
  99                 if (vp == NULL || vp->ch < 0)
 100                         continue;
 101                 if (STATE_IS_PLAYING(vp->state))
 102                         emu->ops.terminate(vp);
 103
 104                 vp->time = emu->use_time++;
 105                 vp->chan = chan;
 106                 vp->port = port;
 107                 vp->key = key;
 108                 vp->note = note;
 109                 vp->velocity = vel;
 110                 vp->zone = table[i];
 111                 if (vp->zone->sample)
 112                         vp->block = vp->zone->sample->block;
 113                 else
 114                         vp->block = NULL;
 115
 116                 setup_voice(vp);
 117
 118                 vp->state = SNDRV_EMUX_ST_STANDBY;
 119                 if (emu->ops.prepare) {
 120                         vp->state = SNDRV_EMUX_ST_OFF;
 121                         if (emu->ops.prepare(vp) >= 0)
 122                                 vp->state = SNDRV_EMUX_ST_STANDBY;
 123                 }
 124         }
 125
 126         /* start envelope now */
 127         for (i = 0; i < emu->max_voices; i++) {
 128                 vp = &emu->voices[i];
 129                 if (vp->state == SNDRV_EMUX_ST_STANDBY &&
 130                     vp->chan == chan) {
 131                         emu->ops.trigger(vp);
 132                         vp->state = SNDRV_EMUX_ST_ON;
 133                         vp->ontime = jiffies; /* remember the trigger timing */
 134                 }
 135         }
 136         spin_unlock_irqrestore(&emu->voice_lock, flags);
 137
 138 #ifdef SNDRV_EMUX_USE_RAW_EFFECT
 139         if (port->port_mode == SNDRV_EMUX_PORT_MODE_OSS_SYNTH) {
 140                 /* clear voice position for the next note on this channel */
 141                 snd_emux_effect_table_t *fx = chan->private;
 142                 if (fx) {
 143                         fx->flag[EMUX_FX_SAMPLE_START] = 0;
 144                         fx->flag[EMUX_FX_COARSE_SAMPLE_START] = 0;
 145                 }
 146         }
 147 #endif
 148 }
 149
 150 /*
 151  * Release a note in response to a midi note off.
 152  */
 153 void
 154 snd_emux_note_off(void *p, int note, int vel, snd_midi_channel_t *chan)
 155 {
 156         int ch;
 157         snd_emux_t *emu;
 158         snd_emux_voice_t *vp;
 159         unsigned long flags;
 160         snd_emux_port_t *port;
 161
 162         port = p;
 163         snd_assert(port != NULL && chan != NULL, return);
 164
 165         emu = port->emu;
 166         snd_assert(emu != NULL, return);
 167         snd_assert(emu->ops.release != NULL, return);
 168
 169         spin_lock_irqsave(&emu->voice_lock, flags);
 170         for (ch = 0; ch < emu->max_voices; ch++) {
 171                 vp = &emu->voices[ch];
 172                 if (STATE_IS_PLAYING(vp->state) &&
 173                     vp->chan == chan && vp->key == note) {
 174                         vp->state = SNDRV_EMUX_ST_RELEASED;
 175                         if (vp->ontime == jiffies) {
 176                                 /* if note-off is sent too shortly after
 177                                  * note-on, emuX engine cannot produce the sound
 178                                  * correctly.  so we'll release this note
 179                                  * a bit later via timer callback.
 180                                  */
 181                                 vp->state = SNDRV_EMUX_ST_PENDING;
 182                                 if (! emu->timer_active) {
 183                                         emu->tlist.expires = jiffies + 1;
 184                                         add_timer(&emu->tlist);
 185                                         emu->timer_active = 1;
 186                                 }
 187                         } else
 188                                 /* ok now release the note */
 189                                 emu->ops.release(vp);
 190                 }
 191         }
 192         spin_unlock_irqrestore(&emu->voice_lock, flags);
 193 }
 194
 195 /*
 196  * timer callback
 197  *
 198  * release the pending note-offs
 199  */
 200 void snd_emux_timer_callback(unsigned long data)
 201 {
 202         snd_emux_t *emu = (snd_emux_t*) data;
 203         snd_emux_voice_t *vp;
 204         int ch, do_again = 0;
 205
 206         spin_lock(&emu->voice_lock);
 207         for (ch = 0; ch < emu->max_voices; ch++) {
 208                 vp = &emu->voices[ch];
 209                 if (vp->state == SNDRV_EMUX_ST_PENDING) {
 210                         if (vp->ontime == jiffies)
 211                                 do_again++; /* release this at the next interrupt */
 212                         else {
 213                                 emu->ops.release(vp);
 214                                 vp->state = SNDRV_EMUX_ST_RELEASED;
 215                         }
 216                 }
 217         }
 218         if (do_again) {
 219                 emu->tlist.expires = jiffies + 1;
 220                 add_timer(&emu->tlist);
 221                 emu->timer_active = 1;
 222         } else
 223                 emu->timer_active = 0;
 224         spin_unlock(&emu->voice_lock);
 225 }
 226
 227 /*
 228  * key pressure change
 229  */
 230 void
 231 snd_emux_key_press(void *p, int note, int vel, snd_midi_channel_t *chan)
 232 {
 233         int ch;
 234         snd_emux_t *emu;
 235         snd_emux_voice_t *vp;
 236         unsigned long flags;
 237         snd_emux_port_t *port;
 238
 239         port = p;
 240         snd_assert(port != NULL && chan != NULL, return);
 241
 242         emu = port->emu;
 243         snd_assert(emu != NULL, return);
 244         snd_assert(emu->ops.update != NULL, return);
 245
 246         spin_lock_irqsave(&emu->voice_lock, flags);
 247         for (ch = 0; ch < emu->max_voices; ch++) {
 248                 vp = &emu->voices[ch];
 249                 if (vp->state == SNDRV_EMUX_ST_ON &&
 250                     vp->chan == chan && vp->key == note) {
 251                         vp->velocity = vel;
 252                         update_voice(emu, vp, SNDRV_EMUX_UPDATE_VOLUME);
 253                 }
 254         }
 255         spin_unlock_irqrestore(&emu->voice_lock, flags);
 256 }
 257
 258
 259 /*
 260  * Modulate the voices which belong to the channel
 261  */
 262 void
 263 snd_emux_update_channel(snd_emux_port_t *port, snd_midi_channel_t *chan, int update)
 264 {
 265         snd_emux_t *emu;
 266         snd_emux_voice_t *vp;
 267         int i;
 268         unsigned long flags;
 269
 270         if (! update)
 271                 return;
 272
 273         emu = port->emu;
 274         snd_assert(emu != NULL, return);
 275         snd_assert(emu->ops.update != NULL, return);
 276
 277         spin_lock_irqsave(&emu->voice_lock, flags);
 278         for (i = 0; i < emu->max_voices; i++) {
 279                 vp = &emu->voices[i];
 280                 if (vp->chan == chan)
 281                         update_voice(emu, vp, update);
 282         }
 283         spin_unlock_irqrestore(&emu->voice_lock, flags);
 284 }
 285
 286 /*
 287  * Modulate all the voices which belong to the port.
 288  */
 289 void
 290 snd_emux_update_port(snd_emux_port_t *port, int update)
 291 {
 292         snd_emux_t *emu;
 293         snd_emux_voice_t *vp;
 294         int i;
 295         unsigned long flags;
 296
 297         if (! update)
 298                 return;
 299
 300         emu = port->emu;
 301         snd_assert(emu != NULL, return);
 302         snd_assert(emu->ops.update != NULL, return);
 303
 304         spin_lock_irqsave(&emu->voice_lock, flags);
 305         for (i = 0; i < emu->max_voices; i++) {
 306                 vp = &emu->voices[i];
 307                 if (vp->port == port)
 308                         update_voice(emu, vp, update);
 309         }
 310         spin_unlock_irqrestore(&emu->voice_lock, flags);
 311 }
 312
 313
 314 /*
 315  * Deal with a controler type event.  This includes all types of
 316  * control events, not just the midi controllers
 317  */
 318 void
 319 snd_emux_control(void *p, int type, snd_midi_channel_t *chan)
 320 {
 321         snd_emux_port_t *port;
 322
 323         port = p;
 324         snd_assert(port != NULL && chan != NULL, return);
 325
 326         switch (type) {
 327         case MIDI_CTL_MSB_MAIN_VOLUME:
 328         case MIDI_CTL_MSB_EXPRESSION:
 329                 snd_emux_update_channel(port, chan, SNDRV_EMUX_UPDATE_VOLUME);
 330                 break;
 331
 332         case MIDI_CTL_MSB_PAN:
 333                 snd_emux_update_channel(port, chan, SNDRV_EMUX_UPDATE_PAN);
 334                 break;
 335
 336         case MIDI_CTL_SOFT_PEDAL:
 337 #ifdef SNDRV_EMUX_USE_RAW_EFFECT
 338                 /* FIXME: this is an emulation */
 339                 snd_emux_send_effect(port, chan, EMUX_FX_CUTOFF, -160,
 340                                      EMUX_FX_FLAG_ADD);
 341 #endif
 342                 break;
 343
 344         case MIDI_CTL_PITCHBEND:
 345                 snd_emux_update_channel(port, chan, SNDRV_EMUX_UPDATE_PITCH);
 346                 break;
 347
 348         case MIDI_CTL_MSB_MODWHEEL:
 349         case MIDI_CTL_CHAN_PRESSURE:
 350                 snd_emux_update_channel(port, chan,
 351                                         SNDRV_EMUX_UPDATE_FMMOD |
 352                                         SNDRV_EMUX_UPDATE_FM2FRQ2);
 353                 break;
 354
 355         }
 356
 357         if (port->chset.midi_mode == SNDRV_MIDI_MODE_XG) {
 358                 snd_emux_xg_control(port, chan, type);
 359         }
 360 }
 361
 362
 363 /*
 364  * terminate note - if free flag is true, free the terminated voice
 365  */
 366 static void
 367 terminate_note1(snd_emux_t *emu, int note, snd_midi_channel_t *chan, int free)
 368 {
 369         int  i;
 370         snd_emux_voice_t *vp;
 371         unsigned long flags;
 372
 373         spin_lock_irqsave(&emu->voice_lock, flags);
 374         for (i = 0; i < emu->max_voices; i++) {
 375                 vp = &emu->voices[i];
 376                 if (STATE_IS_PLAYING(vp->state) && vp->chan == chan &&
 377                     vp->key == note)
 378                         terminate_voice(emu, vp, free);
 379         }
 380         spin_unlock_irqrestore(&emu->voice_lock, flags);
 381 }
 382
 383
 384 /*
 385  * terminate note - exported for midi emulation
 386  */
 387 void
 388 snd_emux_terminate_note(void *p, int note, snd_midi_channel_t *chan)
 389 {
 390         snd_emux_t *emu;
 391         snd_emux_port_t *port;
 392
 393         port = p;
 394         snd_assert(port != NULL && chan != NULL, return);
 395
 396         emu = port->emu;
 397         snd_assert(emu != NULL, return);
 398         snd_assert(emu->ops.terminate != NULL, return);
 399
 400         terminate_note1(emu, note, chan, 1);
 401 }
 402
 403
 404 /*
 405  * Terminate all the notes
 406  */
 407 void
 408 snd_emux_terminate_all(snd_emux_t *emu)
 409 {
 410         int i;
 411         snd_emux_voice_t *vp;
 412         unsigned long flags;
 413
 414         spin_lock_irqsave(&emu->voice_lock, flags);
 415         for (i = 0; i < emu->max_voices; i++) {
 416                 vp = &emu->voices[i];
 417                 if (STATE_IS_PLAYING(vp->state))
 418                         terminate_voice(emu, vp, 0);
 419                 if (vp->state == SNDRV_EMUX_ST_OFF) {
 420                         if (emu->ops.free_voice)
 421                                 emu->ops.free_voice(vp);
 422                         if (emu->ops.reset)
 423                                 emu->ops.reset(emu, i);
 424                 }
 425                 vp->time = 0;
 426         }
 427         /* initialize allocation time */
 428         emu->use_time = 0;
 429         spin_unlock_irqrestore(&emu->voice_lock, flags);
 430 }
 431
 432
 433 /*
 434  * Terminate all voices associated with the given port
 435  */
 436 void
 437 snd_emux_sounds_off_all(snd_emux_port_t *port)
 438 {
 439         int i;
 440         snd_emux_t *emu;
 441         snd_emux_voice_t *vp;
 442         unsigned long flags;
 443
 444         snd_assert(port != NULL, return);
 445         emu = port->emu;
 446         snd_assert(emu != NULL, return);
 447         snd_assert(emu->ops.terminate != NULL, 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(snd_emux_t *emu, snd_emux_port_t *port, int exclass)
 472 {
 473         snd_emux_voice_t *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(snd_emux_t *emu, snd_emux_voice_t *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(snd_emux_t *emu, snd_emux_voice_t *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 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(snd_emux_voice_t *vp)
 547 {
 548         soundfont_voice_parm_t *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 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(snd_emux_voice_t *vp)
 640 {
 641         snd_midi_channel_t *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 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 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 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(snd_emux_voice_t *vp)
 741 {
 742         int vol;
 743         int main_vol, expression_vol, master_vol;
 744         snd_midi_channel_t *chan = vp->chan;
 745         snd_emux_port_t *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                 snd_emux_effect_table_t *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(snd_emux_voice_t *vp)
 812 {
 813         snd_midi_channel_t *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                 snd_emux_effect_table_t *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         offset += vp->emu->pitch_shift;
 849         LIMITVALUE(offset, 0, 0xffff);
 850         if (offset == vp->apitch)
 851                 return 0; /* unchanged */
 852         vp->apitch = offset;
 853         return 1; /* value changed */
 854 }
 855
 856 /*
 857  * Get the bank number assigned to the channel
 858  */
 859 static int
 860 get_bank(snd_emux_port_t *port, snd_midi_channel_t *chan)
 861 {
 862         int val;
 863
 864         switch (port->chset.midi_mode) {
 865         case SNDRV_MIDI_MODE_XG:
 866                 val = chan->control[MIDI_CTL_MSB_BANK];
 867                 if (val == 127)
 868                         return 128; /* return drum bank */
 869                 return chan->control[MIDI_CTL_LSB_BANK];
 870
 871         case SNDRV_MIDI_MODE_GS:
 872                 if (chan->drum_channel)
 873                         return 128;
 874                 /* ignore LSB (bank map) */
 875                 return chan->control[MIDI_CTL_MSB_BANK];
 876
 877         default:
 878                 if (chan->drum_channel)
 879                         return 128;
 880                 return chan->control[MIDI_CTL_MSB_BANK];
 881         }
 882 }
 883
 884
 885 /* Look for the zones matching with the given note and velocity.
 886  * The resultant zones are stored on table.
 887  */
 888 static int
 889 get_zone(snd_emux_t *emu, snd_emux_port_t *port,
 890          int *notep, int vel, snd_midi_channel_t *chan, snd_sf_zone_t **table)
 891 {
 892         int preset, bank, def_preset, def_bank;
 893
 894         bank = get_bank(port, chan);
 895         preset = chan->midi_program;
 896
 897         if (SF_IS_DRUM_BANK(bank)) {
 898                 def_preset = port->ctrls[EMUX_MD_DEF_DRUM];
 899                 def_bank = bank;
 900         } else {
 901                 def_preset = preset;
 902                 def_bank = port->ctrls[EMUX_MD_DEF_BANK];
 903         }
 904
 905         return snd_soundfont_search_zone(emu->sflist, notep, vel, preset, bank,
 906                                          def_preset, def_bank,
 907                                          table, SNDRV_EMUX_MAX_MULTI_VOICES);
 908 }
 909
 910 /*
 911  */
 912 void
 913 snd_emux_init_voices(snd_emux_t *emu)
 914 {
 915         snd_emux_voice_t *vp;
 916         int i;
 917         unsigned long flags;
 918
 919         spin_lock_irqsave(&emu->voice_lock, flags);
 920         for (i = 0; i < emu->max_voices; i++) {
 921                 vp = &emu->voices[i];
 922                 vp->ch = -1; /* not used */
 923                 vp->state = SNDRV_EMUX_ST_OFF;
 924                 vp->chan = NULL;
 925                 vp->port = NULL;
 926                 vp->time = 0;
 927                 vp->emu = emu;
 928                 vp->hw = emu->hw;
 929         }
 930         spin_unlock_irqrestore(&emu->voice_lock, flags);
 931 }
 932
 933 /*
 934  */
 935 void snd_emux_lock_voice(snd_emux_t *emu, int voice)
 936 {
 937         unsigned long flags;
 938
 939         spin_lock_irqsave(&emu->voice_lock, flags);
 940         if (emu->voices[voice].state == SNDRV_EMUX_ST_OFF)
 941                 emu->voices[voice].state = SNDRV_EMUX_ST_LOCKED;
 942         else
 943                 snd_printk("invalid voice for lock %d (state = %x)\n",
 944                            voice, emu->voices[voice].state);
 945         spin_unlock_irqrestore(&emu->voice_lock, flags);
 946 }
 947
 948 /*
 949  */
 950 void snd_emux_unlock_voice(snd_emux_t *emu, int voice)
 951 {
 952         unsigned long flags;
 953
 954         spin_lock_irqsave(&emu->voice_lock, flags);
 955         if (emu->voices[voice].state == SNDRV_EMUX_ST_LOCKED)
 956                 emu->voices[voice].state = SNDRV_EMUX_ST_OFF;
 957         else
 958                 snd_printk("invalid voice for unlock %d (state = %x)\n",
 959                            voice, emu->voices[voice].state);
 960         spin_unlock_irqrestore(&emu->voice_lock, flags);
 961 }