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