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