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