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