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