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