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