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