?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[TG3]: Set minimal hw interrupt mitigation.
[linux-2.6/verdex.git] / sound / synth / emux / emux_synth.c
blobf13b038329ebfb29d5fad6728252484f162cb072
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 }
Verdex Pro support