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