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