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