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