synth/emux/soundfont.c

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