2 * Soundfont generic routines.
3 * It is intended that these should be used by any driver that is willing
4 * to accept soundfont patches.
6 * Copyright (C) 1999 Steve Ratcliffe
7 * Copyright (c) 1999-2000 Takashi Iwai <tiwai@suse.de>
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.
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.
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
24 * Deal with reading in of a soundfont. Code follows the OSS way
25 * of doing things so that the old sfxload utility can be used.
26 * Everything may change when there is an alsa way of doing things.
28 #include <linux/uaccess.h>
29 #include <linux/slab.h>
30 #include <linux/export.h>
31 #include <sound/core.h>
32 #include <sound/soundfont.h>
33 #include <sound/seq_oss_legacy.h>
35 /* Prototypes for static functions */
37 static int open_patch(struct snd_sf_list *sflist, const char __user *data,
38 int count, int client);
39 static struct snd_soundfont *newsf(struct snd_sf_list *sflist, int type, char *name);
40 static int is_identical_font(struct snd_soundfont *sf, int type, unsigned char *name);
41 static int close_patch(struct snd_sf_list *sflist);
42 static int probe_data(struct snd_sf_list *sflist, int sample_id);
43 static void set_zone_counter(struct snd_sf_list *sflist,
44 struct snd_soundfont *sf, struct snd_sf_zone *zp);
45 static struct snd_sf_zone *sf_zone_new(struct snd_sf_list *sflist,
46 struct snd_soundfont *sf);
47 static void set_sample_counter(struct snd_sf_list *sflist,
48 struct snd_soundfont *sf, struct snd_sf_sample *sp);
49 static struct snd_sf_sample *sf_sample_new(struct snd_sf_list *sflist,
50 struct snd_soundfont *sf);
51 static void sf_sample_delete(struct snd_sf_list *sflist,
52 struct snd_soundfont *sf, struct snd_sf_sample *sp);
53 static int load_map(struct snd_sf_list *sflist, const void __user *data, int count);
54 static int load_info(struct snd_sf_list *sflist, const void __user *data, long count);
55 static int remove_info(struct snd_sf_list *sflist, struct snd_soundfont *sf,
57 static void init_voice_info(struct soundfont_voice_info *avp);
58 static void init_voice_parm(struct soundfont_voice_parm *pp);
59 static struct snd_sf_sample *set_sample(struct snd_soundfont *sf,
60 struct soundfont_voice_info *avp);
61 static struct snd_sf_sample *find_sample(struct snd_soundfont *sf, int sample_id);
62 static int load_data(struct snd_sf_list *sflist, const void __user *data, long count);
63 static void rebuild_presets(struct snd_sf_list *sflist);
64 static void add_preset(struct snd_sf_list *sflist, struct snd_sf_zone *cur);
65 static void delete_preset(struct snd_sf_list *sflist, struct snd_sf_zone *zp);
66 static struct snd_sf_zone *search_first_zone(struct snd_sf_list *sflist,
67 int bank, int preset, int key);
68 static int search_zones(struct snd_sf_list *sflist, int *notep, int vel,
69 int preset, int bank, struct snd_sf_zone **table,
70 int max_layers, int level);
71 static int get_index(int bank, int instr, int key);
72 static void snd_sf_init(struct snd_sf_list *sflist);
73 static void snd_sf_clear(struct snd_sf_list *sflist);
76 * lock access to sflist
79 lock_preset(struct snd_sf_list *sflist)
82 mutex_lock(&sflist->presets_mutex);
83 spin_lock_irqsave(&sflist->lock, flags);
84 sflist->presets_locked = 1;
85 spin_unlock_irqrestore(&sflist->lock, flags);
93 unlock_preset(struct snd_sf_list *sflist)
96 spin_lock_irqsave(&sflist->lock, flags);
97 sflist->presets_locked = 0;
98 spin_unlock_irqrestore(&sflist->lock, flags);
99 mutex_unlock(&sflist->presets_mutex);
104 * close the patch if the patch was opened by this client.
107 snd_soundfont_close_check(struct snd_sf_list *sflist, int client)
110 spin_lock_irqsave(&sflist->lock, flags);
111 if (sflist->open_client == client) {
112 spin_unlock_irqrestore(&sflist->lock, flags);
113 return close_patch(sflist);
115 spin_unlock_irqrestore(&sflist->lock, flags);
121 * Deal with a soundfont patch. Any driver could use these routines
122 * although it was designed for the AWE64.
124 * The sample_write and callargs pararameters allow a callback into
125 * the actual driver to write sample data to the board or whatever
126 * it wants to do with it.
129 snd_soundfont_load(struct snd_sf_list *sflist, const void __user *data,
130 long count, int client)
132 struct soundfont_patch_info patch;
136 if (count < (long)sizeof(patch)) {
137 snd_printk(KERN_ERR "patch record too small %ld\n", count);
140 if (copy_from_user(&patch, data, sizeof(patch)))
143 count -= sizeof(patch);
144 data += sizeof(patch);
146 if (patch.key != SNDRV_OSS_SOUNDFONT_PATCH) {
147 snd_printk(KERN_ERR "The wrong kind of patch %x\n", patch.key);
150 if (count < patch.len) {
151 snd_printk(KERN_ERR "Patch too short %ld, need %d\n",
156 snd_printk(KERN_ERR "poor length %d\n", patch.len);
160 if (patch.type == SNDRV_SFNT_OPEN_PATCH) {
161 /* grab sflist to open */
163 rc = open_patch(sflist, data, count, client);
164 unlock_preset(sflist);
168 /* check if other client already opened patch */
169 spin_lock_irqsave(&sflist->lock, flags);
170 if (sflist->open_client != client) {
171 spin_unlock_irqrestore(&sflist->lock, flags);
174 spin_unlock_irqrestore(&sflist->lock, flags);
178 switch (patch.type) {
179 case SNDRV_SFNT_LOAD_INFO:
180 rc = load_info(sflist, data, count);
182 case SNDRV_SFNT_LOAD_DATA:
183 rc = load_data(sflist, data, count);
185 case SNDRV_SFNT_CLOSE_PATCH:
186 rc = close_patch(sflist);
188 case SNDRV_SFNT_REPLACE_DATA:
189 /*rc = replace_data(&patch, data, count);*/
191 case SNDRV_SFNT_MAP_PRESET:
192 rc = load_map(sflist, data, count);
194 case SNDRV_SFNT_PROBE_DATA:
195 rc = probe_data(sflist, patch.optarg);
197 case SNDRV_SFNT_REMOVE_INFO:
198 /* patch must be opened */
199 if (!sflist->currsf) {
200 snd_printk(KERN_ERR "soundfont: remove_info: "
201 "patch not opened\n");
205 bank = ((unsigned short)patch.optarg >> 8) & 0xff;
206 instr = (unsigned short)patch.optarg & 0xff;
207 if (! remove_info(sflist, sflist->currsf, bank, instr))
214 unlock_preset(sflist);
220 /* check if specified type is special font (GUS or preset-alias) */
222 is_special_type(int type)
225 return (type == SNDRV_SFNT_PAT_TYPE_GUS ||
226 type == SNDRV_SFNT_PAT_TYPE_MAP);
230 /* open patch; create sf list */
232 open_patch(struct snd_sf_list *sflist, const char __user *data,
233 int count, int client)
235 struct soundfont_open_parm parm;
236 struct snd_soundfont *sf;
239 spin_lock_irqsave(&sflist->lock, flags);
240 if (sflist->open_client >= 0 || sflist->currsf) {
241 spin_unlock_irqrestore(&sflist->lock, flags);
244 spin_unlock_irqrestore(&sflist->lock, flags);
246 if (copy_from_user(&parm, data, sizeof(parm)))
249 if (is_special_type(parm.type)) {
250 parm.type |= SNDRV_SFNT_PAT_SHARED;
251 sf = newsf(sflist, parm.type, NULL);
253 sf = newsf(sflist, parm.type, parm.name);
258 spin_lock_irqsave(&sflist->lock, flags);
259 sflist->open_client = client;
261 spin_unlock_irqrestore(&sflist->lock, flags);
267 * Allocate a new soundfont structure.
269 static struct snd_soundfont *
270 newsf(struct snd_sf_list *sflist, int type, char *name)
272 struct snd_soundfont *sf;
274 /* check the shared fonts */
275 if (type & SNDRV_SFNT_PAT_SHARED) {
276 for (sf = sflist->fonts; sf; sf = sf->next) {
277 if (is_identical_font(sf, type, name)) {
283 /* not found -- create a new one */
284 sf = kzalloc(sizeof(*sf), GFP_KERNEL);
287 sf->id = sflist->fonts_size;
288 sflist->fonts_size++;
290 /* prepend this record */
291 sf->next = sflist->fonts;
298 memcpy(sf->name, name, SNDRV_SFNT_PATCH_NAME_LEN);
303 /* check if the given name matches to the existing list */
305 is_identical_font(struct snd_soundfont *sf, int type, unsigned char *name)
307 return ((sf->type & SNDRV_SFNT_PAT_SHARED) &&
308 (sf->type & 0x0f) == (type & 0x0f) &&
310 memcmp(sf->name, name, SNDRV_SFNT_PATCH_NAME_LEN) == 0));
314 * Close the current patch.
317 close_patch(struct snd_sf_list *sflist)
321 spin_lock_irqsave(&sflist->lock, flags);
322 sflist->currsf = NULL;
323 sflist->open_client = -1;
324 spin_unlock_irqrestore(&sflist->lock, flags);
326 rebuild_presets(sflist);
332 /* probe sample in the current list -- nothing to be loaded */
334 probe_data(struct snd_sf_list *sflist, int sample_id)
336 /* patch must be opened */
337 if (sflist->currsf) {
338 /* search the specified sample by optarg */
339 if (find_sample(sflist->currsf, sample_id))
346 * increment zone counter
349 set_zone_counter(struct snd_sf_list *sflist, struct snd_soundfont *sf,
350 struct snd_sf_zone *zp)
352 zp->counter = sflist->zone_counter++;
353 if (sf->type & SNDRV_SFNT_PAT_LOCKED)
354 sflist->zone_locked = sflist->zone_counter;
358 * allocate a new zone record
360 static struct snd_sf_zone *
361 sf_zone_new(struct snd_sf_list *sflist, struct snd_soundfont *sf)
363 struct snd_sf_zone *zp;
365 if ((zp = kzalloc(sizeof(*zp), GFP_KERNEL)) == NULL)
367 zp->next = sf->zones;
370 init_voice_info(&zp->v);
372 set_zone_counter(sflist, sf, zp);
378 * increment sample counter
381 set_sample_counter(struct snd_sf_list *sflist, struct snd_soundfont *sf,
382 struct snd_sf_sample *sp)
384 sp->counter = sflist->sample_counter++;
385 if (sf->type & SNDRV_SFNT_PAT_LOCKED)
386 sflist->sample_locked = sflist->sample_counter;
390 * allocate a new sample list record
392 static struct snd_sf_sample *
393 sf_sample_new(struct snd_sf_list *sflist, struct snd_soundfont *sf)
395 struct snd_sf_sample *sp;
397 if ((sp = kzalloc(sizeof(*sp), GFP_KERNEL)) == NULL)
400 sp->next = sf->samples;
403 set_sample_counter(sflist, sf, sp);
408 * delete sample list -- this is an exceptional job.
409 * only the last allocated sample can be deleted.
412 sf_sample_delete(struct snd_sf_list *sflist, struct snd_soundfont *sf,
413 struct snd_sf_sample *sp)
415 /* only last sample is accepted */
416 if (sp == sf->samples) {
417 sf->samples = sp->next;
425 load_map(struct snd_sf_list *sflist, const void __user *data, int count)
427 struct snd_sf_zone *zp, *prevp;
428 struct snd_soundfont *sf;
429 struct soundfont_voice_map map;
431 /* get the link info */
432 if (count < (int)sizeof(map))
434 if (copy_from_user(&map, data, sizeof(map)))
437 if (map.map_instr < 0 || map.map_instr >= SF_MAX_INSTRUMENTS)
440 sf = newsf(sflist, SNDRV_SFNT_PAT_TYPE_MAP|SNDRV_SFNT_PAT_SHARED, NULL);
445 for (zp = sf->zones; zp; prevp = zp, zp = zp->next) {
447 zp->instr == map.map_instr &&
448 zp->bank == map.map_bank &&
449 zp->v.low == map.map_key &&
450 zp->v.start == map.src_instr &&
451 zp->v.end == map.src_bank &&
452 zp->v.fixkey == map.src_key) {
453 /* the same mapping is already present */
454 /* relink this record to the link head */
456 prevp->next = zp->next;
457 zp->next = sf->zones;
460 /* update the counter */
461 set_zone_counter(sflist, sf, zp);
466 /* create a new zone */
467 if ((zp = sf_zone_new(sflist, sf)) == NULL)
470 zp->bank = map.map_bank;
471 zp->instr = map.map_instr;
473 if (map.map_key >= 0) {
474 zp->v.low = map.map_key;
475 zp->v.high = map.map_key;
477 zp->v.start = map.src_instr;
478 zp->v.end = map.src_bank;
479 zp->v.fixkey = map.src_key;
480 zp->v.sf_id = sf->id;
482 add_preset(sflist, zp);
488 /* remove the present instrument layers */
490 remove_info(struct snd_sf_list *sflist, struct snd_soundfont *sf,
493 struct snd_sf_zone *prev, *next, *p;
497 for (p = sf->zones; p; p = next) {
500 p->bank == bank && p->instr == instr) {
501 /* remove this layer */
512 rebuild_presets(sflist);
518 * Read an info record from the user buffer and save it on the current
522 load_info(struct snd_sf_list *sflist, const void __user *data, long count)
524 struct snd_soundfont *sf;
525 struct snd_sf_zone *zone;
526 struct soundfont_voice_rec_hdr hdr;
529 /* patch must be opened */
530 if ((sf = sflist->currsf) == NULL)
533 if (is_special_type(sf->type))
536 if (count < (long)sizeof(hdr)) {
537 printk(KERN_ERR "Soundfont error: invalid patch zone length\n");
540 if (copy_from_user((char*)&hdr, data, sizeof(hdr)))
544 count -= sizeof(hdr);
546 if (hdr.nvoices <= 0 || hdr.nvoices >= 100) {
547 printk(KERN_ERR "Soundfont error: Illegal voice number %d\n",
552 if (count < (long)sizeof(struct soundfont_voice_info) * hdr.nvoices) {
553 printk(KERN_ERR "Soundfont Error: "
554 "patch length(%ld) is smaller than nvoices(%d)\n",
559 switch (hdr.write_mode) {
560 case SNDRV_SFNT_WR_EXCLUSIVE:
561 /* exclusive mode - if the instrument already exists,
563 for (zone = sf->zones; zone; zone = zone->next) {
565 zone->bank == hdr.bank &&
566 zone->instr == hdr.instr)
570 case SNDRV_SFNT_WR_REPLACE:
571 /* replace mode - remove the instrument if it already exists */
572 remove_info(sflist, sf, hdr.bank, hdr.instr);
576 for (i = 0; i < hdr.nvoices; i++) {
577 struct snd_sf_zone tmpzone;
579 /* copy awe_voice_info parameters */
580 if (copy_from_user(&tmpzone.v, data, sizeof(tmpzone.v))) {
584 data += sizeof(tmpzone.v);
585 count -= sizeof(tmpzone.v);
587 tmpzone.bank = hdr.bank;
588 tmpzone.instr = hdr.instr;
590 tmpzone.v.sf_id = sf->id;
591 if (tmpzone.v.mode & SNDRV_SFNT_MODE_INIT_PARM)
592 init_voice_parm(&tmpzone.v.parm);
594 /* create a new zone */
595 if ((zone = sf_zone_new(sflist, sf)) == NULL) {
599 /* copy the temporary data */
600 zone->bank = tmpzone.bank;
601 zone->instr = tmpzone.instr;
604 /* look up the sample */
605 zone->sample = set_sample(sf, &zone->v);
612 /* initialize voice_info record */
614 init_voice_info(struct soundfont_voice_info *avp)
616 memset(avp, 0, sizeof(*avp));
625 avp->amplitude = 127;
626 avp->scaleTuning = 100;
628 init_voice_parm(&avp->parm);
631 /* initialize voice_parm record:
632 * Env1/2: delay=0, attack=0, hold=0, sustain=0, decay=0, release=0.
633 * Vibrato and Tremolo effects are zero.
635 * Chorus and Reverb effects are zero.
638 init_voice_parm(struct soundfont_voice_parm *pp)
640 memset(pp, 0, sizeof(*pp));
642 pp->moddelay = 0x8000;
643 pp->modatkhld = 0x7f7f;
644 pp->moddcysus = 0x7f7f;
645 pp->modrelease = 0x807f;
647 pp->voldelay = 0x8000;
648 pp->volatkhld = 0x7f7f;
649 pp->voldcysus = 0x7f7f;
650 pp->volrelease = 0x807f;
652 pp->lfo1delay = 0x8000;
653 pp->lfo2delay = 0x8000;
658 /* search the specified sample */
659 static struct snd_sf_sample *
660 set_sample(struct snd_soundfont *sf, struct soundfont_voice_info *avp)
662 struct snd_sf_sample *sample;
664 sample = find_sample(sf, avp->sample);
668 /* add in the actual sample offsets:
669 * The voice_info addresses define only the relative offset
670 * from sample pointers. Here we calculate the actual DRAM
671 * offset from sample pointers.
673 avp->start += sample->v.start;
674 avp->end += sample->v.end;
675 avp->loopstart += sample->v.loopstart;
676 avp->loopend += sample->v.loopend;
678 /* copy mode flags */
679 avp->sample_mode = sample->v.mode_flags;
684 /* find the sample pointer with the given id in the soundfont */
685 static struct snd_sf_sample *
686 find_sample(struct snd_soundfont *sf, int sample_id)
688 struct snd_sf_sample *p;
693 for (p = sf->samples; p; p = p->next) {
694 if (p->v.sample == sample_id)
702 * Load sample information, this can include data to be loaded onto
703 * the soundcard. It can also just be a pointer into soundcard ROM.
704 * If there is data it will be written to the soundcard via the callback
708 load_data(struct snd_sf_list *sflist, const void __user *data, long count)
710 struct snd_soundfont *sf;
711 struct soundfont_sample_info sample_info;
712 struct snd_sf_sample *sp;
715 /* patch must be opened */
716 if ((sf = sflist->currsf) == NULL)
719 if (is_special_type(sf->type))
722 if (copy_from_user(&sample_info, data, sizeof(sample_info)))
725 off = sizeof(sample_info);
727 if (sample_info.size != (count-off)/2)
731 if (find_sample(sf, sample_info.sample)) {
732 /* if shared sample, skip this data */
733 if (sf->type & SNDRV_SFNT_PAT_SHARED)
738 /* Allocate a new sample structure */
739 if ((sp = sf_sample_new(sflist, sf)) == NULL)
743 sp->v.sf_id = sf->id;
745 sp->v.truesize = sp->v.size;
748 * If there is wave data then load it.
750 if (sp->v.size > 0) {
752 rc = sflist->callback.sample_new
753 (sflist->callback.private_data, sp, sflist->memhdr,
754 data + off, count - off);
756 sf_sample_delete(sflist, sf, sp);
759 sflist->mem_used += sp->v.truesize;
766 /* log2_tbl[i] = log2(i+128) * 0x10000 */
767 static int log_tbl[129] = {
768 0x70000, 0x702df, 0x705b9, 0x7088e, 0x70b5d, 0x70e26, 0x710eb, 0x713aa,
769 0x71663, 0x71918, 0x71bc8, 0x71e72, 0x72118, 0x723b9, 0x72655, 0x728ed,
770 0x72b80, 0x72e0e, 0x73098, 0x7331d, 0x7359e, 0x7381b, 0x73a93, 0x73d08,
771 0x73f78, 0x741e4, 0x7444c, 0x746b0, 0x74910, 0x74b6c, 0x74dc4, 0x75019,
772 0x75269, 0x754b6, 0x75700, 0x75946, 0x75b88, 0x75dc7, 0x76002, 0x7623a,
773 0x7646e, 0x766a0, 0x768cd, 0x76af8, 0x76d1f, 0x76f43, 0x77164, 0x77382,
774 0x7759d, 0x777b4, 0x779c9, 0x77bdb, 0x77dea, 0x77ff5, 0x781fe, 0x78404,
775 0x78608, 0x78808, 0x78a06, 0x78c01, 0x78df9, 0x78fef, 0x791e2, 0x793d2,
776 0x795c0, 0x797ab, 0x79993, 0x79b79, 0x79d5d, 0x79f3e, 0x7a11d, 0x7a2f9,
777 0x7a4d3, 0x7a6ab, 0x7a880, 0x7aa53, 0x7ac24, 0x7adf2, 0x7afbe, 0x7b188,
778 0x7b350, 0x7b515, 0x7b6d8, 0x7b899, 0x7ba58, 0x7bc15, 0x7bdd0, 0x7bf89,
779 0x7c140, 0x7c2f5, 0x7c4a7, 0x7c658, 0x7c807, 0x7c9b3, 0x7cb5e, 0x7cd07,
780 0x7ceae, 0x7d053, 0x7d1f7, 0x7d398, 0x7d538, 0x7d6d6, 0x7d872, 0x7da0c,
781 0x7dba4, 0x7dd3b, 0x7ded0, 0x7e063, 0x7e1f4, 0x7e384, 0x7e512, 0x7e69f,
782 0x7e829, 0x7e9b3, 0x7eb3a, 0x7ecc0, 0x7ee44, 0x7efc7, 0x7f148, 0x7f2c8,
783 0x7f446, 0x7f5c2, 0x7f73d, 0x7f8b7, 0x7fa2f, 0x7fba5, 0x7fd1a, 0x7fe8d,
787 /* convert from linear to log value
789 * conversion: value = log2(amount / base) * ratio
792 * amount = linear value (unsigned, 32bit max)
793 * offset = base offset (:= log2(base) * 0x10000)
794 * ratio = division ratio
798 snd_sf_linear_to_log(unsigned int amount, int offset, int ratio)
805 for (bit = 0; ! (amount & 0x80000000L); bit++)
807 s = (amount >> 24) & 0x7f;
808 low = (amount >> 16) & 0xff;
809 /* linear approxmimation by lower 8 bit */
810 v = (log_tbl[s + 1] * low + log_tbl[s] * (0x100 - low)) >> 8;
812 v = (v * ratio) >> 16;
813 v += (24 - bit) * ratio;
817 EXPORT_SYMBOL(snd_sf_linear_to_log);
820 #define OFFSET_MSEC 653117 /* base = 1000 */
821 #define OFFSET_ABSCENT 851781 /* base = 8176 */
822 #define OFFSET_SAMPLERATE 1011119 /* base = 44100 */
824 #define ABSCENT_RATIO 1200
825 #define TIMECENT_RATIO 1200
826 #define SAMPLERATE_RATIO 4096
830 * conversion: abscent = log2(MHz / 8176) * 1200
833 freq_to_note(int mhz)
835 return snd_sf_linear_to_log(mhz, OFFSET_ABSCENT, ABSCENT_RATIO);
838 /* convert Hz to AWE32 rate offset:
839 * sample pitch offset for the specified sample rate
840 * rate=44100 is no offset, each 4096 is 1 octave (twice).
841 * eg, when rate is 22050, this offset becomes -4096.
843 * conversion: offset = log2(Hz / 44100) * 4096
846 calc_rate_offset(int hz)
848 return snd_sf_linear_to_log(hz, OFFSET_SAMPLERATE, SAMPLERATE_RATIO);
852 /* calculate GUS envelope time */
854 calc_gus_envelope_time(int rate, int start, int end)
857 r = (3 - ((rate >> 6) & 3)) * 3;
867 return (t * 10) / (p * 441);
870 /* convert envelope time parameter to soundfont parameters */
872 /* attack & decay/release time table (msec) */
873 static short attack_time_tbl[128] = {
874 32767, 32767, 5989, 4235, 2994, 2518, 2117, 1780, 1497, 1373, 1259, 1154, 1058, 970, 890, 816,
875 707, 691, 662, 634, 607, 581, 557, 533, 510, 489, 468, 448, 429, 411, 393, 377,
876 361, 345, 331, 317, 303, 290, 278, 266, 255, 244, 234, 224, 214, 205, 196, 188,
877 180, 172, 165, 158, 151, 145, 139, 133, 127, 122, 117, 112, 107, 102, 98, 94,
878 90, 86, 82, 79, 75, 72, 69, 66, 63, 61, 58, 56, 53, 51, 49, 47,
879 45, 43, 41, 39, 37, 36, 34, 33, 31, 30, 29, 28, 26, 25, 24, 23,
880 22, 21, 20, 19, 19, 18, 17, 16, 16, 15, 15, 14, 13, 13, 12, 12,
881 11, 11, 10, 10, 10, 9, 9, 8, 8, 8, 8, 7, 7, 7, 6, 0,
884 static short decay_time_tbl[128] = {
885 32767, 32767, 22614, 15990, 11307, 9508, 7995, 6723, 5653, 5184, 4754, 4359, 3997, 3665, 3361, 3082,
886 2828, 2765, 2648, 2535, 2428, 2325, 2226, 2132, 2042, 1955, 1872, 1793, 1717, 1644, 1574, 1507,
887 1443, 1382, 1324, 1267, 1214, 1162, 1113, 1066, 978, 936, 897, 859, 822, 787, 754, 722,
888 691, 662, 634, 607, 581, 557, 533, 510, 489, 468, 448, 429, 411, 393, 377, 361,
889 345, 331, 317, 303, 290, 278, 266, 255, 244, 234, 224, 214, 205, 196, 188, 180,
890 172, 165, 158, 151, 145, 139, 133, 127, 122, 117, 112, 107, 102, 98, 94, 90,
891 86, 82, 79, 75, 72, 69, 66, 63, 61, 58, 56, 53, 51, 49, 47, 45,
892 43, 41, 39, 37, 36, 34, 33, 31, 30, 29, 28, 26, 25, 24, 23, 22,
895 /* delay time = 0x8000 - msec/92 */
897 snd_sf_calc_parm_hold(int msec)
899 int val = (0x7f * 92 - msec) / 92;
900 if (val < 1) val = 1;
901 if (val >= 126) val = 126;
905 /* search an index for specified time from given time table */
907 calc_parm_search(int msec, short *table)
909 int left = 1, right = 127, mid;
910 while (left < right) {
911 mid = (left + right) / 2;
912 if (msec < (int)table[mid])
920 /* attack time: search from time table */
922 snd_sf_calc_parm_attack(int msec)
924 return calc_parm_search(msec, attack_time_tbl);
927 /* decay/release time: search from time table */
929 snd_sf_calc_parm_decay(int msec)
931 return calc_parm_search(msec, decay_time_tbl);
934 int snd_sf_vol_table[128] = {
935 255,111,95,86,79,74,70,66,63,61,58,56,54,52,50,49,
936 47,46,45,43,42,41,40,39,38,37,36,35,34,34,33,32,
937 31,31,30,29,29,28,27,27,26,26,25,24,24,23,23,22,
938 22,21,21,21,20,20,19,19,18,18,18,17,17,16,16,16,
939 15,15,15,14,14,14,13,13,13,12,12,12,11,11,11,10,
940 10,10,10,9,9,9,8,8,8,8,7,7,7,7,6,6,
941 6,6,5,5,5,5,5,4,4,4,4,3,3,3,3,3,
942 2,2,2,2,2,1,1,1,1,1,0,0,0,0,0,0,
946 #define calc_gus_sustain(val) (0x7f - snd_sf_vol_table[(val)/2])
947 #define calc_gus_attenuation(val) snd_sf_vol_table[(val)/2]
951 load_guspatch(struct snd_sf_list *sflist, const char __user *data,
952 long count, int client)
954 struct patch_info patch;
955 struct snd_soundfont *sf;
956 struct snd_sf_zone *zone;
957 struct snd_sf_sample *smp;
961 if (count < (long)sizeof(patch)) {
962 snd_printk(KERN_ERR "patch record too small %ld\n", count);
965 if (copy_from_user(&patch, data, sizeof(patch)))
968 count -= sizeof(patch);
969 data += sizeof(patch);
971 sf = newsf(sflist, SNDRV_SFNT_PAT_TYPE_GUS|SNDRV_SFNT_PAT_SHARED, NULL);
974 if ((smp = sf_sample_new(sflist, sf)) == NULL)
976 sample_id = sflist->sample_counter;
977 smp->v.sample = sample_id;
979 smp->v.end = patch.len;
980 smp->v.loopstart = patch.loop_start;
981 smp->v.loopend = patch.loop_end;
982 smp->v.size = patch.len;
984 /* set up mode flags */
985 smp->v.mode_flags = 0;
986 if (!(patch.mode & WAVE_16_BITS))
987 smp->v.mode_flags |= SNDRV_SFNT_SAMPLE_8BITS;
988 if (patch.mode & WAVE_UNSIGNED)
989 smp->v.mode_flags |= SNDRV_SFNT_SAMPLE_UNSIGNED;
990 smp->v.mode_flags |= SNDRV_SFNT_SAMPLE_NO_BLANK;
991 if (!(patch.mode & (WAVE_LOOPING|WAVE_BIDIR_LOOP|WAVE_LOOP_BACK)))
992 smp->v.mode_flags |= SNDRV_SFNT_SAMPLE_SINGLESHOT;
993 if (patch.mode & WAVE_BIDIR_LOOP)
994 smp->v.mode_flags |= SNDRV_SFNT_SAMPLE_BIDIR_LOOP;
995 if (patch.mode & WAVE_LOOP_BACK)
996 smp->v.mode_flags |= SNDRV_SFNT_SAMPLE_REVERSE_LOOP;
998 if (patch.mode & WAVE_16_BITS) {
999 /* convert to word offsets */
1002 smp->v.loopstart /= 2;
1003 smp->v.loopend /= 2;
1005 /*smp->v.loopend++;*/
1008 smp->v.truesize = 0;
1009 smp->v.sf_id = sf->id;
1011 /* set up voice info */
1012 if ((zone = sf_zone_new(sflist, sf)) == NULL) {
1013 sf_sample_delete(sflist, sf, smp);
1020 if (sflist->callback.sample_new) {
1021 rc = sflist->callback.sample_new
1022 (sflist->callback.private_data, smp, sflist->memhdr,
1025 sf_sample_delete(sflist, sf, smp);
1029 /* memory offset is updated after */
1032 /* update the memory offset here */
1033 sflist->mem_used += smp->v.truesize;
1035 zone->v.sample = sample_id; /* the last sample */
1036 zone->v.rate_offset = calc_rate_offset(patch.base_freq);
1037 note = freq_to_note(patch.base_note);
1038 zone->v.root = note / 100;
1039 zone->v.tune = -(note % 100);
1040 zone->v.low = (freq_to_note(patch.low_note) + 99) / 100;
1041 zone->v.high = freq_to_note(patch.high_note) / 100;
1042 /* panning position; -128 - 127 => 0-127 */
1043 zone->v.pan = (patch.panning + 128) / 2;
1045 snd_printk(KERN_DEBUG
1046 "gus: basefrq=%d (ofs=%d) root=%d,tune=%d, range:%d-%d\n",
1047 (int)patch.base_freq, zone->v.rate_offset,
1048 zone->v.root, zone->v.tune, zone->v.low, zone->v.high);
1051 /* detuning is ignored */
1052 /* 6points volume envelope */
1053 if (patch.mode & WAVE_ENVELOPES) {
1054 int attack, hold, decay, release;
1055 attack = calc_gus_envelope_time
1056 (patch.env_rate[0], 0, patch.env_offset[0]);
1057 hold = calc_gus_envelope_time
1058 (patch.env_rate[1], patch.env_offset[0],
1059 patch.env_offset[1]);
1060 decay = calc_gus_envelope_time
1061 (patch.env_rate[2], patch.env_offset[1],
1062 patch.env_offset[2]);
1063 release = calc_gus_envelope_time
1064 (patch.env_rate[3], patch.env_offset[1],
1065 patch.env_offset[4]);
1066 release += calc_gus_envelope_time
1067 (patch.env_rate[4], patch.env_offset[3],
1068 patch.env_offset[4]);
1069 release += calc_gus_envelope_time
1070 (patch.env_rate[5], patch.env_offset[4],
1071 patch.env_offset[5]);
1072 zone->v.parm.volatkhld =
1073 (snd_sf_calc_parm_hold(hold) << 8) |
1074 snd_sf_calc_parm_attack(attack);
1075 zone->v.parm.voldcysus = (calc_gus_sustain(patch.env_offset[2]) << 8) |
1076 snd_sf_calc_parm_decay(decay);
1077 zone->v.parm.volrelease = 0x8000 | snd_sf_calc_parm_decay(release);
1078 zone->v.attenuation = calc_gus_attenuation(patch.env_offset[0]);
1080 snd_printk(KERN_DEBUG
1081 "gus: atkhld=%x, dcysus=%x, volrel=%x, att=%d\n",
1082 zone->v.parm.volatkhld,
1083 zone->v.parm.voldcysus,
1084 zone->v.parm.volrelease,
1085 zone->v.attenuation);
1090 if (patch.mode & WAVE_FAST_RELEASE) {
1091 zone->v.parm.volrelease = 0x807f;
1094 /* tremolo effect */
1095 if (patch.mode & WAVE_TREMOLO) {
1096 int rate = (patch.tremolo_rate * 1000 / 38) / 42;
1097 zone->v.parm.tremfrq = ((patch.tremolo_depth / 2) << 8) | rate;
1099 /* vibrato effect */
1100 if (patch.mode & WAVE_VIBRATO) {
1101 int rate = (patch.vibrato_rate * 1000 / 38) / 42;
1102 zone->v.parm.fm2frq2 = ((patch.vibrato_depth / 6) << 8) | rate;
1105 /* scale_freq, scale_factor, volume, and fractions not implemented */
1107 if (!(smp->v.mode_flags & SNDRV_SFNT_SAMPLE_SINGLESHOT))
1108 zone->v.mode = SNDRV_SFNT_MODE_LOOPING;
1112 /* append to the tail of the list */
1113 /*zone->bank = ctrls[AWE_MD_GUS_BANK];*/
1115 zone->instr = patch.instr_no;
1117 zone->v.sf_id = sf->id;
1119 zone->sample = set_sample(sf, &zone->v);
1121 /* rebuild preset now */
1122 add_preset(sflist, zone);
1127 /* load GUS patch */
1129 snd_soundfont_load_guspatch(struct snd_sf_list *sflist, const char __user *data,
1130 long count, int client)
1133 lock_preset(sflist);
1134 rc = load_guspatch(sflist, data, count, client);
1135 unlock_preset(sflist);
1141 * Rebuild the preset table. This is like a hash table in that it allows
1142 * quick access to the zone information. For each preset there are zone
1143 * structures linked by next_instr and by next_zone. Former is the whole
1144 * link for this preset, and latter is the link for zone (i.e. instrument/
1145 * bank/key combination).
1148 rebuild_presets(struct snd_sf_list *sflist)
1150 struct snd_soundfont *sf;
1151 struct snd_sf_zone *cur;
1153 /* clear preset table */
1154 memset(sflist->presets, 0, sizeof(sflist->presets));
1156 /* search all fonts and insert each font */
1157 for (sf = sflist->fonts; sf; sf = sf->next) {
1158 for (cur = sf->zones; cur; cur = cur->next) {
1159 if (! cur->mapped && cur->sample == NULL) {
1160 /* try again to search the corresponding sample */
1161 cur->sample = set_sample(sf, &cur->v);
1162 if (cur->sample == NULL)
1166 add_preset(sflist, cur);
1173 * add the given zone to preset table
1176 add_preset(struct snd_sf_list *sflist, struct snd_sf_zone *cur)
1178 struct snd_sf_zone *zone;
1181 zone = search_first_zone(sflist, cur->bank, cur->instr, cur->v.low);
1182 if (zone && zone->v.sf_id != cur->v.sf_id) {
1183 /* different instrument was already defined */
1184 struct snd_sf_zone *p;
1185 /* compare the allocated time */
1186 for (p = zone; p; p = p->next_zone) {
1187 if (p->counter > cur->counter)
1188 /* the current is older.. skipped */
1191 /* remove old zones */
1192 delete_preset(sflist, zone);
1193 zone = NULL; /* do not forget to clear this! */
1196 /* prepend this zone */
1197 if ((index = get_index(cur->bank, cur->instr, cur->v.low)) < 0)
1199 cur->next_zone = zone; /* zone link */
1200 cur->next_instr = sflist->presets[index]; /* preset table link */
1201 sflist->presets[index] = cur;
1205 * delete the given zones from preset_table
1208 delete_preset(struct snd_sf_list *sflist, struct snd_sf_zone *zp)
1211 struct snd_sf_zone *p;
1213 if ((index = get_index(zp->bank, zp->instr, zp->v.low)) < 0)
1215 for (p = sflist->presets[index]; p; p = p->next_instr) {
1216 while (p->next_instr == zp) {
1217 p->next_instr = zp->next_instr;
1227 * Search matching zones from preset table.
1228 * The note can be rewritten by preset mapping (alias).
1229 * The found zones are stored on 'table' array. max_layers defines
1230 * the maximum number of elements in this array.
1231 * This function returns the number of found zones. 0 if not found.
1234 snd_soundfont_search_zone(struct snd_sf_list *sflist, int *notep, int vel,
1235 int preset, int bank,
1236 int def_preset, int def_bank,
1237 struct snd_sf_zone **table, int max_layers)
1240 unsigned long flags;
1242 /* this function is supposed to be called atomically,
1243 * so we check the lock. if it's busy, just returns 0 to
1244 * tell the caller the busy state
1246 spin_lock_irqsave(&sflist->lock, flags);
1247 if (sflist->presets_locked) {
1248 spin_unlock_irqrestore(&sflist->lock, flags);
1251 nvoices = search_zones(sflist, notep, vel, preset, bank,
1252 table, max_layers, 0);
1254 if (preset != def_preset || bank != def_bank)
1255 nvoices = search_zones(sflist, notep, vel,
1256 def_preset, def_bank,
1257 table, max_layers, 0);
1259 spin_unlock_irqrestore(&sflist->lock, flags);
1265 * search the first matching zone
1267 static struct snd_sf_zone *
1268 search_first_zone(struct snd_sf_list *sflist, int bank, int preset, int key)
1271 struct snd_sf_zone *zp;
1273 if ((index = get_index(bank, preset, key)) < 0)
1275 for (zp = sflist->presets[index]; zp; zp = zp->next_instr) {
1276 if (zp->instr == preset && zp->bank == bank)
1284 * search matching zones from sflist. can be called recursively.
1287 search_zones(struct snd_sf_list *sflist, int *notep, int vel,
1288 int preset, int bank, struct snd_sf_zone **table,
1289 int max_layers, int level)
1291 struct snd_sf_zone *zp;
1294 zp = search_first_zone(sflist, bank, preset, *notep);
1296 for (; zp; zp = zp->next_zone) {
1297 if (*notep >= zp->v.low && *notep <= zp->v.high &&
1298 vel >= zp->v.vellow && vel <= zp->v.velhigh) {
1300 /* search preset mapping (aliasing) */
1301 int key = zp->v.fixkey;
1302 preset = zp->v.start;
1305 if (level > 5) /* too deep alias level */
1309 nvoices = search_zones(sflist, &key, vel,
1310 preset, bank, table,
1311 max_layers, level + 1);
1316 table[nvoices++] = zp;
1317 if (nvoices >= max_layers)
1326 /* calculate the index of preset table:
1327 * drums are mapped from 128 to 255 according to its note key.
1328 * other instruments are mapped from 0 to 127.
1329 * if the index is out of range, return -1.
1332 get_index(int bank, int instr, int key)
1335 if (SF_IS_DRUM_BANK(bank))
1336 index = key + SF_MAX_INSTRUMENTS;
1339 index = index % SF_MAX_PRESETS;
1346 * Initialise the sflist structure.
1349 snd_sf_init(struct snd_sf_list *sflist)
1351 memset(sflist->presets, 0, sizeof(sflist->presets));
1353 sflist->mem_used = 0;
1354 sflist->currsf = NULL;
1355 sflist->open_client = -1;
1356 sflist->fonts = NULL;
1357 sflist->fonts_size = 0;
1358 sflist->zone_counter = 0;
1359 sflist->sample_counter = 0;
1360 sflist->zone_locked = 0;
1361 sflist->sample_locked = 0;
1365 * Release all list records
1368 snd_sf_clear(struct snd_sf_list *sflist)
1370 struct snd_soundfont *sf, *nextsf;
1371 struct snd_sf_zone *zp, *nextzp;
1372 struct snd_sf_sample *sp, *nextsp;
1374 for (sf = sflist->fonts; sf; sf = nextsf) {
1376 for (zp = sf->zones; zp; zp = nextzp) {
1380 for (sp = sf->samples; sp; sp = nextsp) {
1382 if (sflist->callback.sample_free)
1383 sflist->callback.sample_free(sflist->callback.private_data,
1384 sp, sflist->memhdr);
1390 snd_sf_init(sflist);
1395 * Create a new sflist structure
1397 struct snd_sf_list *
1398 snd_sf_new(struct snd_sf_callback *callback, struct snd_util_memhdr *hdr)
1400 struct snd_sf_list *sflist;
1402 if ((sflist = kzalloc(sizeof(*sflist), GFP_KERNEL)) == NULL)
1405 mutex_init(&sflist->presets_mutex);
1406 spin_lock_init(&sflist->lock);
1407 sflist->memhdr = hdr;
1410 sflist->callback = *callback;
1412 snd_sf_init(sflist);
1418 * Free everything allocated off the sflist structure.
1421 snd_sf_free(struct snd_sf_list *sflist)
1426 lock_preset(sflist);
1427 if (sflist->callback.sample_reset)
1428 sflist->callback.sample_reset(sflist->callback.private_data);
1429 snd_sf_clear(sflist);
1430 unlock_preset(sflist);
1436 * Remove all samples
1437 * The soundcard should be silet before calling this function.
1440 snd_soundfont_remove_samples(struct snd_sf_list *sflist)
1442 lock_preset(sflist);
1443 if (sflist->callback.sample_reset)
1444 sflist->callback.sample_reset(sflist->callback.private_data);
1445 snd_sf_clear(sflist);
1446 unlock_preset(sflist);
1452 * Remove unlocked samples.
1453 * The soundcard should be silent before calling this function.
1456 snd_soundfont_remove_unlocked(struct snd_sf_list *sflist)
1458 struct snd_soundfont *sf;
1459 struct snd_sf_zone *zp, *nextzp;
1460 struct snd_sf_sample *sp, *nextsp;
1462 lock_preset(sflist);
1464 if (sflist->callback.sample_reset)
1465 sflist->callback.sample_reset(sflist->callback.private_data);
1468 memset(sflist->presets, 0, sizeof(sflist->presets));
1470 for (sf = sflist->fonts; sf; sf = sf->next) {
1471 for (zp = sf->zones; zp; zp = nextzp) {
1472 if (zp->counter < sflist->zone_locked)
1479 for (sp = sf->samples; sp; sp = nextsp) {
1480 if (sp->counter < sflist->sample_locked)
1483 sf->samples = nextsp;
1484 sflist->mem_used -= sp->v.truesize;
1485 if (sflist->callback.sample_free)
1486 sflist->callback.sample_free(sflist->callback.private_data,
1487 sp, sflist->memhdr);
1492 sflist->zone_counter = sflist->zone_locked;
1493 sflist->sample_counter = sflist->sample_locked;
1495 rebuild_presets(sflist);
1497 unlock_preset(sflist);