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