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, ¬e, 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); 985