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