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