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