d0925ea50838d2b6497bc3dc399b037587b02d33
[linux-3.10.git] / sound / synth / emux / soundfont.c
1 /*
2  *  Soundfont generic routines.
3  *      It is intended that these should be used by any driver that is willing
4  *      to accept soundfont patches.
5  *
6  *  Copyright (C) 1999 Steve Ratcliffe
7  *  Copyright (c) 1999-2000 Takashi Iwai <tiwai@suse.de>
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  * 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.
27  */
28 #include <sound/driver.h>
29 #include <asm/uaccess.h>
30 #include <linux/slab.h>
31 #include <sound/core.h>
32 #include <sound/soundfont.h>
33 #include <sound/seq_oss_legacy.h>
34
35 /* Prototypes for static functions */
36
37 static int open_patch(snd_sf_list_t *sflist, const char __user *data, int count, int client);
38 static snd_soundfont_t *newsf(snd_sf_list_t *sflist, int type, char *name);
39 static int is_identical_font(snd_soundfont_t *sf, int type, unsigned char *name);
40 static int close_patch(snd_sf_list_t *sflist);
41 static int probe_data(snd_sf_list_t *sflist, int sample_id);
42 static void set_zone_counter(snd_sf_list_t *sflist, snd_soundfont_t *sf, snd_sf_zone_t *zp);
43 static snd_sf_zone_t *sf_zone_new(snd_sf_list_t *sflist, snd_soundfont_t *sf);
44 static void set_sample_counter(snd_sf_list_t *sflist, snd_soundfont_t *sf, snd_sf_sample_t *sp);
45 static snd_sf_sample_t *sf_sample_new(snd_sf_list_t *sflist, snd_soundfont_t *sf);
46 static void sf_sample_delete(snd_sf_list_t *sflist, snd_soundfont_t *sf, snd_sf_sample_t *sp);
47 static int load_map(snd_sf_list_t *sflist, const void __user *data, int count);
48 static int load_info(snd_sf_list_t *sflist, const void __user *data, long count);
49 static int remove_info(snd_sf_list_t *sflist, snd_soundfont_t *sf, int bank, int instr);
50 static void init_voice_info(soundfont_voice_info_t *avp);
51 static void init_voice_parm(soundfont_voice_parm_t *pp);
52 static snd_sf_sample_t *set_sample(snd_soundfont_t *sf, soundfont_voice_info_t *avp);
53 static snd_sf_sample_t *find_sample(snd_soundfont_t *sf, int sample_id);
54 static int load_data(snd_sf_list_t *sflist, const void __user *data, long count);
55 static void rebuild_presets(snd_sf_list_t *sflist);
56 static void add_preset(snd_sf_list_t *sflist, snd_sf_zone_t *cur);
57 static void delete_preset(snd_sf_list_t *sflist, snd_sf_zone_t *zp);
58 static snd_sf_zone_t *search_first_zone(snd_sf_list_t *sflist, int bank, int preset, int key);
59 static int search_zones(snd_sf_list_t *sflist, int *notep, int vel, int preset, int bank, snd_sf_zone_t **table, int max_layers, int level);
60 static int get_index(int bank, int instr, int key);
61 static void snd_sf_init(snd_sf_list_t *sflist);
62 static void snd_sf_clear(snd_sf_list_t *sflist);
63
64 /*
65  * lock access to sflist
66  */
67 static void
68 lock_preset(snd_sf_list_t *sflist)
69 {
70         unsigned long flags;
71         down(&sflist->presets_mutex);
72         spin_lock_irqsave(&sflist->lock, flags);
73         sflist->presets_locked = 1;
74         spin_unlock_irqrestore(&sflist->lock, flags);
75 }
76
77
78 /*
79  * remove lock
80  */
81 static void
82 unlock_preset(snd_sf_list_t *sflist)
83 {
84         unsigned long flags;
85         spin_lock_irqsave(&sflist->lock, flags);
86         sflist->presets_locked = 0;
87         spin_unlock_irqrestore(&sflist->lock, flags);
88         up(&sflist->presets_mutex);
89 }
90
91
92 /*
93  * close the patch if the patch was opened by this client.
94  */
95 int
96 snd_soundfont_close_check(snd_sf_list_t *sflist, int client)
97 {
98         unsigned long flags;
99         spin_lock_irqsave(&sflist->lock, flags);
100         if (sflist->open_client == client)  {
101                 spin_unlock_irqrestore(&sflist->lock, flags);
102                 return close_patch(sflist);
103         }
104         spin_unlock_irqrestore(&sflist->lock, flags);
105         return 0;
106 }
107
108
109 /*
110  * Deal with a soundfont patch.  Any driver could use these routines
111  * although it was designed for the AWE64.
112  *
113  * The sample_write and callargs pararameters allow a callback into
114  * the actual driver to write sample data to the board or whatever
115  * it wants to do with it.
116  */
117 int
118 snd_soundfont_load(snd_sf_list_t *sflist, const void __user *data, long count, int client)
119 {
120         soundfont_patch_info_t patch;
121         unsigned long flags;
122         int  rc;
123
124         if (count < (long)sizeof(patch)) {
125                 snd_printk("patch record too small %ld\n", count);
126                 return -EINVAL;
127         }
128         if (copy_from_user(&patch, data, sizeof(patch)))
129                 return -EFAULT;
130
131         count -= sizeof(patch);
132         data += sizeof(patch);
133
134         if (patch.key != SNDRV_OSS_SOUNDFONT_PATCH) {
135                 snd_printk("'The wrong kind of patch' %x\n", patch.key);
136                 return -EINVAL;
137         }
138         if (count < patch.len) {
139                 snd_printk("Patch too short %ld, need %d\n", count, patch.len);
140                 return -EINVAL;
141         }
142         if (patch.len < 0) {
143                 snd_printk("poor length %d\n", patch.len);
144                 return -EINVAL;
145         }
146
147         if (patch.type == SNDRV_SFNT_OPEN_PATCH) {
148                 /* grab sflist to open */
149                 lock_preset(sflist);
150                 rc = open_patch(sflist, data, count, client);
151                 unlock_preset(sflist);
152                 return rc;
153         }
154
155         /* check if other client already opened patch */
156         spin_lock_irqsave(&sflist->lock, flags);
157         if (sflist->open_client != client) {
158                 spin_unlock_irqrestore(&sflist->lock, flags);
159                 return -EBUSY;
160         }
161         spin_unlock_irqrestore(&sflist->lock, flags);
162
163         lock_preset(sflist);
164         rc = -EINVAL;
165         switch (patch.type) {
166         case SNDRV_SFNT_LOAD_INFO:
167                 rc = load_info(sflist, data, count);
168                 break;
169         case SNDRV_SFNT_LOAD_DATA:
170                 rc = load_data(sflist, data, count);
171                 break;
172         case SNDRV_SFNT_CLOSE_PATCH:
173                 rc = close_patch(sflist);
174                 break;
175         case SNDRV_SFNT_REPLACE_DATA:
176                 /*rc = replace_data(&patch, data, count);*/
177                 break;
178         case SNDRV_SFNT_MAP_PRESET:
179                 rc = load_map(sflist, data, count);
180                 break;
181         case SNDRV_SFNT_PROBE_DATA:
182                 rc = probe_data(sflist, patch.optarg);
183                 break;
184         case SNDRV_SFNT_REMOVE_INFO:
185                 /* patch must be opened */
186                 if (sflist->currsf) {
187                         snd_printk("soundfont: remove_info: patch not opened\n");
188                         rc = -EINVAL;
189                 } else {
190                         int bank, instr;
191                         bank = ((unsigned short)patch.optarg >> 8) & 0xff;
192                         instr = (unsigned short)patch.optarg & 0xff;
193                         if (! remove_info(sflist, sflist->currsf, bank, instr))
194                                 rc = -EINVAL;
195                         else
196                                 rc = 0;
197                 }
198                 break;
199         }
200         unlock_preset(sflist);
201
202         return rc;
203 }
204
205
206 /* check if specified type is special font (GUS or preset-alias) */
207 static inline int
208 is_special_type(int type)
209 {
210         type &= 0x0f;
211         return (type == SNDRV_SFNT_PAT_TYPE_GUS ||
212                 type == SNDRV_SFNT_PAT_TYPE_MAP);
213 }
214
215
216 /* open patch; create sf list */
217 static int
218 open_patch(snd_sf_list_t *sflist, const char __user *data, int count, int client)
219 {
220         soundfont_open_parm_t parm;
221         snd_soundfont_t *sf;
222         unsigned long flags;
223
224         spin_lock_irqsave(&sflist->lock, flags);
225         if (sflist->open_client >= 0 || sflist->currsf) {
226                 spin_unlock_irqrestore(&sflist->lock, flags);
227                 return -EBUSY;
228         }
229         spin_unlock_irqrestore(&sflist->lock, flags);
230
231         if (copy_from_user(&parm, data, sizeof(parm)))
232                 return -EFAULT;
233
234         if (is_special_type(parm.type)) {
235                 parm.type |= SNDRV_SFNT_PAT_SHARED;
236                 sf = newsf(sflist, parm.type, NULL);
237         } else 
238                 sf = newsf(sflist, parm.type, parm.name);
239         if (sf == NULL) {
240                 return -ENOMEM;
241         }
242
243         spin_lock_irqsave(&sflist->lock, flags);
244         sflist->open_client = client;
245         sflist->currsf = sf;
246         spin_unlock_irqrestore(&sflist->lock, flags);
247
248         return 0;
249 }
250
251 /*
252  * Allocate a new soundfont structure.
253  */
254 static snd_soundfont_t *
255 newsf(snd_sf_list_t *sflist, int type, char *name)
256 {
257         snd_soundfont_t *sf;
258
259         /* check the shared fonts */
260         if (type & SNDRV_SFNT_PAT_SHARED) {
261                 for (sf = sflist->fonts; sf; sf = sf->next) {
262                         if (is_identical_font(sf, type, name)) {
263                                 return sf;
264                         }
265                 }
266         }
267
268         /* not found -- create a new one */
269         sf = kzalloc(sizeof(*sf), GFP_KERNEL);
270         if (sf == NULL)
271                 return NULL;
272         sf->id = sflist->fonts_size;
273         sflist->fonts_size++;
274
275         /* prepend this record */
276         sf->next = sflist->fonts;
277         sflist->fonts = sf;
278
279         sf->type = type;
280         sf->zones = NULL;
281         sf->samples = NULL;
282         if (name)
283                 memcpy(sf->name, name, SNDRV_SFNT_PATCH_NAME_LEN);
284
285         return sf;
286 }
287
288 /* check if the given name matches to the existing list */
289 static int
290 is_identical_font(snd_soundfont_t *sf, int type, unsigned char *name)
291 {
292         return ((sf->type & SNDRV_SFNT_PAT_SHARED) &&
293                 (sf->type & 0x0f) == (type & 0x0f) &&
294                 (name == NULL ||
295                  memcmp(sf->name, name, SNDRV_SFNT_PATCH_NAME_LEN) == 0));
296 }
297
298 /*
299  * Close the current patch.
300  */
301 static int
302 close_patch(snd_sf_list_t *sflist)
303 {
304         unsigned long flags;
305
306         spin_lock_irqsave(&sflist->lock, flags);
307         sflist->currsf = NULL;
308         sflist->open_client = -1;
309         spin_unlock_irqrestore(&sflist->lock, flags);
310
311         rebuild_presets(sflist);
312
313         return 0;
314
315 }
316
317 /* probe sample in the current list -- nothing to be loaded */
318 static int
319 probe_data(snd_sf_list_t *sflist, int sample_id)
320 {
321         /* patch must be opened */
322         if (sflist->currsf) {
323                 /* search the specified sample by optarg */
324                 if (find_sample(sflist->currsf, sample_id))
325                         return 0;
326         }
327         return -EINVAL;
328 }
329
330 /*
331  * increment zone counter
332  */
333 static void
334 set_zone_counter(snd_sf_list_t *sflist, snd_soundfont_t *sf, snd_sf_zone_t *zp)
335 {
336         zp->counter = sflist->zone_counter++;
337         if (sf->type & SNDRV_SFNT_PAT_LOCKED)
338                 sflist->zone_locked = sflist->zone_counter;
339 }
340
341 /*
342  * allocate a new zone record
343  */
344 static snd_sf_zone_t *
345 sf_zone_new(snd_sf_list_t *sflist, snd_soundfont_t *sf)
346 {
347         snd_sf_zone_t *zp;
348
349         if ((zp = kzalloc(sizeof(*zp), GFP_KERNEL)) == NULL)
350                 return NULL;
351         zp->next = sf->zones;
352         sf->zones = zp;
353
354         init_voice_info(&zp->v);
355
356         set_zone_counter(sflist, sf, zp);
357         return zp;
358 }
359
360
361 /*
362  * increment sample couter
363  */
364 static void
365 set_sample_counter(snd_sf_list_t *sflist, snd_soundfont_t *sf, snd_sf_sample_t *sp)
366 {
367         sp->counter = sflist->sample_counter++;
368         if (sf->type & SNDRV_SFNT_PAT_LOCKED)
369                 sflist->sample_locked = sflist->sample_counter;
370 }
371
372 /*
373  * allocate a new sample list record
374  */
375 static snd_sf_sample_t *
376 sf_sample_new(snd_sf_list_t *sflist, snd_soundfont_t *sf)
377 {
378         snd_sf_sample_t *sp;
379
380         if ((sp = kzalloc(sizeof(*sp), GFP_KERNEL)) == NULL)
381                 return NULL;
382
383         sp->next = sf->samples;
384         sf->samples = sp;
385
386         set_sample_counter(sflist, sf, sp);
387         return sp;
388 }
389
390 /*
391  * delete sample list -- this is an exceptional job.
392  * only the last allocated sample can be deleted.
393  */
394 static void
395 sf_sample_delete(snd_sf_list_t *sflist, snd_soundfont_t *sf, snd_sf_sample_t *sp)
396 {
397         /* only last sample is accepted */
398         if (sp == sf->samples) {
399                 sf->samples = sp->next;
400                 kfree(sp);
401         }
402 }
403
404
405 /* load voice map */
406 static int
407 load_map(snd_sf_list_t *sflist, const void __user *data, int count)
408 {
409         snd_sf_zone_t *zp, *prevp;
410         snd_soundfont_t *sf;
411         soundfont_voice_map_t map;
412
413         /* get the link info */
414         if (count < (int)sizeof(map))
415                 return -EINVAL;
416         if (copy_from_user(&map, data, sizeof(map)))
417                 return -EFAULT;
418
419         if (map.map_instr < 0 || map.map_instr >= SF_MAX_INSTRUMENTS)
420                 return -EINVAL;
421         
422         sf = newsf(sflist, SNDRV_SFNT_PAT_TYPE_MAP|SNDRV_SFNT_PAT_SHARED, NULL);
423         if (sf == NULL)
424                 return -ENOMEM;
425
426         prevp = NULL;
427         for (zp = sf->zones; zp; prevp = zp, zp = zp->next) {
428                 if (zp->mapped &&
429                     zp->instr == map.map_instr &&
430                     zp->bank == map.map_bank &&
431                     zp->v.low == map.map_key &&
432                     zp->v.start == map.src_instr &&
433                     zp->v.end == map.src_bank &&
434                     zp->v.fixkey == map.src_key) {
435                         /* the same mapping is already present */
436                         /* relink this record to the link head */
437                         if (prevp) {
438                                 prevp->next = zp->next;
439                                 zp->next = sf->zones;
440                                 sf->zones = zp;
441                         }
442                         /* update the counter */
443                         set_zone_counter(sflist, sf, zp);
444                         return 0;
445                 }
446         }
447
448         /* create a new zone */
449         if ((zp = sf_zone_new(sflist, sf)) == NULL)
450                 return -ENOMEM;
451
452         zp->bank = map.map_bank;
453         zp->instr = map.map_instr;
454         zp->mapped = 1;
455         if (map.map_key >= 0) {
456                 zp->v.low = map.map_key;
457                 zp->v.high = map.map_key;
458         }
459         zp->v.start = map.src_instr;
460         zp->v.end = map.src_bank;
461         zp->v.fixkey = map.src_key;
462         zp->v.sf_id = sf->id;
463
464         add_preset(sflist, zp);
465
466         return 0;
467 }
468
469
470 /* remove the present instrument layers */
471 static int
472 remove_info(snd_sf_list_t *sflist, snd_soundfont_t *sf, int bank, int instr)
473 {
474         snd_sf_zone_t *prev, *next, *p;
475         int removed = 0;
476
477         prev = NULL;
478         for (p = sf->zones; p; p = next) {
479                 next = p->next;
480                 if (! p->mapped &&
481                     p->bank == bank && p->instr == instr) {
482                         /* remove this layer */
483                         if (prev)
484                                 prev->next = next;
485                         else
486                                 sf->zones = next;
487                         removed++;
488                         kfree(p);
489                 } else
490                         prev = p;
491         }
492         if (removed)
493                 rebuild_presets(sflist);
494         return removed;
495 }
496
497
498 /*
499  * Read an info record from the user buffer and save it on the current
500  * open soundfont.
501  */
502 static int
503 load_info(snd_sf_list_t *sflist, const void __user *data, long count)
504 {
505         snd_soundfont_t *sf;
506         snd_sf_zone_t *zone;
507         soundfont_voice_rec_hdr_t hdr;
508         int i;
509
510         /* patch must be opened */
511         if ((sf = sflist->currsf) == NULL)
512                 return -EINVAL;
513
514         if (is_special_type(sf->type))
515                 return -EINVAL;
516
517         if (count < (long)sizeof(hdr)) {
518                 printk("Soundfont error: invalid patch zone length\n");
519                 return -EINVAL;
520         }
521         if (copy_from_user((char*)&hdr, data, sizeof(hdr)))
522                 return -EFAULT;
523         
524         data += sizeof(hdr);
525         count -= sizeof(hdr);
526
527         if (hdr.nvoices <= 0 || hdr.nvoices >= 100) {
528                 printk("Soundfont error: Illegal voice number %d\n", hdr.nvoices);
529                 return -EINVAL;
530         }
531
532         if (count < (long)sizeof(soundfont_voice_info_t)*hdr.nvoices) {
533                 printk("Soundfont Error: patch length(%ld) is smaller than nvoices(%d)\n",
534                        count, hdr.nvoices);
535                 return -EINVAL;
536         }
537
538         switch (hdr.write_mode) {
539         case SNDRV_SFNT_WR_EXCLUSIVE:
540                 /* exclusive mode - if the instrument already exists,
541                    return error */
542                 for (zone = sf->zones; zone; zone = zone->next) {
543                         if (!zone->mapped &&
544                             zone->bank == hdr.bank &&
545                             zone->instr == hdr.instr)
546                                 return -EINVAL;
547                 }
548                 break;
549         case SNDRV_SFNT_WR_REPLACE:
550                 /* replace mode - remove the instrument if it already exists */
551                 remove_info(sflist, sf, hdr.bank, hdr.instr);
552                 break;
553         }
554
555         for (i = 0; i < hdr.nvoices; i++) {
556                 snd_sf_zone_t tmpzone;
557
558                 /* copy awe_voice_info parameters */
559                 if (copy_from_user(&tmpzone.v, data, sizeof(tmpzone.v))) {
560                         return -EFAULT;
561                 }
562
563                 data += sizeof(tmpzone.v);
564                 count -= sizeof(tmpzone.v);
565
566                 tmpzone.bank = hdr.bank;
567                 tmpzone.instr = hdr.instr;
568                 tmpzone.mapped = 0;
569                 tmpzone.v.sf_id = sf->id;
570                 if (tmpzone.v.mode & SNDRV_SFNT_MODE_INIT_PARM)
571                         init_voice_parm(&tmpzone.v.parm);
572
573                 /* create a new zone */
574                 if ((zone = sf_zone_new(sflist, sf)) == NULL) {
575                         return -ENOMEM;
576                 }
577
578                 /* copy the temporary data */
579                 zone->bank = tmpzone.bank;
580                 zone->instr = tmpzone.instr;
581                 zone->v = tmpzone.v;
582
583                 /* look up the sample */
584                 zone->sample = set_sample(sf, &zone->v);
585         }
586
587         return 0;
588 }
589
590
591 /* initialize voice_info record */
592 static void
593 init_voice_info(soundfont_voice_info_t *avp)
594 {
595         memset(avp, 0, sizeof(*avp));
596
597         avp->root = 60;
598         avp->high = 127;
599         avp->velhigh = 127;
600         avp->fixkey = -1;
601         avp->fixvel = -1;
602         avp->fixpan = -1;
603         avp->pan = -1;
604         avp->amplitude = 127;
605         avp->scaleTuning = 100;
606
607         init_voice_parm(&avp->parm);
608 }
609
610 /* initialize voice_parm record:
611  * Env1/2: delay=0, attack=0, hold=0, sustain=0, decay=0, release=0.
612  * Vibrato and Tremolo effects are zero.
613  * Cutoff is maximum.
614  * Chorus and Reverb effects are zero.
615  */
616 static void
617 init_voice_parm(soundfont_voice_parm_t *pp)
618 {
619         memset(pp, 0, sizeof(*pp));
620
621         pp->moddelay = 0x8000;
622         pp->modatkhld = 0x7f7f;
623         pp->moddcysus = 0x7f7f;
624         pp->modrelease = 0x807f;
625
626         pp->voldelay = 0x8000;
627         pp->volatkhld = 0x7f7f;
628         pp->voldcysus = 0x7f7f;
629         pp->volrelease = 0x807f;
630
631         pp->lfo1delay = 0x8000;
632         pp->lfo2delay = 0x8000;
633
634         pp->cutoff = 0xff;
635 }       
636
637 /* search the specified sample */
638 static snd_sf_sample_t *
639 set_sample(snd_soundfont_t *sf, soundfont_voice_info_t *avp)
640 {
641         snd_sf_sample_t *sample;
642
643         sample = find_sample(sf, avp->sample);
644         if (sample == NULL)
645                 return NULL;
646
647         /* add in the actual sample offsets:
648          * The voice_info addresses define only the relative offset
649          * from sample pointers.  Here we calculate the actual DRAM
650          * offset from sample pointers.
651          */
652         avp->start += sample->v.start;
653         avp->end += sample->v.end;
654         avp->loopstart += sample->v.loopstart;
655         avp->loopend += sample->v.loopend;
656
657         /* copy mode flags */
658         avp->sample_mode = sample->v.mode_flags;
659
660         return sample;
661 }
662
663 /* find the sample pointer with the given id in the soundfont */
664 static snd_sf_sample_t *
665 find_sample(snd_soundfont_t *sf, int sample_id)
666 {
667         snd_sf_sample_t *p;
668
669         if (sf == NULL)
670                 return NULL;
671
672         for (p = sf->samples; p; p = p->next) {
673                 if (p->v.sample == sample_id)
674                         return p;
675         }
676         return NULL;
677 }
678
679
680 /*
681  * Load sample information, this can include data to be loaded onto
682  * the soundcard.  It can also just be a pointer into soundcard ROM.
683  * If there is data it will be written to the soundcard via the callback
684  * routine.
685  */
686 static int
687 load_data(snd_sf_list_t *sflist, const void __user *data, long count)
688 {
689         snd_soundfont_t *sf;
690         soundfont_sample_info_t sample_info;
691         snd_sf_sample_t *sp;
692         long off;
693
694         /* patch must be opened */
695         if ((sf = sflist->currsf) == NULL)
696                 return -EINVAL;
697
698         if (is_special_type(sf->type))
699                 return -EINVAL;
700
701         if (copy_from_user(&sample_info, data, sizeof(sample_info)))
702                 return -EFAULT;
703
704         off = sizeof(sample_info);
705
706         if (sample_info.size != (count-off)/2)
707                 return -EINVAL;
708
709         /* Check for dup */
710         if (find_sample(sf, sample_info.sample)) {
711                 /* if shared sample, skip this data */
712                 if (sf->type & SNDRV_SFNT_PAT_SHARED)
713                         return 0;
714                 return -EINVAL;
715         }
716
717         /* Allocate a new sample structure */
718         if ((sp = sf_sample_new(sflist, sf)) == NULL)
719                 return -ENOMEM;
720
721         sp->v = sample_info;
722         sp->v.sf_id = sf->id;
723         sp->v.dummy = 0;
724         sp->v.truesize = sp->v.size;
725
726         /*
727          * If there is wave data then load it.
728          */
729         if (sp->v.size > 0) {
730                 int  rc;
731                 rc = sflist->callback.sample_new
732                         (sflist->callback.private_data, sp, sflist->memhdr,
733                          data + off, count - off);
734                 if (rc < 0) {
735                         sf_sample_delete(sflist, sf, sp);
736                         return rc;
737                 }
738                 sflist->mem_used += sp->v.truesize;
739         }
740
741         return count;
742 }
743
744
745 /* log2_tbl[i] = log2(i+128) * 0x10000 */
746 static int log_tbl[129] = {
747         0x70000, 0x702df, 0x705b9, 0x7088e, 0x70b5d, 0x70e26, 0x710eb, 0x713aa,
748         0x71663, 0x71918, 0x71bc8, 0x71e72, 0x72118, 0x723b9, 0x72655, 0x728ed,
749         0x72b80, 0x72e0e, 0x73098, 0x7331d, 0x7359e, 0x7381b, 0x73a93, 0x73d08,
750         0x73f78, 0x741e4, 0x7444c, 0x746b0, 0x74910, 0x74b6c, 0x74dc4, 0x75019,
751         0x75269, 0x754b6, 0x75700, 0x75946, 0x75b88, 0x75dc7, 0x76002, 0x7623a,
752         0x7646e, 0x766a0, 0x768cd, 0x76af8, 0x76d1f, 0x76f43, 0x77164, 0x77382,
753         0x7759d, 0x777b4, 0x779c9, 0x77bdb, 0x77dea, 0x77ff5, 0x781fe, 0x78404,
754         0x78608, 0x78808, 0x78a06, 0x78c01, 0x78df9, 0x78fef, 0x791e2, 0x793d2,
755         0x795c0, 0x797ab, 0x79993, 0x79b79, 0x79d5d, 0x79f3e, 0x7a11d, 0x7a2f9,
756         0x7a4d3, 0x7a6ab, 0x7a880, 0x7aa53, 0x7ac24, 0x7adf2, 0x7afbe, 0x7b188,
757         0x7b350, 0x7b515, 0x7b6d8, 0x7b899, 0x7ba58, 0x7bc15, 0x7bdd0, 0x7bf89,
758         0x7c140, 0x7c2f5, 0x7c4a7, 0x7c658, 0x7c807, 0x7c9b3, 0x7cb5e, 0x7cd07,
759         0x7ceae, 0x7d053, 0x7d1f7, 0x7d398, 0x7d538, 0x7d6d6, 0x7d872, 0x7da0c,
760         0x7dba4, 0x7dd3b, 0x7ded0, 0x7e063, 0x7e1f4, 0x7e384, 0x7e512, 0x7e69f,
761         0x7e829, 0x7e9b3, 0x7eb3a, 0x7ecc0, 0x7ee44, 0x7efc7, 0x7f148, 0x7f2c8,
762         0x7f446, 0x7f5c2, 0x7f73d, 0x7f8b7, 0x7fa2f, 0x7fba5, 0x7fd1a, 0x7fe8d,
763         0x80000,
764 };
765
766 /* convert from linear to log value
767  *
768  * conversion: value = log2(amount / base) * ratio
769  *
770  * argument:
771  *   amount = linear value (unsigned, 32bit max)
772  *   offset = base offset (:= log2(base) * 0x10000)
773  *   ratio = division ratio
774  *
775  */
776 int
777 snd_sf_linear_to_log(unsigned int amount, int offset, int ratio)
778 {
779         int v;
780         int s, low, bit;
781         
782         if (amount < 2)
783                 return 0;
784         for (bit = 0; ! (amount & 0x80000000L); bit++)
785                 amount <<= 1;
786         s = (amount >> 24) & 0x7f;
787         low = (amount >> 16) & 0xff;
788         /* linear approxmimation by lower 8 bit */
789         v = (log_tbl[s + 1] * low + log_tbl[s] * (0x100 - low)) >> 8;
790         v -= offset;
791         v = (v * ratio) >> 16;
792         v += (24 - bit) * ratio;
793         return v;
794 }
795
796 #define OFFSET_MSEC             653117          /* base = 1000 */
797 #define OFFSET_ABSCENT          851781          /* base = 8176 */
798 #define OFFSET_SAMPLERATE       1011119         /* base = 44100 */
799
800 #define ABSCENT_RATIO           1200
801 #define TIMECENT_RATIO          1200
802 #define SAMPLERATE_RATIO        4096
803
804 /*
805  * mHz to abscent
806  * conversion: abscent = log2(MHz / 8176) * 1200
807  */
808 static int
809 freq_to_note(int mhz)
810 {
811         return snd_sf_linear_to_log(mhz, OFFSET_ABSCENT, ABSCENT_RATIO);
812 }
813
814 /* convert Hz to AWE32 rate offset:
815  * sample pitch offset for the specified sample rate
816  * rate=44100 is no offset, each 4096 is 1 octave (twice).
817  * eg, when rate is 22050, this offset becomes -4096.
818  *
819  * conversion: offset = log2(Hz / 44100) * 4096
820  */
821 static int
822 calc_rate_offset(int hz)
823 {
824         return snd_sf_linear_to_log(hz, OFFSET_SAMPLERATE, SAMPLERATE_RATIO);
825 }
826
827
828 /* calculate GUS envelope time */
829 static int
830 calc_gus_envelope_time(int rate, int start, int end)
831 {
832         int r, p, t;
833         r = (3 - ((rate >> 6) & 3)) * 3;
834         p = rate & 0x3f;
835         t = end - start;
836         if (t < 0) t = -t;
837         if (13 > r)
838                 t = t << (13 - r);
839         else
840                 t = t >> (r - 13);
841         return (t * 10) / (p * 441);
842 }
843
844 /* convert envelope time parameter to soundfont parameters */
845
846 /* attack & decay/release time table (msec) */
847 static short attack_time_tbl[128] = {
848 32767, 32767, 5989, 4235, 2994, 2518, 2117, 1780, 1497, 1373, 1259, 1154, 1058, 970, 890, 816,
849 707, 691, 662, 634, 607, 581, 557, 533, 510, 489, 468, 448, 429, 411, 393, 377,
850 361, 345, 331, 317, 303, 290, 278, 266, 255, 244, 234, 224, 214, 205, 196, 188,
851 180, 172, 165, 158, 151, 145, 139, 133, 127, 122, 117, 112, 107, 102, 98, 94,
852 90, 86, 82, 79, 75, 72, 69, 66, 63, 61, 58, 56, 53, 51, 49, 47,
853 45, 43, 41, 39, 37, 36, 34, 33, 31, 30, 29, 28, 26, 25, 24, 23,
854 22, 21, 20, 19, 19, 18, 17, 16, 16, 15, 15, 14, 13, 13, 12, 12,
855 11, 11, 10, 10, 10, 9, 9, 8, 8, 8, 8, 7, 7, 7, 6, 0,
856 };
857
858 static short decay_time_tbl[128] = {
859 32767, 32767, 22614, 15990, 11307, 9508, 7995, 6723, 5653, 5184, 4754, 4359, 3997, 3665, 3361, 3082,
860 2828, 2765, 2648, 2535, 2428, 2325, 2226, 2132, 2042, 1955, 1872, 1793, 1717, 1644, 1574, 1507,
861 1443, 1382, 1324, 1267, 1214, 1162, 1113, 1066, 978, 936, 897, 859, 822, 787, 754, 722,
862 691, 662, 634, 607, 581, 557, 533, 510, 489, 468, 448, 429, 411, 393, 377, 361,
863 345, 331, 317, 303, 290, 278, 266, 255, 244, 234, 224, 214, 205, 196, 188, 180,
864 172, 165, 158, 151, 145, 139, 133, 127, 122, 117, 112, 107, 102, 98, 94, 90,
865 86, 82, 79, 75, 72, 69, 66, 63, 61, 58, 56, 53, 51, 49, 47, 45,
866 43, 41, 39, 37, 36, 34, 33, 31, 30, 29, 28, 26, 25, 24, 23, 22,
867 };
868
869 /* delay time = 0x8000 - msec/92 */
870 int
871 snd_sf_calc_parm_hold(int msec)
872 {
873         int val = (0x7f * 92 - msec) / 92;
874         if (val < 1) val = 1;
875         if (val >= 126) val = 126;
876         return val;
877 }
878
879 /* search an index for specified time from given time table */
880 static int
881 calc_parm_search(int msec, short *table)
882 {
883         int left = 1, right = 127, mid;
884         while (left < right) {
885                 mid = (left + right) / 2;
886                 if (msec < (int)table[mid])
887                         left = mid + 1;
888                 else
889                         right = mid;
890         }
891         return left;
892 }
893
894 /* attack time: search from time table */
895 int
896 snd_sf_calc_parm_attack(int msec)
897 {
898         return calc_parm_search(msec, attack_time_tbl);
899 }
900
901 /* decay/release time: search from time table */
902 int
903 snd_sf_calc_parm_decay(int msec)
904 {
905         return calc_parm_search(msec, decay_time_tbl);
906 }
907
908 int snd_sf_vol_table[128] = {
909         255,111,95,86,79,74,70,66,63,61,58,56,54,52,50,49,
910         47,46,45,43,42,41,40,39,38,37,36,35,34,34,33,32,
911         31,31,30,29,29,28,27,27,26,26,25,24,24,23,23,22,
912         22,21,21,21,20,20,19,19,18,18,18,17,17,16,16,16,
913         15,15,15,14,14,14,13,13,13,12,12,12,11,11,11,10,
914         10,10,10,9,9,9,8,8,8,8,7,7,7,7,6,6,
915         6,6,5,5,5,5,5,4,4,4,4,3,3,3,3,3,
916         2,2,2,2,2,1,1,1,1,1,0,0,0,0,0,0,
917 };
918
919
920 #define calc_gus_sustain(val)  (0x7f - snd_sf_vol_table[(val)/2])
921 #define calc_gus_attenuation(val)       snd_sf_vol_table[(val)/2]
922
923 /* load GUS patch */
924 static int
925 load_guspatch(snd_sf_list_t *sflist, const char __user *data, long count, int client)
926 {
927         struct patch_info patch;
928         snd_soundfont_t *sf;
929         snd_sf_zone_t *zone;
930         snd_sf_sample_t *smp;
931         int note, sample_id;
932         int rc;
933
934         if (count < (long)sizeof(patch)) {
935                 snd_printk("patch record too small %ld\n", count);
936                 return -EINVAL;
937         }
938         if (copy_from_user(&patch, data, sizeof(patch)))
939                 return -EFAULT;
940         
941         count -= sizeof(patch);
942         data += sizeof(patch);
943
944         sf = newsf(sflist, SNDRV_SFNT_PAT_TYPE_GUS|SNDRV_SFNT_PAT_SHARED, NULL);
945         if (sf == NULL)
946                 return -ENOMEM;
947         if ((smp = sf_sample_new(sflist, sf)) == NULL)
948                 return -ENOMEM;
949         sample_id = sflist->sample_counter;
950         smp->v.sample = sample_id;
951         smp->v.start = 0;
952         smp->v.end = patch.len;
953         smp->v.loopstart = patch.loop_start;
954         smp->v.loopend = patch.loop_end;
955         smp->v.size = patch.len;
956
957         /* set up mode flags */
958         smp->v.mode_flags = 0;
959         if (!(patch.mode & WAVE_16_BITS))
960                 smp->v.mode_flags |= SNDRV_SFNT_SAMPLE_8BITS;
961         if (patch.mode & WAVE_UNSIGNED)
962                 smp->v.mode_flags |= SNDRV_SFNT_SAMPLE_UNSIGNED;
963         smp->v.mode_flags |= SNDRV_SFNT_SAMPLE_NO_BLANK;
964         if (!(patch.mode & (WAVE_LOOPING|WAVE_BIDIR_LOOP|WAVE_LOOP_BACK)))
965                 smp->v.mode_flags |= SNDRV_SFNT_SAMPLE_SINGLESHOT;
966         if (patch.mode & WAVE_BIDIR_LOOP)
967                 smp->v.mode_flags |= SNDRV_SFNT_SAMPLE_BIDIR_LOOP;
968         if (patch.mode & WAVE_LOOP_BACK)
969                 smp->v.mode_flags |= SNDRV_SFNT_SAMPLE_REVERSE_LOOP;
970
971         if (patch.mode & WAVE_16_BITS) {
972                 /* convert to word offsets */
973                 smp->v.size /= 2;
974                 smp->v.end /= 2;
975                 smp->v.loopstart /= 2;
976                 smp->v.loopend /= 2;
977         }
978         /*smp->v.loopend++;*/
979
980         smp->v.dummy = 0;
981         smp->v.truesize = 0;
982         smp->v.sf_id = sf->id;
983
984         /* set up voice info */
985         if ((zone = sf_zone_new(sflist, sf)) == NULL) {
986                 sf_sample_delete(sflist, sf, smp);
987                 return -ENOMEM;
988         }
989
990         /*
991          * load wave data
992          */
993         if (sflist->callback.sample_new) {
994                 rc = sflist->callback.sample_new
995                         (sflist->callback.private_data, smp, sflist->memhdr, data, count);
996                 if (rc < 0) {
997                         sf_sample_delete(sflist, sf, smp);
998                         return rc;
999                 }
1000                 /* memory offset is updated after */
1001         }
1002
1003         /* update the memory offset here */
1004         sflist->mem_used += smp->v.truesize;
1005
1006         zone->v.sample = sample_id; /* the last sample */
1007         zone->v.rate_offset = calc_rate_offset(patch.base_freq);
1008         note = freq_to_note(patch.base_note);
1009         zone->v.root = note / 100;
1010         zone->v.tune = -(note % 100);
1011         zone->v.low = (freq_to_note(patch.low_note) + 99) / 100;
1012         zone->v.high = freq_to_note(patch.high_note) / 100;
1013         /* panning position; -128 - 127 => 0-127 */
1014         zone->v.pan = (patch.panning + 128) / 2;
1015 #if 0
1016         snd_printk("gus: basefrq=%d (ofs=%d) root=%d,tune=%d, range:%d-%d\n",
1017                    (int)patch.base_freq, zone->v.rate_offset,
1018                    zone->v.root, zone->v.tune, zone->v.low, zone->v.high);
1019 #endif
1020
1021         /* detuning is ignored */
1022         /* 6points volume envelope */
1023         if (patch.mode & WAVE_ENVELOPES) {
1024                 int attack, hold, decay, release;
1025                 attack = calc_gus_envelope_time
1026                         (patch.env_rate[0], 0, patch.env_offset[0]);
1027                 hold = calc_gus_envelope_time
1028                         (patch.env_rate[1], patch.env_offset[0],
1029                          patch.env_offset[1]);
1030                 decay = calc_gus_envelope_time
1031                         (patch.env_rate[2], patch.env_offset[1],
1032                          patch.env_offset[2]);
1033                 release = calc_gus_envelope_time
1034                         (patch.env_rate[3], patch.env_offset[1],
1035                          patch.env_offset[4]);
1036                 release += calc_gus_envelope_time
1037                         (patch.env_rate[4], patch.env_offset[3],
1038                          patch.env_offset[4]);
1039                 release += calc_gus_envelope_time
1040                         (patch.env_rate[5], patch.env_offset[4],
1041                          patch.env_offset[5]);
1042                 zone->v.parm.volatkhld = 
1043                         (snd_sf_calc_parm_hold(hold) << 8) |
1044                         snd_sf_calc_parm_attack(attack);
1045                 zone->v.parm.voldcysus = (calc_gus_sustain(patch.env_offset[2]) << 8) |
1046                         snd_sf_calc_parm_decay(decay);
1047                 zone->v.parm.volrelease = 0x8000 | snd_sf_calc_parm_decay(release);
1048                 zone->v.attenuation = calc_gus_attenuation(patch.env_offset[0]);
1049 #if 0
1050                 snd_printk("gus: atkhld=%x, dcysus=%x, volrel=%x, att=%d\n",
1051                            zone->v.parm.volatkhld,
1052                            zone->v.parm.voldcysus,
1053                            zone->v.parm.volrelease,
1054                            zone->v.attenuation);
1055 #endif
1056         }
1057
1058         /* fast release */
1059         if (patch.mode & WAVE_FAST_RELEASE) {
1060                 zone->v.parm.volrelease = 0x807f;
1061         }
1062
1063         /* tremolo effect */
1064         if (patch.mode & WAVE_TREMOLO) {
1065                 int rate = (patch.tremolo_rate * 1000 / 38) / 42;
1066                 zone->v.parm.tremfrq = ((patch.tremolo_depth / 2) << 8) | rate;
1067         }
1068         /* vibrato effect */
1069         if (patch.mode & WAVE_VIBRATO) {
1070                 int rate = (patch.vibrato_rate * 1000 / 38) / 42;
1071                 zone->v.parm.fm2frq2 = ((patch.vibrato_depth / 6) << 8) | rate;
1072         }
1073         
1074         /* scale_freq, scale_factor, volume, and fractions not implemented */
1075
1076         if (!(smp->v.mode_flags & SNDRV_SFNT_SAMPLE_SINGLESHOT))
1077                 zone->v.mode = SNDRV_SFNT_MODE_LOOPING;
1078         else
1079                 zone->v.mode = 0;
1080
1081         /* append to the tail of the list */
1082         /*zone->bank = ctrls[AWE_MD_GUS_BANK];*/
1083         zone->bank = 0;
1084         zone->instr = patch.instr_no;
1085         zone->mapped = 0;
1086         zone->v.sf_id = sf->id;
1087
1088         zone->sample = set_sample(sf, &zone->v);
1089
1090         /* rebuild preset now */
1091         add_preset(sflist, zone);
1092
1093         return 0;
1094 }
1095
1096 /* load GUS patch */
1097 int
1098 snd_soundfont_load_guspatch(snd_sf_list_t *sflist, const char __user *data,
1099                             long count, int client)
1100 {
1101         int rc;
1102         lock_preset(sflist);
1103         rc = load_guspatch(sflist, data, count, client);
1104         unlock_preset(sflist);
1105         return rc;
1106 }
1107
1108
1109 /*
1110  * Rebuild the preset table.  This is like a hash table in that it allows
1111  * quick access to the zone information.  For each preset there are zone
1112  * structures linked by next_instr and by next_zone.  Former is the whole
1113  * link for this preset, and latter is the link for zone (i.e. instrument/
1114  * bank/key combination).
1115  */
1116 static void
1117 rebuild_presets(snd_sf_list_t *sflist)
1118 {
1119         snd_soundfont_t *sf;
1120         snd_sf_zone_t *cur;
1121
1122         /* clear preset table */
1123         memset(sflist->presets, 0, sizeof(sflist->presets));
1124
1125         /* search all fonts and insert each font */
1126         for (sf = sflist->fonts; sf; sf = sf->next) {
1127                 for (cur = sf->zones; cur; cur = cur->next) {
1128                         if (! cur->mapped && cur->sample == NULL) {
1129                                 /* try again to search the corresponding sample */
1130                                 cur->sample = set_sample(sf, &cur->v);
1131                                 if (cur->sample == NULL)
1132                                         continue;
1133                         }
1134
1135                         add_preset(sflist, cur);
1136                 }
1137         }
1138 }
1139
1140
1141 /*
1142  * add the given zone to preset table
1143  */
1144 static void
1145 add_preset(snd_sf_list_t *sflist, snd_sf_zone_t *cur)
1146 {
1147         snd_sf_zone_t *zone;
1148         int index;
1149
1150         zone = search_first_zone(sflist, cur->bank, cur->instr, cur->v.low);
1151         if (zone && zone->v.sf_id != cur->v.sf_id) {
1152                 /* different instrument was already defined */
1153                 snd_sf_zone_t *p;
1154                 /* compare the allocated time */
1155                 for (p = zone; p; p = p->next_zone) {
1156                         if (p->counter > cur->counter)
1157                                 /* the current is older.. skipped */
1158                                 return;
1159                 }
1160                 /* remove old zones */
1161                 delete_preset(sflist, zone);
1162                 zone = NULL; /* do not forget to clear this! */
1163         }
1164
1165         /* prepend this zone */
1166         if ((index = get_index(cur->bank, cur->instr, cur->v.low)) < 0)
1167                 return;
1168         cur->next_zone = zone; /* zone link */
1169         cur->next_instr = sflist->presets[index]; /* preset table link */
1170         sflist->presets[index] = cur;
1171 }
1172
1173 /*
1174  * delete the given zones from preset_table
1175  */
1176 static void
1177 delete_preset(snd_sf_list_t *sflist, snd_sf_zone_t *zp)
1178 {
1179         int index;
1180         snd_sf_zone_t *p;
1181
1182         if ((index = get_index(zp->bank, zp->instr, zp->v.low)) < 0)
1183                 return;
1184         for (p = sflist->presets[index]; p; p = p->next_instr) {
1185                 while (p->next_instr == zp) {
1186                         p->next_instr = zp->next_instr;
1187                         zp = zp->next_zone;
1188                         if (zp == NULL)
1189                                 return;
1190                 }
1191         }
1192 }
1193
1194
1195 /*
1196  * Search matching zones from preset table.
1197  * The note can be rewritten by preset mapping (alias).
1198  * The found zones are stored on 'table' array.  max_layers defines
1199  * the maximum number of elements in this array.
1200  * This function returns the number of found zones.  0 if not found.
1201  */
1202 int
1203 snd_soundfont_search_zone(snd_sf_list_t *sflist, int *notep, int vel,
1204                           int preset, int bank,
1205                           int def_preset, int def_bank,
1206                           snd_sf_zone_t **table, int max_layers)
1207 {
1208         int nvoices;
1209         unsigned long flags;
1210
1211         /* this function is supposed to be called atomically,
1212          * so we check the lock.  if it's busy, just returns 0 to
1213          * tell the caller the busy state
1214          */
1215         spin_lock_irqsave(&sflist->lock, flags);
1216         if (sflist->presets_locked) {
1217                 spin_unlock_irqrestore(&sflist->lock, flags);
1218                 return 0;
1219         }
1220         nvoices = search_zones(sflist, notep, vel, preset, bank, table, max_layers, 0);
1221         if (! nvoices) {
1222                 if (preset != def_preset || bank != def_bank)
1223                         nvoices = search_zones(sflist, notep, vel, def_preset, def_bank, table, max_layers, 0);
1224         }
1225         spin_unlock_irqrestore(&sflist->lock, flags);
1226         return nvoices;
1227 }
1228
1229
1230 /*
1231  * search the first matching zone
1232  */
1233 static snd_sf_zone_t *
1234 search_first_zone(snd_sf_list_t *sflist, int bank, int preset, int key)
1235 {
1236         int index;
1237         snd_sf_zone_t *zp;
1238
1239         if ((index = get_index(bank, preset, key)) < 0)
1240                 return NULL;
1241         for (zp = sflist->presets[index]; zp; zp = zp->next_instr) {
1242                 if (zp->instr == preset && zp->bank == bank)
1243                         return zp;
1244         }
1245         return NULL;
1246 }
1247
1248
1249 /*
1250  * search matching zones from sflist.  can be called recursively.
1251  */
1252 static int
1253 search_zones(snd_sf_list_t *sflist, int *notep, int vel, int preset, int bank, snd_sf_zone_t **table, int max_layers, int level)
1254 {
1255         snd_sf_zone_t *zp;
1256         int nvoices;
1257
1258         zp = search_first_zone(sflist, bank, preset, *notep);
1259         nvoices = 0;
1260         for (; zp; zp = zp->next_zone) {
1261                 if (*notep >= zp->v.low && *notep <= zp->v.high &&
1262                     vel >= zp->v.vellow && vel <= zp->v.velhigh) {
1263                         if (zp->mapped) {
1264                                 /* search preset mapping (aliasing) */
1265                                 int key = zp->v.fixkey;
1266                                 preset = zp->v.start;
1267                                 bank = zp->v.end;
1268
1269                                 if (level > 5) /* too deep alias level */
1270                                         return 0;
1271                                 if (key < 0)
1272                                         key = *notep;
1273                                 nvoices = search_zones(sflist, &key, vel,
1274                                                        preset, bank, table,
1275                                                        max_layers, level + 1);
1276                                 if (nvoices > 0)
1277                                         *notep = key;
1278                                 break;
1279                         }
1280                         table[nvoices++] = zp;
1281                         if (nvoices >= max_layers)
1282                                 break;
1283                 }
1284         }
1285
1286         return nvoices;
1287 }
1288
1289
1290 /* calculate the index of preset table:
1291  * drums are mapped from 128 to 255 according to its note key.
1292  * other instruments are mapped from 0 to 127.
1293  * if the index is out of range, return -1.
1294  */
1295 static int
1296 get_index(int bank, int instr, int key)
1297 {
1298         int index;
1299         if (SF_IS_DRUM_BANK(bank))
1300                 index = key + SF_MAX_INSTRUMENTS;
1301         else
1302                 index = instr;
1303         index = index % SF_MAX_PRESETS;
1304         if (index < 0)
1305                 return -1;
1306         return index;
1307 }
1308
1309 /*
1310  * Initialise the sflist structure.
1311  */
1312 static void
1313 snd_sf_init(snd_sf_list_t *sflist)
1314 {
1315         memset(sflist->presets, 0, sizeof(sflist->presets));
1316
1317         sflist->mem_used = 0;
1318         sflist->currsf = NULL;
1319         sflist->open_client = -1;
1320         sflist->fonts = NULL;
1321         sflist->fonts_size = 0;
1322         sflist->zone_counter = 0;
1323         sflist->sample_counter = 0;
1324         sflist->zone_locked = 0;
1325         sflist->sample_locked = 0;
1326 }
1327
1328 /*
1329  * Release all list records
1330  */
1331 static void
1332 snd_sf_clear(snd_sf_list_t *sflist)
1333 {
1334         snd_soundfont_t *sf, *nextsf;
1335         snd_sf_zone_t *zp, *nextzp;
1336         snd_sf_sample_t *sp, *nextsp;
1337
1338         for (sf = sflist->fonts; sf; sf = nextsf) {
1339                 nextsf = sf->next;
1340                 for (zp = sf->zones; zp; zp = nextzp) {
1341                         nextzp = zp->next;
1342                         kfree(zp);
1343                 }
1344                 for (sp = sf->samples; sp; sp = nextsp) {
1345                         nextsp = sp->next;
1346                         if (sflist->callback.sample_free)
1347                                 sflist->callback.sample_free(sflist->callback.private_data, sp, sflist->memhdr);
1348                         kfree(sp);
1349                 }
1350                 kfree(sf);
1351         }
1352
1353         snd_sf_init(sflist);
1354 }
1355
1356
1357 /*
1358  * Create a new sflist structure
1359  */
1360 snd_sf_list_t *
1361 snd_sf_new(snd_sf_callback_t *callback, snd_util_memhdr_t *hdr)
1362 {
1363         snd_sf_list_t *sflist;
1364
1365         if ((sflist = kzalloc(sizeof(*sflist), GFP_KERNEL)) == NULL)
1366                 return NULL;
1367
1368         init_MUTEX(&sflist->presets_mutex);
1369         spin_lock_init(&sflist->lock);
1370         sflist->memhdr = hdr;
1371
1372         if (callback)
1373                 sflist->callback = *callback;
1374
1375         snd_sf_init(sflist);
1376         return sflist;
1377 }
1378
1379
1380 /*
1381  * Free everything allocated off the sflist structure.
1382  */
1383 void
1384 snd_sf_free(snd_sf_list_t *sflist)
1385 {
1386         if (sflist == NULL)
1387                 return;
1388         
1389         lock_preset(sflist);
1390         if (sflist->callback.sample_reset)
1391                 sflist->callback.sample_reset(sflist->callback.private_data);
1392         snd_sf_clear(sflist);
1393         unlock_preset(sflist);
1394
1395         kfree(sflist);
1396 }
1397
1398 /*
1399  * Remove all samples
1400  * The soundcard should be silet before calling this function.
1401  */
1402 int
1403 snd_soundfont_remove_samples(snd_sf_list_t *sflist)
1404 {
1405         lock_preset(sflist);
1406         if (sflist->callback.sample_reset)
1407                 sflist->callback.sample_reset(sflist->callback.private_data);
1408         snd_sf_clear(sflist);
1409         unlock_preset(sflist);
1410
1411         return 0;
1412 }
1413
1414 /*
1415  * Remove unlocked samples.
1416  * The soundcard should be silent before calling this function.
1417  */
1418 int
1419 snd_soundfont_remove_unlocked(snd_sf_list_t *sflist)
1420 {
1421         snd_soundfont_t *sf;
1422         snd_sf_zone_t *zp, *nextzp;
1423         snd_sf_sample_t *sp, *nextsp;
1424
1425         lock_preset(sflist);
1426
1427         if (sflist->callback.sample_reset)
1428                 sflist->callback.sample_reset(sflist->callback.private_data);
1429
1430         /* to be sure */
1431         memset(sflist->presets, 0, sizeof(sflist->presets));
1432
1433         for (sf = sflist->fonts; sf; sf = sf->next) {
1434                 for (zp = sf->zones; zp; zp = nextzp) {
1435                         if (zp->counter < sflist->zone_locked)
1436                                 break;
1437                         nextzp = zp->next;
1438                         sf->zones = nextzp;
1439                         kfree(zp);
1440                 }
1441
1442                 for (sp = sf->samples; sp; sp = nextsp) {
1443                         if (sp->counter < sflist->sample_locked)
1444                                 break;
1445                         nextsp = sp->next;
1446                         sf->samples = nextsp;
1447                         sflist->mem_used -= sp->v.truesize;
1448                         if (sflist->callback.sample_free)
1449                                 sflist->callback.sample_free(sflist->callback.private_data, sp, sflist->memhdr);
1450                         kfree(sp);
1451                 }
1452         }
1453
1454         sflist->zone_counter = sflist->zone_locked;
1455         sflist->sample_counter = sflist->sample_locked;
1456
1457         rebuild_presets(sflist);
1458
1459         unlock_preset(sflist);
1460         return 0;
1461 }
1462