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