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