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