11da177e4SLinus Torvalds /* 21da177e4SLinus Torvalds * Midi synth routines for the Emu8k/Emu10k1 31da177e4SLinus Torvalds * 41da177e4SLinus Torvalds * Copyright (C) 1999 Steve Ratcliffe 51da177e4SLinus Torvalds * Copyright (c) 1999-2000 Takashi Iwai <tiwai@suse.de> 61da177e4SLinus Torvalds * 71da177e4SLinus Torvalds * Contains code based on awe_wave.c by Takashi Iwai 81da177e4SLinus Torvalds * 91da177e4SLinus Torvalds * This program is free software; you can redistribute it and/or modify 101da177e4SLinus Torvalds * it under the terms of the GNU General Public License as published by 111da177e4SLinus Torvalds * the Free Software Foundation; either version 2 of the License, or 121da177e4SLinus Torvalds * (at your option) any later version. 131da177e4SLinus Torvalds * 141da177e4SLinus Torvalds * This program is distributed in the hope that it will be useful, 151da177e4SLinus Torvalds * but WITHOUT ANY WARRANTY; without even the implied warranty of 161da177e4SLinus Torvalds * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 171da177e4SLinus Torvalds * GNU General Public License for more details. 181da177e4SLinus Torvalds * 191da177e4SLinus Torvalds * You should have received a copy of the GNU General Public License 201da177e4SLinus Torvalds * along with this program; if not, write to the Free Software 211da177e4SLinus Torvalds * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 221da177e4SLinus Torvalds * 231da177e4SLinus Torvalds */ 241da177e4SLinus Torvalds 25d81a6d71SPaul Gortmaker #include <linux/export.h> 261da177e4SLinus Torvalds #include "emux_voice.h" 271da177e4SLinus Torvalds #include <sound/asoundef.h> 281da177e4SLinus Torvalds 291da177e4SLinus Torvalds /* 301da177e4SLinus Torvalds * Prototypes 311da177e4SLinus Torvalds */ 321da177e4SLinus Torvalds 331da177e4SLinus Torvalds /* 341da177e4SLinus Torvalds * Ensure a value is between two points 351da177e4SLinus Torvalds * macro evaluates its args more than once, so changed to upper-case. 361da177e4SLinus Torvalds */ 371da177e4SLinus Torvalds #define LIMITVALUE(x, a, b) do { if ((x) < (a)) (x) = (a); else if ((x) > (b)) (x) = (b); } while (0) 381da177e4SLinus Torvalds #define LIMITMAX(x, a) do {if ((x) > (a)) (x) = (a); } while (0) 391da177e4SLinus Torvalds 4003da312aSTakashi Iwai static int get_zone(struct snd_emux *emu, struct snd_emux_port *port, 4103da312aSTakashi Iwai int *notep, int vel, struct snd_midi_channel *chan, 4203da312aSTakashi Iwai struct snd_sf_zone **table); 4303da312aSTakashi Iwai static int get_bank(struct snd_emux_port *port, struct snd_midi_channel *chan); 4403da312aSTakashi Iwai static void terminate_note1(struct snd_emux *emu, int note, 4503da312aSTakashi Iwai struct snd_midi_channel *chan, int free); 4603da312aSTakashi Iwai static void exclusive_note_off(struct snd_emux *emu, struct snd_emux_port *port, 4703da312aSTakashi Iwai int exclass); 4803da312aSTakashi Iwai static void terminate_voice(struct snd_emux *emu, struct snd_emux_voice *vp, int free); 4903da312aSTakashi Iwai static void update_voice(struct snd_emux *emu, struct snd_emux_voice *vp, int update); 5003da312aSTakashi Iwai static void setup_voice(struct snd_emux_voice *vp); 5103da312aSTakashi Iwai static int calc_pan(struct snd_emux_voice *vp); 5203da312aSTakashi Iwai static int calc_volume(struct snd_emux_voice *vp); 5303da312aSTakashi Iwai static int calc_pitch(struct snd_emux_voice *vp); 541da177e4SLinus Torvalds 551da177e4SLinus Torvalds 561da177e4SLinus Torvalds /* 571da177e4SLinus Torvalds * Start a note. 581da177e4SLinus Torvalds */ 591da177e4SLinus Torvalds void 6003da312aSTakashi Iwai snd_emux_note_on(void *p, int note, int vel, struct snd_midi_channel *chan) 611da177e4SLinus Torvalds { 6203da312aSTakashi Iwai struct snd_emux *emu; 631da177e4SLinus Torvalds int i, key, nvoices; 6403da312aSTakashi Iwai struct snd_emux_voice *vp; 6503da312aSTakashi Iwai struct snd_sf_zone *table[SNDRV_EMUX_MAX_MULTI_VOICES]; 661da177e4SLinus Torvalds unsigned long flags; 6703da312aSTakashi Iwai struct snd_emux_port *port; 681da177e4SLinus Torvalds 691da177e4SLinus Torvalds port = p; 705e246b85STakashi Iwai if (snd_BUG_ON(!port || !chan)) 715e246b85STakashi Iwai return; 721da177e4SLinus Torvalds 731da177e4SLinus Torvalds emu = port->emu; 745e246b85STakashi Iwai if (snd_BUG_ON(!emu || !emu->ops.get_voice || !emu->ops.trigger)) 755e246b85STakashi Iwai return; 761da177e4SLinus Torvalds 771da177e4SLinus Torvalds key = note; /* remember the original note */ 781da177e4SLinus Torvalds nvoices = get_zone(emu, port, ¬e, vel, chan, table); 791da177e4SLinus Torvalds if (! nvoices) 801da177e4SLinus Torvalds return; 811da177e4SLinus Torvalds 821da177e4SLinus Torvalds /* exclusive note off */ 831da177e4SLinus Torvalds for (i = 0; i < nvoices; i++) { 8403da312aSTakashi Iwai struct snd_sf_zone *zp = table[i]; 851da177e4SLinus Torvalds if (zp && zp->v.exclusiveClass) 861da177e4SLinus Torvalds exclusive_note_off(emu, port, zp->v.exclusiveClass); 871da177e4SLinus Torvalds } 881da177e4SLinus Torvalds 891da177e4SLinus Torvalds #if 0 // seems not necessary 901da177e4SLinus Torvalds /* Turn off the same note on the same channel. */ 911da177e4SLinus Torvalds terminate_note1(emu, key, chan, 0); 921da177e4SLinus Torvalds #endif 931da177e4SLinus Torvalds 941da177e4SLinus Torvalds spin_lock_irqsave(&emu->voice_lock, flags); 951da177e4SLinus Torvalds for (i = 0; i < nvoices; i++) { 961da177e4SLinus Torvalds 971da177e4SLinus Torvalds /* set up each voice parameter */ 981da177e4SLinus Torvalds /* at this stage, we don't trigger the voice yet. */ 991da177e4SLinus Torvalds 1001da177e4SLinus Torvalds if (table[i] == NULL) 1011da177e4SLinus Torvalds continue; 1021da177e4SLinus Torvalds 1031da177e4SLinus Torvalds vp = emu->ops.get_voice(emu, port); 1041da177e4SLinus Torvalds if (vp == NULL || vp->ch < 0) 1051da177e4SLinus Torvalds continue; 1061da177e4SLinus Torvalds if (STATE_IS_PLAYING(vp->state)) 1071da177e4SLinus Torvalds emu->ops.terminate(vp); 1081da177e4SLinus Torvalds 1091da177e4SLinus Torvalds vp->time = emu->use_time++; 1101da177e4SLinus Torvalds vp->chan = chan; 1111da177e4SLinus Torvalds vp->port = port; 1121da177e4SLinus Torvalds vp->key = key; 1131da177e4SLinus Torvalds vp->note = note; 1141da177e4SLinus Torvalds vp->velocity = vel; 1151da177e4SLinus Torvalds vp->zone = table[i]; 1161da177e4SLinus Torvalds if (vp->zone->sample) 1171da177e4SLinus Torvalds vp->block = vp->zone->sample->block; 1181da177e4SLinus Torvalds else 1191da177e4SLinus Torvalds vp->block = NULL; 1201da177e4SLinus Torvalds 1211da177e4SLinus Torvalds setup_voice(vp); 1221da177e4SLinus Torvalds 1231da177e4SLinus Torvalds vp->state = SNDRV_EMUX_ST_STANDBY; 1241da177e4SLinus Torvalds if (emu->ops.prepare) { 1251da177e4SLinus Torvalds vp->state = SNDRV_EMUX_ST_OFF; 1261da177e4SLinus Torvalds if (emu->ops.prepare(vp) >= 0) 1271da177e4SLinus Torvalds vp->state = SNDRV_EMUX_ST_STANDBY; 1281da177e4SLinus Torvalds } 1291da177e4SLinus Torvalds } 1301da177e4SLinus Torvalds 1311da177e4SLinus Torvalds /* start envelope now */ 1321da177e4SLinus Torvalds for (i = 0; i < emu->max_voices; i++) { 1331da177e4SLinus Torvalds vp = &emu->voices[i]; 1341da177e4SLinus Torvalds if (vp->state == SNDRV_EMUX_ST_STANDBY && 1351da177e4SLinus Torvalds vp->chan == chan) { 1361da177e4SLinus Torvalds emu->ops.trigger(vp); 1371da177e4SLinus Torvalds vp->state = SNDRV_EMUX_ST_ON; 1381da177e4SLinus Torvalds vp->ontime = jiffies; /* remember the trigger timing */ 1391da177e4SLinus Torvalds } 1401da177e4SLinus Torvalds } 1411da177e4SLinus Torvalds spin_unlock_irqrestore(&emu->voice_lock, flags); 1421da177e4SLinus Torvalds 1431da177e4SLinus Torvalds #ifdef SNDRV_EMUX_USE_RAW_EFFECT 1441da177e4SLinus Torvalds if (port->port_mode == SNDRV_EMUX_PORT_MODE_OSS_SYNTH) { 1451da177e4SLinus Torvalds /* clear voice position for the next note on this channel */ 14603da312aSTakashi Iwai struct snd_emux_effect_table *fx = chan->private; 1471da177e4SLinus Torvalds if (fx) { 1481da177e4SLinus Torvalds fx->flag[EMUX_FX_SAMPLE_START] = 0; 1491da177e4SLinus Torvalds fx->flag[EMUX_FX_COARSE_SAMPLE_START] = 0; 1501da177e4SLinus Torvalds } 1511da177e4SLinus Torvalds } 1521da177e4SLinus Torvalds #endif 1531da177e4SLinus Torvalds } 1541da177e4SLinus Torvalds 1551da177e4SLinus Torvalds /* 1561da177e4SLinus Torvalds * Release a note in response to a midi note off. 1571da177e4SLinus Torvalds */ 1581da177e4SLinus Torvalds void 15903da312aSTakashi Iwai snd_emux_note_off(void *p, int note, int vel, struct snd_midi_channel *chan) 1601da177e4SLinus Torvalds { 1611da177e4SLinus Torvalds int ch; 16203da312aSTakashi Iwai struct snd_emux *emu; 16303da312aSTakashi Iwai struct snd_emux_voice *vp; 1641da177e4SLinus Torvalds unsigned long flags; 16503da312aSTakashi Iwai struct snd_emux_port *port; 1661da177e4SLinus Torvalds 1671da177e4SLinus Torvalds port = p; 1685e246b85STakashi Iwai if (snd_BUG_ON(!port || !chan)) 1695e246b85STakashi Iwai return; 1701da177e4SLinus Torvalds 1711da177e4SLinus Torvalds emu = port->emu; 1725e246b85STakashi Iwai if (snd_BUG_ON(!emu || !emu->ops.release)) 1735e246b85STakashi Iwai return; 1741da177e4SLinus Torvalds 1751da177e4SLinus Torvalds spin_lock_irqsave(&emu->voice_lock, flags); 1761da177e4SLinus Torvalds for (ch = 0; ch < emu->max_voices; ch++) { 1771da177e4SLinus Torvalds vp = &emu->voices[ch]; 1781da177e4SLinus Torvalds if (STATE_IS_PLAYING(vp->state) && 1791da177e4SLinus Torvalds vp->chan == chan && vp->key == note) { 1801da177e4SLinus Torvalds vp->state = SNDRV_EMUX_ST_RELEASED; 1811da177e4SLinus Torvalds if (vp->ontime == jiffies) { 1821da177e4SLinus Torvalds /* if note-off is sent too shortly after 1831da177e4SLinus Torvalds * note-on, emuX engine cannot produce the sound 1841da177e4SLinus Torvalds * correctly. so we'll release this note 1851da177e4SLinus Torvalds * a bit later via timer callback. 1861da177e4SLinus Torvalds */ 1871da177e4SLinus Torvalds vp->state = SNDRV_EMUX_ST_PENDING; 1881da177e4SLinus Torvalds if (! emu->timer_active) { 189abd08352STakashi Iwai mod_timer(&emu->tlist, jiffies + 1); 1901da177e4SLinus Torvalds emu->timer_active = 1; 1911da177e4SLinus Torvalds } 1921da177e4SLinus Torvalds } else 1931da177e4SLinus Torvalds /* ok now release the note */ 1941da177e4SLinus Torvalds emu->ops.release(vp); 1951da177e4SLinus Torvalds } 1961da177e4SLinus Torvalds } 1971da177e4SLinus Torvalds spin_unlock_irqrestore(&emu->voice_lock, flags); 1981da177e4SLinus Torvalds } 1991da177e4SLinus Torvalds 2001da177e4SLinus Torvalds /* 2011da177e4SLinus Torvalds * timer callback 2021da177e4SLinus Torvalds * 2031da177e4SLinus Torvalds * release the pending note-offs 2041da177e4SLinus Torvalds */ 2051da177e4SLinus Torvalds void snd_emux_timer_callback(unsigned long data) 2061da177e4SLinus Torvalds { 20703da312aSTakashi Iwai struct snd_emux *emu = (struct snd_emux *) data; 20803da312aSTakashi Iwai struct snd_emux_voice *vp; 209b32425acSTakashi Iwai unsigned long flags; 2101da177e4SLinus Torvalds int ch, do_again = 0; 2111da177e4SLinus Torvalds 212b32425acSTakashi Iwai spin_lock_irqsave(&emu->voice_lock, flags); 2131da177e4SLinus Torvalds for (ch = 0; ch < emu->max_voices; ch++) { 2141da177e4SLinus Torvalds vp = &emu->voices[ch]; 2151da177e4SLinus Torvalds if (vp->state == SNDRV_EMUX_ST_PENDING) { 2161da177e4SLinus Torvalds if (vp->ontime == jiffies) 2171da177e4SLinus Torvalds do_again++; /* release this at the next interrupt */ 2181da177e4SLinus Torvalds else { 2191da177e4SLinus Torvalds emu->ops.release(vp); 2201da177e4SLinus Torvalds vp->state = SNDRV_EMUX_ST_RELEASED; 2211da177e4SLinus Torvalds } 2221da177e4SLinus Torvalds } 2231da177e4SLinus Torvalds } 2241da177e4SLinus Torvalds if (do_again) { 225abd08352STakashi Iwai mod_timer(&emu->tlist, jiffies + 1); 2261da177e4SLinus Torvalds emu->timer_active = 1; 2271da177e4SLinus Torvalds } else 2281da177e4SLinus Torvalds emu->timer_active = 0; 229b32425acSTakashi Iwai spin_unlock_irqrestore(&emu->voice_lock, flags); 2301da177e4SLinus Torvalds } 2311da177e4SLinus Torvalds 2321da177e4SLinus Torvalds /* 2331da177e4SLinus Torvalds * key pressure change 2341da177e4SLinus Torvalds */ 2351da177e4SLinus Torvalds void 23603da312aSTakashi Iwai snd_emux_key_press(void *p, int note, int vel, struct snd_midi_channel *chan) 2371da177e4SLinus Torvalds { 2381da177e4SLinus Torvalds int ch; 23903da312aSTakashi Iwai struct snd_emux *emu; 24003da312aSTakashi Iwai struct snd_emux_voice *vp; 2411da177e4SLinus Torvalds unsigned long flags; 24203da312aSTakashi Iwai struct snd_emux_port *port; 2431da177e4SLinus Torvalds 2441da177e4SLinus Torvalds port = p; 2455e246b85STakashi Iwai if (snd_BUG_ON(!port || !chan)) 2465e246b85STakashi Iwai return; 2471da177e4SLinus Torvalds 2481da177e4SLinus Torvalds emu = port->emu; 2495e246b85STakashi Iwai if (snd_BUG_ON(!emu || !emu->ops.update)) 2505e246b85STakashi Iwai return; 2511da177e4SLinus Torvalds 2521da177e4SLinus Torvalds spin_lock_irqsave(&emu->voice_lock, flags); 2531da177e4SLinus Torvalds for (ch = 0; ch < emu->max_voices; ch++) { 2541da177e4SLinus Torvalds vp = &emu->voices[ch]; 2551da177e4SLinus Torvalds if (vp->state == SNDRV_EMUX_ST_ON && 2561da177e4SLinus Torvalds vp->chan == chan && vp->key == note) { 2571da177e4SLinus Torvalds vp->velocity = vel; 2581da177e4SLinus Torvalds update_voice(emu, vp, SNDRV_EMUX_UPDATE_VOLUME); 2591da177e4SLinus Torvalds } 2601da177e4SLinus Torvalds } 2611da177e4SLinus Torvalds spin_unlock_irqrestore(&emu->voice_lock, flags); 2621da177e4SLinus Torvalds } 2631da177e4SLinus Torvalds 2641da177e4SLinus Torvalds 2651da177e4SLinus Torvalds /* 2661da177e4SLinus Torvalds * Modulate the voices which belong to the channel 2671da177e4SLinus Torvalds */ 2681da177e4SLinus Torvalds void 26903da312aSTakashi Iwai snd_emux_update_channel(struct snd_emux_port *port, struct snd_midi_channel *chan, int update) 2701da177e4SLinus Torvalds { 27103da312aSTakashi Iwai struct snd_emux *emu; 27203da312aSTakashi Iwai struct snd_emux_voice *vp; 2731da177e4SLinus Torvalds int i; 2741da177e4SLinus Torvalds unsigned long flags; 2751da177e4SLinus Torvalds 2761da177e4SLinus Torvalds if (! update) 2771da177e4SLinus Torvalds return; 2781da177e4SLinus Torvalds 2791da177e4SLinus Torvalds emu = port->emu; 2805e246b85STakashi Iwai if (snd_BUG_ON(!emu || !emu->ops.update)) 2815e246b85STakashi Iwai return; 2821da177e4SLinus Torvalds 2831da177e4SLinus Torvalds spin_lock_irqsave(&emu->voice_lock, flags); 2841da177e4SLinus Torvalds for (i = 0; i < emu->max_voices; i++) { 2851da177e4SLinus Torvalds vp = &emu->voices[i]; 2861da177e4SLinus Torvalds if (vp->chan == chan) 2871da177e4SLinus Torvalds update_voice(emu, vp, update); 2881da177e4SLinus Torvalds } 2891da177e4SLinus Torvalds spin_unlock_irqrestore(&emu->voice_lock, flags); 2901da177e4SLinus Torvalds } 2911da177e4SLinus Torvalds 2921da177e4SLinus Torvalds /* 2931da177e4SLinus Torvalds * Modulate all the voices which belong to the port. 2941da177e4SLinus Torvalds */ 2951da177e4SLinus Torvalds void 29603da312aSTakashi Iwai snd_emux_update_port(struct snd_emux_port *port, int update) 2971da177e4SLinus Torvalds { 29803da312aSTakashi Iwai struct snd_emux *emu; 29903da312aSTakashi Iwai struct snd_emux_voice *vp; 3001da177e4SLinus Torvalds int i; 3011da177e4SLinus Torvalds unsigned long flags; 3021da177e4SLinus Torvalds 3031da177e4SLinus Torvalds if (! update) 3041da177e4SLinus Torvalds return; 3051da177e4SLinus Torvalds 3061da177e4SLinus Torvalds emu = port->emu; 3075e246b85STakashi Iwai if (snd_BUG_ON(!emu || !emu->ops.update)) 3085e246b85STakashi Iwai return; 3091da177e4SLinus Torvalds 3101da177e4SLinus Torvalds spin_lock_irqsave(&emu->voice_lock, flags); 3111da177e4SLinus Torvalds for (i = 0; i < emu->max_voices; i++) { 3121da177e4SLinus Torvalds vp = &emu->voices[i]; 3131da177e4SLinus Torvalds if (vp->port == port) 3141da177e4SLinus Torvalds update_voice(emu, vp, update); 3151da177e4SLinus Torvalds } 3161da177e4SLinus Torvalds spin_unlock_irqrestore(&emu->voice_lock, flags); 3171da177e4SLinus Torvalds } 3181da177e4SLinus Torvalds 3191da177e4SLinus Torvalds 3201da177e4SLinus Torvalds /* 3213a4fa0a2SRobert P. J. Day * Deal with a controller type event. This includes all types of 3221da177e4SLinus Torvalds * control events, not just the midi controllers 3231da177e4SLinus Torvalds */ 3241da177e4SLinus Torvalds void 32503da312aSTakashi Iwai snd_emux_control(void *p, int type, struct snd_midi_channel *chan) 3261da177e4SLinus Torvalds { 32703da312aSTakashi Iwai struct snd_emux_port *port; 3281da177e4SLinus Torvalds 3291da177e4SLinus Torvalds port = p; 3305e246b85STakashi Iwai if (snd_BUG_ON(!port || !chan)) 3315e246b85STakashi Iwai return; 3321da177e4SLinus Torvalds 3331da177e4SLinus Torvalds switch (type) { 3341da177e4SLinus Torvalds case MIDI_CTL_MSB_MAIN_VOLUME: 3351da177e4SLinus Torvalds case MIDI_CTL_MSB_EXPRESSION: 3361da177e4SLinus Torvalds snd_emux_update_channel(port, chan, SNDRV_EMUX_UPDATE_VOLUME); 3371da177e4SLinus Torvalds break; 3381da177e4SLinus Torvalds 3391da177e4SLinus Torvalds case MIDI_CTL_MSB_PAN: 3401da177e4SLinus Torvalds snd_emux_update_channel(port, chan, SNDRV_EMUX_UPDATE_PAN); 3411da177e4SLinus Torvalds break; 3421da177e4SLinus Torvalds 3431da177e4SLinus Torvalds case MIDI_CTL_SOFT_PEDAL: 3441da177e4SLinus Torvalds #ifdef SNDRV_EMUX_USE_RAW_EFFECT 3451da177e4SLinus Torvalds /* FIXME: this is an emulation */ 346bf91141dSmaximilian attems if (chan->control[type] >= 64) 3471da177e4SLinus Torvalds snd_emux_send_effect(port, chan, EMUX_FX_CUTOFF, -160, 3481da177e4SLinus Torvalds EMUX_FX_FLAG_ADD); 349bf91141dSmaximilian attems else 350bf91141dSmaximilian attems snd_emux_send_effect(port, chan, EMUX_FX_CUTOFF, 0, 351bf91141dSmaximilian attems EMUX_FX_FLAG_OFF); 3521da177e4SLinus Torvalds #endif 3531da177e4SLinus Torvalds break; 3541da177e4SLinus Torvalds 3551da177e4SLinus Torvalds case MIDI_CTL_PITCHBEND: 3561da177e4SLinus Torvalds snd_emux_update_channel(port, chan, SNDRV_EMUX_UPDATE_PITCH); 3571da177e4SLinus Torvalds break; 3581da177e4SLinus Torvalds 3591da177e4SLinus Torvalds case MIDI_CTL_MSB_MODWHEEL: 3601da177e4SLinus Torvalds case MIDI_CTL_CHAN_PRESSURE: 3611da177e4SLinus Torvalds snd_emux_update_channel(port, chan, 3621da177e4SLinus Torvalds SNDRV_EMUX_UPDATE_FMMOD | 3631da177e4SLinus Torvalds SNDRV_EMUX_UPDATE_FM2FRQ2); 3641da177e4SLinus Torvalds break; 3651da177e4SLinus Torvalds 3661da177e4SLinus Torvalds } 3671da177e4SLinus Torvalds 3681da177e4SLinus Torvalds if (port->chset.midi_mode == SNDRV_MIDI_MODE_XG) { 3691da177e4SLinus Torvalds snd_emux_xg_control(port, chan, type); 3701da177e4SLinus Torvalds } 3711da177e4SLinus Torvalds } 3721da177e4SLinus Torvalds 3731da177e4SLinus Torvalds 3741da177e4SLinus Torvalds /* 3751da177e4SLinus Torvalds * terminate note - if free flag is true, free the terminated voice 3761da177e4SLinus Torvalds */ 3771da177e4SLinus Torvalds static void 37803da312aSTakashi Iwai terminate_note1(struct snd_emux *emu, int note, struct snd_midi_channel *chan, int free) 3791da177e4SLinus Torvalds { 3801da177e4SLinus Torvalds int i; 38103da312aSTakashi Iwai struct snd_emux_voice *vp; 3821da177e4SLinus Torvalds unsigned long flags; 3831da177e4SLinus Torvalds 3841da177e4SLinus Torvalds spin_lock_irqsave(&emu->voice_lock, flags); 3851da177e4SLinus Torvalds for (i = 0; i < emu->max_voices; i++) { 3861da177e4SLinus Torvalds vp = &emu->voices[i]; 3871da177e4SLinus Torvalds if (STATE_IS_PLAYING(vp->state) && vp->chan == chan && 3881da177e4SLinus Torvalds vp->key == note) 3891da177e4SLinus Torvalds terminate_voice(emu, vp, free); 3901da177e4SLinus Torvalds } 3911da177e4SLinus Torvalds spin_unlock_irqrestore(&emu->voice_lock, flags); 3921da177e4SLinus Torvalds } 3931da177e4SLinus Torvalds 3941da177e4SLinus Torvalds 3951da177e4SLinus Torvalds /* 3961da177e4SLinus Torvalds * terminate note - exported for midi emulation 3971da177e4SLinus Torvalds */ 3981da177e4SLinus Torvalds void 39903da312aSTakashi Iwai snd_emux_terminate_note(void *p, int note, struct snd_midi_channel *chan) 4001da177e4SLinus Torvalds { 40103da312aSTakashi Iwai struct snd_emux *emu; 40203da312aSTakashi Iwai struct snd_emux_port *port; 4031da177e4SLinus Torvalds 4041da177e4SLinus Torvalds port = p; 4055e246b85STakashi Iwai if (snd_BUG_ON(!port || !chan)) 4065e246b85STakashi Iwai return; 4071da177e4SLinus Torvalds 4081da177e4SLinus Torvalds emu = port->emu; 4095e246b85STakashi Iwai if (snd_BUG_ON(!emu || !emu->ops.terminate)) 4105e246b85STakashi Iwai return; 4111da177e4SLinus Torvalds 4121da177e4SLinus Torvalds terminate_note1(emu, note, chan, 1); 4131da177e4SLinus Torvalds } 4141da177e4SLinus Torvalds 4151da177e4SLinus Torvalds 4161da177e4SLinus Torvalds /* 4171da177e4SLinus Torvalds * Terminate all the notes 4181da177e4SLinus Torvalds */ 4191da177e4SLinus Torvalds void 42003da312aSTakashi Iwai snd_emux_terminate_all(struct snd_emux *emu) 4211da177e4SLinus Torvalds { 4221da177e4SLinus Torvalds int i; 42303da312aSTakashi Iwai struct snd_emux_voice *vp; 4241da177e4SLinus Torvalds unsigned long flags; 4251da177e4SLinus Torvalds 4261da177e4SLinus Torvalds spin_lock_irqsave(&emu->voice_lock, flags); 4271da177e4SLinus Torvalds for (i = 0; i < emu->max_voices; i++) { 4281da177e4SLinus Torvalds vp = &emu->voices[i]; 4291da177e4SLinus Torvalds if (STATE_IS_PLAYING(vp->state)) 4301da177e4SLinus Torvalds terminate_voice(emu, vp, 0); 4311da177e4SLinus Torvalds if (vp->state == SNDRV_EMUX_ST_OFF) { 4321da177e4SLinus Torvalds if (emu->ops.free_voice) 4331da177e4SLinus Torvalds emu->ops.free_voice(vp); 4341da177e4SLinus Torvalds if (emu->ops.reset) 4351da177e4SLinus Torvalds emu->ops.reset(emu, i); 4361da177e4SLinus Torvalds } 4371da177e4SLinus Torvalds vp->time = 0; 4381da177e4SLinus Torvalds } 4391da177e4SLinus Torvalds /* initialize allocation time */ 4401da177e4SLinus Torvalds emu->use_time = 0; 4411da177e4SLinus Torvalds spin_unlock_irqrestore(&emu->voice_lock, flags); 4421da177e4SLinus Torvalds } 4431da177e4SLinus Torvalds 44495ff1756STakashi Iwai EXPORT_SYMBOL(snd_emux_terminate_all); 4451da177e4SLinus Torvalds 4461da177e4SLinus Torvalds /* 4471da177e4SLinus Torvalds * Terminate all voices associated with the given port 4481da177e4SLinus Torvalds */ 4491da177e4SLinus Torvalds void 45003da312aSTakashi Iwai snd_emux_sounds_off_all(struct snd_emux_port *port) 4511da177e4SLinus Torvalds { 4521da177e4SLinus Torvalds int i; 45303da312aSTakashi Iwai struct snd_emux *emu; 45403da312aSTakashi Iwai struct snd_emux_voice *vp; 4551da177e4SLinus Torvalds unsigned long flags; 4561da177e4SLinus Torvalds 4575e246b85STakashi Iwai if (snd_BUG_ON(!port)) 4585e246b85STakashi Iwai return; 4591da177e4SLinus Torvalds emu = port->emu; 4605e246b85STakashi Iwai if (snd_BUG_ON(!emu || !emu->ops.terminate)) 4615e246b85STakashi Iwai return; 4621da177e4SLinus Torvalds 4631da177e4SLinus Torvalds spin_lock_irqsave(&emu->voice_lock, flags); 4641da177e4SLinus Torvalds for (i = 0; i < emu->max_voices; i++) { 4651da177e4SLinus Torvalds vp = &emu->voices[i]; 4661da177e4SLinus Torvalds if (STATE_IS_PLAYING(vp->state) && 4671da177e4SLinus Torvalds vp->port == port) 4681da177e4SLinus Torvalds terminate_voice(emu, vp, 0); 4691da177e4SLinus Torvalds if (vp->state == SNDRV_EMUX_ST_OFF) { 4701da177e4SLinus Torvalds if (emu->ops.free_voice) 4711da177e4SLinus Torvalds emu->ops.free_voice(vp); 4721da177e4SLinus Torvalds if (emu->ops.reset) 4731da177e4SLinus Torvalds emu->ops.reset(emu, i); 4741da177e4SLinus Torvalds } 4751da177e4SLinus Torvalds } 4761da177e4SLinus Torvalds spin_unlock_irqrestore(&emu->voice_lock, flags); 4771da177e4SLinus Torvalds } 4781da177e4SLinus Torvalds 4791da177e4SLinus Torvalds 4801da177e4SLinus Torvalds /* 4811da177e4SLinus Torvalds * Terminate all voices that have the same exclusive class. This 4821da177e4SLinus Torvalds * is mainly for drums. 4831da177e4SLinus Torvalds */ 4841da177e4SLinus Torvalds static void 48503da312aSTakashi Iwai exclusive_note_off(struct snd_emux *emu, struct snd_emux_port *port, int exclass) 4861da177e4SLinus Torvalds { 48703da312aSTakashi Iwai struct snd_emux_voice *vp; 4881da177e4SLinus Torvalds int i; 4891da177e4SLinus Torvalds unsigned long flags; 4901da177e4SLinus Torvalds 4911da177e4SLinus Torvalds spin_lock_irqsave(&emu->voice_lock, flags); 4921da177e4SLinus Torvalds for (i = 0; i < emu->max_voices; i++) { 4931da177e4SLinus Torvalds vp = &emu->voices[i]; 4941da177e4SLinus Torvalds if (STATE_IS_PLAYING(vp->state) && vp->port == port && 4951da177e4SLinus Torvalds vp->reg.exclusiveClass == exclass) { 4961da177e4SLinus Torvalds terminate_voice(emu, vp, 0); 4971da177e4SLinus Torvalds } 4981da177e4SLinus Torvalds } 4991da177e4SLinus Torvalds spin_unlock_irqrestore(&emu->voice_lock, flags); 5001da177e4SLinus Torvalds } 5011da177e4SLinus Torvalds 5021da177e4SLinus Torvalds /* 5031da177e4SLinus Torvalds * terminate a voice 5041da177e4SLinus Torvalds * if free flag is true, call free_voice after termination 5051da177e4SLinus Torvalds */ 5061da177e4SLinus Torvalds static void 50703da312aSTakashi Iwai terminate_voice(struct snd_emux *emu, struct snd_emux_voice *vp, int free) 5081da177e4SLinus Torvalds { 5091da177e4SLinus Torvalds emu->ops.terminate(vp); 5101da177e4SLinus Torvalds vp->time = emu->use_time++; 5111da177e4SLinus Torvalds vp->chan = NULL; 5121da177e4SLinus Torvalds vp->port = NULL; 5131da177e4SLinus Torvalds vp->zone = NULL; 5141da177e4SLinus Torvalds vp->block = NULL; 5151da177e4SLinus Torvalds vp->state = SNDRV_EMUX_ST_OFF; 5161da177e4SLinus Torvalds if (free && emu->ops.free_voice) 5171da177e4SLinus Torvalds emu->ops.free_voice(vp); 5181da177e4SLinus Torvalds } 5191da177e4SLinus Torvalds 5201da177e4SLinus Torvalds 5211da177e4SLinus Torvalds /* 5221da177e4SLinus Torvalds * Modulate the voice 5231da177e4SLinus Torvalds */ 5241da177e4SLinus Torvalds static void 52503da312aSTakashi Iwai update_voice(struct snd_emux *emu, struct snd_emux_voice *vp, int update) 5261da177e4SLinus Torvalds { 5271da177e4SLinus Torvalds if (!STATE_IS_PLAYING(vp->state)) 5281da177e4SLinus Torvalds return; 5291da177e4SLinus Torvalds 5301da177e4SLinus Torvalds if (vp->chan == NULL || vp->port == NULL) 5311da177e4SLinus Torvalds return; 5321da177e4SLinus Torvalds if (update & SNDRV_EMUX_UPDATE_VOLUME) 5331da177e4SLinus Torvalds calc_volume(vp); 5341da177e4SLinus Torvalds if (update & SNDRV_EMUX_UPDATE_PITCH) 5351da177e4SLinus Torvalds calc_pitch(vp); 5361da177e4SLinus Torvalds if (update & SNDRV_EMUX_UPDATE_PAN) { 5371da177e4SLinus Torvalds if (! calc_pan(vp) && (update == SNDRV_EMUX_UPDATE_PAN)) 5381da177e4SLinus Torvalds return; 5391da177e4SLinus Torvalds } 5401da177e4SLinus Torvalds emu->ops.update(vp, update); 5411da177e4SLinus Torvalds } 5421da177e4SLinus Torvalds 5431da177e4SLinus Torvalds 5441da177e4SLinus Torvalds #if 0 // not used 5451da177e4SLinus Torvalds /* table for volume target calculation */ 5461da177e4SLinus Torvalds static unsigned short voltarget[16] = { 5471da177e4SLinus Torvalds 0xEAC0, 0xE0C8, 0xD740, 0xCE20, 0xC560, 0xBD08, 0xB500, 0xAD58, 5481da177e4SLinus Torvalds 0xA5F8, 0x9EF0, 0x9830, 0x91C0, 0x8B90, 0x85A8, 0x8000, 0x7A90 5491da177e4SLinus Torvalds }; 5501da177e4SLinus Torvalds #endif 5511da177e4SLinus Torvalds 5521da177e4SLinus Torvalds #define LO_BYTE(v) ((v) & 0xff) 5531da177e4SLinus Torvalds #define HI_BYTE(v) (((v) >> 8) & 0xff) 5541da177e4SLinus Torvalds 5551da177e4SLinus Torvalds /* 5561da177e4SLinus Torvalds * Sets up the voice structure by calculating some values that 5571da177e4SLinus Torvalds * will be needed later. 5581da177e4SLinus Torvalds */ 5591da177e4SLinus Torvalds static void 56003da312aSTakashi Iwai setup_voice(struct snd_emux_voice *vp) 5611da177e4SLinus Torvalds { 56203da312aSTakashi Iwai struct soundfont_voice_parm *parm; 5631da177e4SLinus Torvalds int pitch; 5641da177e4SLinus Torvalds 5651da177e4SLinus Torvalds /* copy the original register values */ 5661da177e4SLinus Torvalds vp->reg = vp->zone->v; 5671da177e4SLinus Torvalds 5681da177e4SLinus Torvalds #ifdef SNDRV_EMUX_USE_RAW_EFFECT 5691da177e4SLinus Torvalds snd_emux_setup_effect(vp); 5701da177e4SLinus Torvalds #endif 5711da177e4SLinus Torvalds 5721da177e4SLinus Torvalds /* reset status */ 5731da177e4SLinus Torvalds vp->apan = -1; 5741da177e4SLinus Torvalds vp->avol = -1; 5751da177e4SLinus Torvalds vp->apitch = -1; 5761da177e4SLinus Torvalds 5771da177e4SLinus Torvalds calc_volume(vp); 5781da177e4SLinus Torvalds calc_pitch(vp); 5791da177e4SLinus Torvalds calc_pan(vp); 5801da177e4SLinus Torvalds 5811da177e4SLinus Torvalds parm = &vp->reg.parm; 5821da177e4SLinus Torvalds 5831da177e4SLinus Torvalds /* compute filter target and correct modulation parameters */ 5841da177e4SLinus Torvalds if (LO_BYTE(parm->modatkhld) >= 0x80 && parm->moddelay >= 0x8000) { 5851da177e4SLinus Torvalds parm->moddelay = 0xbfff; 5861da177e4SLinus Torvalds pitch = (HI_BYTE(parm->pefe) << 4) + vp->apitch; 5871da177e4SLinus Torvalds if (pitch > 0xffff) 5881da177e4SLinus Torvalds pitch = 0xffff; 5891da177e4SLinus Torvalds /* calculate filter target */ 5901da177e4SLinus Torvalds vp->ftarget = parm->cutoff + LO_BYTE(parm->pefe); 5911da177e4SLinus Torvalds LIMITVALUE(vp->ftarget, 0, 255); 5921da177e4SLinus Torvalds vp->ftarget <<= 8; 5931da177e4SLinus Torvalds } else { 5941da177e4SLinus Torvalds vp->ftarget = parm->cutoff; 5951da177e4SLinus Torvalds vp->ftarget <<= 8; 5961da177e4SLinus Torvalds pitch = vp->apitch; 5971da177e4SLinus Torvalds } 5981da177e4SLinus Torvalds 5991da177e4SLinus Torvalds /* compute pitch target */ 6001da177e4SLinus Torvalds if (pitch != 0xffff) { 6011da177e4SLinus Torvalds vp->ptarget = 1 << (pitch >> 12); 6021da177e4SLinus Torvalds if (pitch & 0x800) vp->ptarget += (vp->ptarget*0x102e)/0x2710; 6031da177e4SLinus Torvalds if (pitch & 0x400) vp->ptarget += (vp->ptarget*0x764)/0x2710; 6041da177e4SLinus Torvalds if (pitch & 0x200) vp->ptarget += (vp->ptarget*0x389)/0x2710; 6051da177e4SLinus Torvalds vp->ptarget += (vp->ptarget >> 1); 6061da177e4SLinus Torvalds if (vp->ptarget > 0xffff) vp->ptarget = 0xffff; 6071da177e4SLinus Torvalds } else 6081da177e4SLinus Torvalds vp->ptarget = 0xffff; 6091da177e4SLinus Torvalds 6101da177e4SLinus Torvalds if (LO_BYTE(parm->modatkhld) >= 0x80) { 6111da177e4SLinus Torvalds parm->modatkhld &= ~0xff; 6121da177e4SLinus Torvalds parm->modatkhld |= 0x7f; 6131da177e4SLinus Torvalds } 6141da177e4SLinus Torvalds 6151da177e4SLinus Torvalds /* compute volume target and correct volume parameters */ 6161da177e4SLinus Torvalds vp->vtarget = 0; 6171da177e4SLinus Torvalds #if 0 /* FIXME: this leads to some clicks.. */ 6181da177e4SLinus Torvalds if (LO_BYTE(parm->volatkhld) >= 0x80 && parm->voldelay >= 0x8000) { 6191da177e4SLinus Torvalds parm->voldelay = 0xbfff; 6201da177e4SLinus Torvalds vp->vtarget = voltarget[vp->avol % 0x10] >> (vp->avol >> 4); 6211da177e4SLinus Torvalds } 6221da177e4SLinus Torvalds #endif 6231da177e4SLinus Torvalds 6241da177e4SLinus Torvalds if (LO_BYTE(parm->volatkhld) >= 0x80) { 6251da177e4SLinus Torvalds parm->volatkhld &= ~0xff; 6261da177e4SLinus Torvalds parm->volatkhld |= 0x7f; 6271da177e4SLinus Torvalds } 6281da177e4SLinus Torvalds } 6291da177e4SLinus Torvalds 6301da177e4SLinus Torvalds /* 6311da177e4SLinus Torvalds * calculate pitch parameter 6321da177e4SLinus Torvalds */ 6331da177e4SLinus Torvalds static unsigned char pan_volumes[256] = { 6341da177e4SLinus Torvalds 0x00,0x03,0x06,0x09,0x0c,0x0f,0x12,0x14,0x17,0x1a,0x1d,0x20,0x22,0x25,0x28,0x2a, 6351da177e4SLinus Torvalds 0x2d,0x30,0x32,0x35,0x37,0x3a,0x3c,0x3f,0x41,0x44,0x46,0x49,0x4b,0x4d,0x50,0x52, 6361da177e4SLinus Torvalds 0x54,0x57,0x59,0x5b,0x5d,0x60,0x62,0x64,0x66,0x68,0x6a,0x6c,0x6f,0x71,0x73,0x75, 6371da177e4SLinus Torvalds 0x77,0x79,0x7b,0x7c,0x7e,0x80,0x82,0x84,0x86,0x88,0x89,0x8b,0x8d,0x8f,0x90,0x92, 6381da177e4SLinus Torvalds 0x94,0x96,0x97,0x99,0x9a,0x9c,0x9e,0x9f,0xa1,0xa2,0xa4,0xa5,0xa7,0xa8,0xaa,0xab, 6391da177e4SLinus Torvalds 0xad,0xae,0xaf,0xb1,0xb2,0xb3,0xb5,0xb6,0xb7,0xb9,0xba,0xbb,0xbc,0xbe,0xbf,0xc0, 6401da177e4SLinus Torvalds 0xc1,0xc2,0xc3,0xc5,0xc6,0xc7,0xc8,0xc9,0xca,0xcb,0xcc,0xcd,0xce,0xcf,0xd0,0xd1, 6411da177e4SLinus Torvalds 0xd2,0xd3,0xd4,0xd5,0xd6,0xd7,0xd7,0xd8,0xd9,0xda,0xdb,0xdc,0xdc,0xdd,0xde,0xdf, 6421da177e4SLinus Torvalds 0xdf,0xe0,0xe1,0xe2,0xe2,0xe3,0xe4,0xe4,0xe5,0xe6,0xe6,0xe7,0xe8,0xe8,0xe9,0xe9, 6431da177e4SLinus Torvalds 0xea,0xeb,0xeb,0xec,0xec,0xed,0xed,0xee,0xee,0xef,0xef,0xf0,0xf0,0xf1,0xf1,0xf1, 6441da177e4SLinus Torvalds 0xf2,0xf2,0xf3,0xf3,0xf3,0xf4,0xf4,0xf5,0xf5,0xf5,0xf6,0xf6,0xf6,0xf7,0xf7,0xf7, 6451da177e4SLinus Torvalds 0xf7,0xf8,0xf8,0xf8,0xf9,0xf9,0xf9,0xf9,0xf9,0xfa,0xfa,0xfa,0xfa,0xfb,0xfb,0xfb, 6461da177e4SLinus Torvalds 0xfb,0xfb,0xfc,0xfc,0xfc,0xfc,0xfc,0xfc,0xfc,0xfd,0xfd,0xfd,0xfd,0xfd,0xfd,0xfd, 6471da177e4SLinus Torvalds 0xfd,0xfe,0xfe,0xfe,0xfe,0xfe,0xfe,0xfe,0xfe,0xfe,0xfe,0xfe,0xfe,0xfe,0xfe,0xfe, 6481da177e4SLinus Torvalds 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, 6491da177e4SLinus Torvalds 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, 6501da177e4SLinus Torvalds }; 6511da177e4SLinus Torvalds 6521da177e4SLinus Torvalds static int 65303da312aSTakashi Iwai calc_pan(struct snd_emux_voice *vp) 6541da177e4SLinus Torvalds { 65503da312aSTakashi Iwai struct snd_midi_channel *chan = vp->chan; 6561da177e4SLinus Torvalds int pan; 6571da177e4SLinus Torvalds 6581da177e4SLinus Torvalds /* pan & loop start (pan 8bit, MSB, 0:right, 0xff:left) */ 6591da177e4SLinus Torvalds if (vp->reg.fixpan > 0) /* 0-127 */ 6601da177e4SLinus Torvalds pan = 255 - (int)vp->reg.fixpan * 2; 6611da177e4SLinus Torvalds else { 6621da177e4SLinus Torvalds pan = chan->control[MIDI_CTL_MSB_PAN] - 64; 6631da177e4SLinus Torvalds if (vp->reg.pan >= 0) /* 0-127 */ 6641da177e4SLinus Torvalds pan += vp->reg.pan - 64; 6651da177e4SLinus Torvalds pan = 127 - (int)pan * 2; 6661da177e4SLinus Torvalds } 6671da177e4SLinus Torvalds LIMITVALUE(pan, 0, 255); 6681da177e4SLinus Torvalds 6691da177e4SLinus Torvalds if (vp->emu->linear_panning) { 6701da177e4SLinus Torvalds /* assuming linear volume */ 6711da177e4SLinus Torvalds if (pan != vp->apan) { 6721da177e4SLinus Torvalds vp->apan = pan; 6731da177e4SLinus Torvalds if (pan == 0) 6741da177e4SLinus Torvalds vp->aaux = 0xff; 6751da177e4SLinus Torvalds else 6761da177e4SLinus Torvalds vp->aaux = (-pan) & 0xff; 6771da177e4SLinus Torvalds return 1; 6781da177e4SLinus Torvalds } else 6791da177e4SLinus Torvalds return 0; 6801da177e4SLinus Torvalds } else { 6811da177e4SLinus Torvalds /* using volume table */ 6821da177e4SLinus Torvalds if (vp->apan != (int)pan_volumes[pan]) { 6831da177e4SLinus Torvalds vp->apan = pan_volumes[pan]; 6841da177e4SLinus Torvalds vp->aaux = pan_volumes[255 - pan]; 6851da177e4SLinus Torvalds return 1; 6861da177e4SLinus Torvalds } 6871da177e4SLinus Torvalds return 0; 6881da177e4SLinus Torvalds } 6891da177e4SLinus Torvalds } 6901da177e4SLinus Torvalds 6911da177e4SLinus Torvalds 6921da177e4SLinus Torvalds /* 6931da177e4SLinus Torvalds * calculate volume attenuation 6941da177e4SLinus Torvalds * 6951da177e4SLinus Torvalds * Voice volume is controlled by volume attenuation parameter. 6961da177e4SLinus Torvalds * So volume becomes maximum when avol is 0 (no attenuation), and 6971da177e4SLinus Torvalds * minimum when 255 (-96dB or silence). 6981da177e4SLinus Torvalds */ 6991da177e4SLinus Torvalds 7001da177e4SLinus Torvalds /* tables for volume->attenuation calculation */ 7011da177e4SLinus Torvalds static unsigned char voltab1[128] = { 7021da177e4SLinus Torvalds 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 7031da177e4SLinus Torvalds 0x63, 0x2b, 0x29, 0x28, 0x27, 0x26, 0x25, 0x24, 0x23, 0x22, 7041da177e4SLinus Torvalds 0x21, 0x20, 0x1f, 0x1e, 0x1e, 0x1d, 0x1c, 0x1b, 0x1b, 0x1a, 7051da177e4SLinus Torvalds 0x19, 0x19, 0x18, 0x17, 0x17, 0x16, 0x16, 0x15, 0x15, 0x14, 7061da177e4SLinus Torvalds 0x14, 0x13, 0x13, 0x13, 0x12, 0x12, 0x11, 0x11, 0x11, 0x10, 7071da177e4SLinus Torvalds 0x10, 0x10, 0x0f, 0x0f, 0x0f, 0x0e, 0x0e, 0x0e, 0x0e, 0x0d, 7081da177e4SLinus Torvalds 0x0d, 0x0d, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0b, 0x0b, 0x0b, 7091da177e4SLinus Torvalds 0x0b, 0x0a, 0x0a, 0x0a, 0x0a, 0x09, 0x09, 0x09, 0x09, 0x09, 7101da177e4SLinus Torvalds 0x08, 0x08, 0x08, 0x08, 0x08, 0x07, 0x07, 0x07, 0x07, 0x06, 7111da177e4SLinus Torvalds 0x06, 0x06, 0x06, 0x06, 0x05, 0x05, 0x05, 0x05, 0x05, 0x04, 7121da177e4SLinus Torvalds 0x04, 0x04, 0x04, 0x04, 0x03, 0x03, 0x03, 0x03, 0x03, 0x02, 7131da177e4SLinus Torvalds 0x02, 0x02, 0x02, 0x02, 0x02, 0x01, 0x01, 0x01, 0x01, 0x01, 7141da177e4SLinus Torvalds 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 7151da177e4SLinus Torvalds }; 7161da177e4SLinus Torvalds 7171da177e4SLinus Torvalds static unsigned char voltab2[128] = { 7181da177e4SLinus Torvalds 0x32, 0x31, 0x30, 0x2f, 0x2e, 0x2d, 0x2c, 0x2b, 0x2a, 0x2a, 7191da177e4SLinus Torvalds 0x29, 0x28, 0x27, 0x26, 0x25, 0x24, 0x24, 0x23, 0x22, 0x21, 7201da177e4SLinus Torvalds 0x21, 0x20, 0x1f, 0x1e, 0x1e, 0x1d, 0x1c, 0x1c, 0x1b, 0x1a, 7211da177e4SLinus Torvalds 0x1a, 0x19, 0x19, 0x18, 0x18, 0x17, 0x16, 0x16, 0x15, 0x15, 7221da177e4SLinus Torvalds 0x14, 0x14, 0x13, 0x13, 0x13, 0x12, 0x12, 0x11, 0x11, 0x10, 7231da177e4SLinus Torvalds 0x10, 0x10, 0x0f, 0x0f, 0x0f, 0x0e, 0x0e, 0x0e, 0x0d, 0x0d, 7241da177e4SLinus Torvalds 0x0d, 0x0c, 0x0c, 0x0c, 0x0b, 0x0b, 0x0b, 0x0b, 0x0a, 0x0a, 7251da177e4SLinus Torvalds 0x0a, 0x0a, 0x09, 0x09, 0x09, 0x09, 0x09, 0x08, 0x08, 0x08, 7261da177e4SLinus Torvalds 0x08, 0x08, 0x07, 0x07, 0x07, 0x07, 0x07, 0x06, 0x06, 0x06, 7271da177e4SLinus Torvalds 0x06, 0x06, 0x06, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 7281da177e4SLinus Torvalds 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x03, 0x03, 0x03, 0x03, 7291da177e4SLinus Torvalds 0x03, 0x03, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x01, 0x01, 7301da177e4SLinus Torvalds 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00 7311da177e4SLinus Torvalds }; 7321da177e4SLinus Torvalds 7331da177e4SLinus Torvalds static unsigned char expressiontab[128] = { 7341da177e4SLinus Torvalds 0x7f, 0x6c, 0x62, 0x5a, 0x54, 0x50, 0x4b, 0x48, 0x45, 0x42, 7351da177e4SLinus Torvalds 0x40, 0x3d, 0x3b, 0x39, 0x38, 0x36, 0x34, 0x33, 0x31, 0x30, 7361da177e4SLinus Torvalds 0x2f, 0x2d, 0x2c, 0x2b, 0x2a, 0x29, 0x28, 0x27, 0x26, 0x25, 7371da177e4SLinus Torvalds 0x24, 0x24, 0x23, 0x22, 0x21, 0x21, 0x20, 0x1f, 0x1e, 0x1e, 7381da177e4SLinus Torvalds 0x1d, 0x1d, 0x1c, 0x1b, 0x1b, 0x1a, 0x1a, 0x19, 0x18, 0x18, 7391da177e4SLinus Torvalds 0x17, 0x17, 0x16, 0x16, 0x15, 0x15, 0x15, 0x14, 0x14, 0x13, 7401da177e4SLinus Torvalds 0x13, 0x12, 0x12, 0x11, 0x11, 0x11, 0x10, 0x10, 0x0f, 0x0f, 7411da177e4SLinus Torvalds 0x0f, 0x0e, 0x0e, 0x0e, 0x0d, 0x0d, 0x0d, 0x0c, 0x0c, 0x0c, 7421da177e4SLinus Torvalds 0x0b, 0x0b, 0x0b, 0x0a, 0x0a, 0x0a, 0x09, 0x09, 0x09, 0x09, 7431da177e4SLinus Torvalds 0x08, 0x08, 0x08, 0x07, 0x07, 0x07, 0x07, 0x06, 0x06, 0x06, 7441da177e4SLinus Torvalds 0x06, 0x05, 0x05, 0x05, 0x04, 0x04, 0x04, 0x04, 0x04, 0x03, 7451da177e4SLinus Torvalds 0x03, 0x03, 0x03, 0x02, 0x02, 0x02, 0x02, 0x01, 0x01, 0x01, 7461da177e4SLinus Torvalds 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 7471da177e4SLinus Torvalds }; 7481da177e4SLinus Torvalds 7491da177e4SLinus Torvalds /* 7501da177e4SLinus Torvalds * Magic to calculate the volume (actually attenuation) from all the 7511da177e4SLinus Torvalds * voice and channels parameters. 7521da177e4SLinus Torvalds */ 7531da177e4SLinus Torvalds static int 75403da312aSTakashi Iwai calc_volume(struct snd_emux_voice *vp) 7551da177e4SLinus Torvalds { 7561da177e4SLinus Torvalds int vol; 7571da177e4SLinus Torvalds int main_vol, expression_vol, master_vol; 75803da312aSTakashi Iwai struct snd_midi_channel *chan = vp->chan; 75903da312aSTakashi Iwai struct snd_emux_port *port = vp->port; 7601da177e4SLinus Torvalds 7611da177e4SLinus Torvalds expression_vol = chan->control[MIDI_CTL_MSB_EXPRESSION]; 7621da177e4SLinus Torvalds LIMITMAX(vp->velocity, 127); 7631da177e4SLinus Torvalds LIMITVALUE(expression_vol, 0, 127); 7641da177e4SLinus Torvalds if (port->port_mode == SNDRV_EMUX_PORT_MODE_OSS_SYNTH) { 7651da177e4SLinus Torvalds /* 0 - 127 */ 7661da177e4SLinus Torvalds main_vol = chan->control[MIDI_CTL_MSB_MAIN_VOLUME]; 7671da177e4SLinus Torvalds vol = (vp->velocity * main_vol * expression_vol) / (127*127); 7681da177e4SLinus Torvalds vol = vol * vp->reg.amplitude / 127; 7691da177e4SLinus Torvalds 7701da177e4SLinus Torvalds LIMITVALUE(vol, 0, 127); 7711da177e4SLinus Torvalds 7721da177e4SLinus Torvalds /* calc to attenuation */ 7731da177e4SLinus Torvalds vol = snd_sf_vol_table[vol]; 7741da177e4SLinus Torvalds 7751da177e4SLinus Torvalds } else { 7761da177e4SLinus Torvalds main_vol = chan->control[MIDI_CTL_MSB_MAIN_VOLUME] * vp->reg.amplitude / 127; 7771da177e4SLinus Torvalds LIMITVALUE(main_vol, 0, 127); 7781da177e4SLinus Torvalds 7791da177e4SLinus Torvalds vol = voltab1[main_vol] + voltab2[vp->velocity]; 7801da177e4SLinus Torvalds vol = (vol * 8) / 3; 7811da177e4SLinus Torvalds vol += vp->reg.attenuation; 7821da177e4SLinus Torvalds vol += ((0x100 - vol) * expressiontab[expression_vol])/128; 7831da177e4SLinus Torvalds } 7841da177e4SLinus Torvalds 7851da177e4SLinus Torvalds master_vol = port->chset.gs_master_volume; 7861da177e4SLinus Torvalds LIMITVALUE(master_vol, 0, 127); 7871da177e4SLinus Torvalds vol += snd_sf_vol_table[master_vol]; 7881da177e4SLinus Torvalds vol += port->volume_atten; 7891da177e4SLinus Torvalds 7901da177e4SLinus Torvalds #ifdef SNDRV_EMUX_USE_RAW_EFFECT 7911da177e4SLinus Torvalds if (chan->private) { 79203da312aSTakashi Iwai struct snd_emux_effect_table *fx = chan->private; 7931da177e4SLinus Torvalds vol += fx->val[EMUX_FX_ATTEN]; 7941da177e4SLinus Torvalds } 7951da177e4SLinus Torvalds #endif 7961da177e4SLinus Torvalds 7971da177e4SLinus Torvalds LIMITVALUE(vol, 0, 255); 7981da177e4SLinus Torvalds if (vp->avol == vol) 7991da177e4SLinus Torvalds return 0; /* value unchanged */ 8001da177e4SLinus Torvalds 8011da177e4SLinus Torvalds vp->avol = vol; 8021da177e4SLinus Torvalds if (!SF_IS_DRUM_BANK(get_bank(port, chan)) 8031da177e4SLinus Torvalds && LO_BYTE(vp->reg.parm.volatkhld) < 0x7d) { 8041da177e4SLinus Torvalds int atten; 8051da177e4SLinus Torvalds if (vp->velocity < 70) 8061da177e4SLinus Torvalds atten = 70; 8071da177e4SLinus Torvalds else 8081da177e4SLinus Torvalds atten = vp->velocity; 8091da177e4SLinus Torvalds vp->acutoff = (atten * vp->reg.parm.cutoff + 0xa0) >> 7; 8101da177e4SLinus Torvalds } else { 8111da177e4SLinus Torvalds vp->acutoff = vp->reg.parm.cutoff; 8121da177e4SLinus Torvalds } 8131da177e4SLinus Torvalds 8141da177e4SLinus Torvalds return 1; /* value changed */ 8151da177e4SLinus Torvalds } 8161da177e4SLinus Torvalds 8171da177e4SLinus Torvalds /* 8181da177e4SLinus Torvalds * calculate pitch offset 8191da177e4SLinus Torvalds * 8201da177e4SLinus Torvalds * 0xE000 is no pitch offset at 44100Hz sample. 8211da177e4SLinus Torvalds * Every 4096 is one octave. 8221da177e4SLinus Torvalds */ 8231da177e4SLinus Torvalds 8241da177e4SLinus Torvalds static int 82503da312aSTakashi Iwai calc_pitch(struct snd_emux_voice *vp) 8261da177e4SLinus Torvalds { 82703da312aSTakashi Iwai struct snd_midi_channel *chan = vp->chan; 8281da177e4SLinus Torvalds int offset; 8291da177e4SLinus Torvalds 8301da177e4SLinus Torvalds /* calculate offset */ 8311da177e4SLinus Torvalds if (vp->reg.fixkey >= 0) { 8321da177e4SLinus Torvalds offset = (vp->reg.fixkey - vp->reg.root) * 4096 / 12; 8331da177e4SLinus Torvalds } else { 8341da177e4SLinus Torvalds offset = (vp->note - vp->reg.root) * 4096 / 12; 8351da177e4SLinus Torvalds } 8361da177e4SLinus Torvalds offset = (offset * vp->reg.scaleTuning) / 100; 8371da177e4SLinus Torvalds offset += vp->reg.tune * 4096 / 1200; 8381da177e4SLinus Torvalds if (chan->midi_pitchbend != 0) { 8391da177e4SLinus Torvalds /* (128 * 8192: 1 semitone) ==> (4096: 12 semitones) */ 8401da177e4SLinus Torvalds offset += chan->midi_pitchbend * chan->gm_rpn_pitch_bend_range / 3072; 8411da177e4SLinus Torvalds } 8421da177e4SLinus Torvalds 8431da177e4SLinus Torvalds /* tuning via RPN: 8441da177e4SLinus Torvalds * coarse = -8192 to 8192 (100 cent per 128) 8451da177e4SLinus Torvalds * fine = -8192 to 8192 (max=100cent) 8461da177e4SLinus Torvalds */ 8471da177e4SLinus Torvalds /* 4096 = 1200 cents in emu8000 parameter */ 8481da177e4SLinus Torvalds offset += chan->gm_rpn_coarse_tuning * 4096 / (12 * 128); 8491da177e4SLinus Torvalds offset += chan->gm_rpn_fine_tuning / 24; 8501da177e4SLinus Torvalds 8511da177e4SLinus Torvalds #ifdef SNDRV_EMUX_USE_RAW_EFFECT 8521da177e4SLinus Torvalds /* add initial pitch correction */ 8531da177e4SLinus Torvalds if (chan->private) { 85403da312aSTakashi Iwai struct snd_emux_effect_table *fx = chan->private; 8551da177e4SLinus Torvalds if (fx->flag[EMUX_FX_INIT_PITCH]) 8561da177e4SLinus Torvalds offset += fx->val[EMUX_FX_INIT_PITCH]; 8571da177e4SLinus Torvalds } 8581da177e4SLinus Torvalds #endif 8591da177e4SLinus Torvalds 8601da177e4SLinus Torvalds /* 0xe000: root pitch */ 8611da177e4SLinus Torvalds offset += 0xe000 + vp->reg.rate_offset; 8621da177e4SLinus Torvalds offset += vp->emu->pitch_shift; 8631da177e4SLinus Torvalds LIMITVALUE(offset, 0, 0xffff); 8641da177e4SLinus Torvalds if (offset == vp->apitch) 8651da177e4SLinus Torvalds return 0; /* unchanged */ 8661da177e4SLinus Torvalds vp->apitch = offset; 8671da177e4SLinus Torvalds return 1; /* value changed */ 8681da177e4SLinus Torvalds } 8691da177e4SLinus Torvalds 8701da177e4SLinus Torvalds /* 8711da177e4SLinus Torvalds * Get the bank number assigned to the channel 8721da177e4SLinus Torvalds */ 8731da177e4SLinus Torvalds static int 87403da312aSTakashi Iwai get_bank(struct snd_emux_port *port, struct snd_midi_channel *chan) 8751da177e4SLinus Torvalds { 8761da177e4SLinus Torvalds int val; 8771da177e4SLinus Torvalds 8781da177e4SLinus Torvalds switch (port->chset.midi_mode) { 8791da177e4SLinus Torvalds case SNDRV_MIDI_MODE_XG: 8801da177e4SLinus Torvalds val = chan->control[MIDI_CTL_MSB_BANK]; 8811da177e4SLinus Torvalds if (val == 127) 8821da177e4SLinus Torvalds return 128; /* return drum bank */ 8831da177e4SLinus Torvalds return chan->control[MIDI_CTL_LSB_BANK]; 8841da177e4SLinus Torvalds 8851da177e4SLinus Torvalds case SNDRV_MIDI_MODE_GS: 8861da177e4SLinus Torvalds if (chan->drum_channel) 8871da177e4SLinus Torvalds return 128; 8881da177e4SLinus Torvalds /* ignore LSB (bank map) */ 8891da177e4SLinus Torvalds return chan->control[MIDI_CTL_MSB_BANK]; 8901da177e4SLinus Torvalds 8911da177e4SLinus Torvalds default: 8921da177e4SLinus Torvalds if (chan->drum_channel) 8931da177e4SLinus Torvalds return 128; 8941da177e4SLinus Torvalds return chan->control[MIDI_CTL_MSB_BANK]; 8951da177e4SLinus Torvalds } 8961da177e4SLinus Torvalds } 8971da177e4SLinus Torvalds 8981da177e4SLinus Torvalds 8991da177e4SLinus Torvalds /* Look for the zones matching with the given note and velocity. 9001da177e4SLinus Torvalds * The resultant zones are stored on table. 9011da177e4SLinus Torvalds */ 9021da177e4SLinus Torvalds static int 90303da312aSTakashi Iwai get_zone(struct snd_emux *emu, struct snd_emux_port *port, 90403da312aSTakashi Iwai int *notep, int vel, struct snd_midi_channel *chan, 90503da312aSTakashi Iwai struct snd_sf_zone **table) 9061da177e4SLinus Torvalds { 9071da177e4SLinus Torvalds int preset, bank, def_preset, def_bank; 9081da177e4SLinus Torvalds 9091da177e4SLinus Torvalds bank = get_bank(port, chan); 9101da177e4SLinus Torvalds preset = chan->midi_program; 9111da177e4SLinus Torvalds 9121da177e4SLinus Torvalds if (SF_IS_DRUM_BANK(bank)) { 9131da177e4SLinus Torvalds def_preset = port->ctrls[EMUX_MD_DEF_DRUM]; 9141da177e4SLinus Torvalds def_bank = bank; 9151da177e4SLinus Torvalds } else { 9161da177e4SLinus Torvalds def_preset = preset; 9171da177e4SLinus Torvalds def_bank = port->ctrls[EMUX_MD_DEF_BANK]; 9181da177e4SLinus Torvalds } 9191da177e4SLinus Torvalds 9201da177e4SLinus Torvalds return snd_soundfont_search_zone(emu->sflist, notep, vel, preset, bank, 9211da177e4SLinus Torvalds def_preset, def_bank, 9221da177e4SLinus Torvalds table, SNDRV_EMUX_MAX_MULTI_VOICES); 9231da177e4SLinus Torvalds } 9241da177e4SLinus Torvalds 9251da177e4SLinus Torvalds /* 9261da177e4SLinus Torvalds */ 9271da177e4SLinus Torvalds void 92803da312aSTakashi Iwai snd_emux_init_voices(struct snd_emux *emu) 9291da177e4SLinus Torvalds { 93003da312aSTakashi Iwai struct snd_emux_voice *vp; 9311da177e4SLinus Torvalds int i; 9321da177e4SLinus Torvalds unsigned long flags; 9331da177e4SLinus Torvalds 9341da177e4SLinus Torvalds spin_lock_irqsave(&emu->voice_lock, flags); 9351da177e4SLinus Torvalds for (i = 0; i < emu->max_voices; i++) { 9361da177e4SLinus Torvalds vp = &emu->voices[i]; 9371da177e4SLinus Torvalds vp->ch = -1; /* not used */ 9381da177e4SLinus Torvalds vp->state = SNDRV_EMUX_ST_OFF; 9391da177e4SLinus Torvalds vp->chan = NULL; 9401da177e4SLinus Torvalds vp->port = NULL; 9411da177e4SLinus Torvalds vp->time = 0; 9421da177e4SLinus Torvalds vp->emu = emu; 9431da177e4SLinus Torvalds vp->hw = emu->hw; 9441da177e4SLinus Torvalds } 9451da177e4SLinus Torvalds spin_unlock_irqrestore(&emu->voice_lock, flags); 9461da177e4SLinus Torvalds } 9471da177e4SLinus Torvalds 9481da177e4SLinus Torvalds /* 9491da177e4SLinus Torvalds */ 95003da312aSTakashi Iwai void snd_emux_lock_voice(struct snd_emux *emu, int voice) 9511da177e4SLinus Torvalds { 9521da177e4SLinus Torvalds unsigned long flags; 9531da177e4SLinus Torvalds 9541da177e4SLinus Torvalds spin_lock_irqsave(&emu->voice_lock, flags); 9551da177e4SLinus Torvalds if (emu->voices[voice].state == SNDRV_EMUX_ST_OFF) 9561da177e4SLinus Torvalds emu->voices[voice].state = SNDRV_EMUX_ST_LOCKED; 9571da177e4SLinus Torvalds else 95842b0158bSTakashi Iwai snd_printk(KERN_WARNING 95942b0158bSTakashi Iwai "invalid voice for lock %d (state = %x)\n", 9601da177e4SLinus Torvalds voice, emu->voices[voice].state); 9611da177e4SLinus Torvalds spin_unlock_irqrestore(&emu->voice_lock, flags); 9621da177e4SLinus Torvalds } 9631da177e4SLinus Torvalds 96495ff1756STakashi Iwai EXPORT_SYMBOL(snd_emux_lock_voice); 96595ff1756STakashi Iwai 9661da177e4SLinus Torvalds /* 9671da177e4SLinus Torvalds */ 96803da312aSTakashi Iwai void snd_emux_unlock_voice(struct snd_emux *emu, int voice) 9691da177e4SLinus Torvalds { 9701da177e4SLinus Torvalds unsigned long flags; 9711da177e4SLinus Torvalds 9721da177e4SLinus Torvalds spin_lock_irqsave(&emu->voice_lock, flags); 9731da177e4SLinus Torvalds if (emu->voices[voice].state == SNDRV_EMUX_ST_LOCKED) 9741da177e4SLinus Torvalds emu->voices[voice].state = SNDRV_EMUX_ST_OFF; 9751da177e4SLinus Torvalds else 97642b0158bSTakashi Iwai snd_printk(KERN_WARNING 97742b0158bSTakashi Iwai "invalid voice for unlock %d (state = %x)\n", 9781da177e4SLinus Torvalds voice, emu->voices[voice].state); 9791da177e4SLinus Torvalds spin_unlock_irqrestore(&emu->voice_lock, flags); 9801da177e4SLinus Torvalds } 98195ff1756STakashi Iwai 98295ff1756STakashi Iwai EXPORT_SYMBOL(snd_emux_unlock_voice); 983