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