开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > midi > 查看源码
fluid_ramsfont.c
资源名称：trunk-r284.zip　[点击查看]
上传用户：tjmskj2
上传日期：2020-08-17
资源大小：577k
文件大小：35k
源码类别：

midi

开发平台：

C/C++

fluid_ramsfont.c：源码内容
  1. /* FluidSynth - A Software Synthesizer
  2.  *
  3.  * Copyright (C) 2003  Peter Hanappe and others.
  4.  *
  5.  * This library is free software; you can redistribute it and/or
  6.  * modify it under the terms of the GNU Library General Public License
  7.  * as published by the Free Software Foundation; either version 2 of
  8.  * the License, or (at your option) any later version.
  9.  *
  10.  * This library is distributed in the hope that it will be useful, but
  11.  * WITHOUT ANY WARRANTY; without even the implied warranty of
  12.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13.  * Library General Public License for more details.
  14.  *
  15.  * You should have received a copy of the GNU Library General Public
  16.  * License along with this library; if not, write to the Free
  17.  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
  18.  * 02111-1307, USA
  19.  */
  21. #include "fluid_ramsfont.h"
  22. #include "fluid_sys.h"
  23. #include "fluid_synth.h"
  25. /* thenumber of samples before the start and after the end */
  26. #define SAMPLE_LOOP_MARGIN 8
  28. /* Prototypes */
  29. static int fluid_ramsfont_sfont_delete(fluid_sfont_t* sfont);
  30. static char *fluid_ramsfont_sfont_get_name(fluid_sfont_t* sfont);
  31. static fluid_preset_t *fluid_ramsfont_sfont_get_preset(fluid_sfont_t* sfont,
  32.                                                        unsigned int bank,
  33.                                                        unsigned int prenum);
  34. static void fluid_ramsfont_sfont_iteration_start(fluid_sfont_t* sfont);
  35. static int fluid_ramsfont_sfont_iteration_next(fluid_sfont_t* sfont,
  36.                                                fluid_preset_t* preset);
  37. static int fluid_rampreset_preset_delete(fluid_preset_t* preset);
  38. static char *fluid_rampreset_preset_get_name(fluid_preset_t* preset);
  39. static int fluid_rampreset_preset_get_banknum(fluid_preset_t* preset);
  40. static int fluid_rampreset_preset_get_num(fluid_preset_t* preset);
  41. static int fluid_rampreset_preset_noteon(fluid_preset_t* preset,
  42.                                          fluid_synth_t* synth, int chan,
  43.                                          int key, int vel);
  44. static fluid_ramsfont_t *new_fluid_ramsfont (void);
  45. static int delete_fluid_ramsfont (fluid_ramsfont_t* sfont);
  46. static char *fluid_ramsfont_get_name(fluid_ramsfont_t* sfont);
  47. static int fluid_ramsfont_add_preset (fluid_ramsfont_t* sfont,
  48.                                       fluid_rampreset_t* preset);
  49. static fluid_rampreset_t *fluid_ramsfont_get_preset (fluid_ramsfont_t* sfont,
  50.                                                      unsigned int bank, unsigned int num);
  51. static void fluid_ramsfont_iteration_start (fluid_ramsfont_t* sfont);
  52. static int fluid_ramsfont_iteration_next (fluid_ramsfont_t* sfont,
  53.                                           fluid_preset_t* preset);
  54. static fluid_rampreset_t* new_fluid_rampreset(fluid_ramsfont_t* sfont);
  55. static int delete_fluid_rampreset (fluid_rampreset_t* preset);
  56. static int fluid_rampreset_get_banknum (fluid_rampreset_t* preset);
  57. static int fluid_rampreset_get_num (fluid_rampreset_t* preset);
  58. static char *fluid_rampreset_get_name (fluid_rampreset_t* preset);
  59. static fluid_rampreset_t *fluid_rampreset_next (fluid_rampreset_t* preset);
  60. static int fluid_rampreset_add_zone(fluid_rampreset_t* preset,
  61.                                     fluid_preset_zone_t* zone);
  62. static int fluid_rampreset_add_sample (fluid_rampreset_t* preset,
  63.                                        fluid_sample_t* sample,
  64.                                        int lokey, int hikey);
  65. static fluid_inst_zone_t *fluid_rampreset_izoneforsample (fluid_rampreset_t* preset,
  66.                                                           fluid_sample_t* sample);
  67. static int fluid_rampreset_izone_set_loop (fluid_rampreset_t* preset,
  68.                                            fluid_sample_t* sample,
  69.                                            int on, float loopstart, float loopend);
  70. static int fluid_rampreset_izone_set_gen (fluid_rampreset_t* preset,
  71.                                           fluid_sample_t* sample,
  72.                                           int gen_type, float value);
  73. static int fluid_rampreset_remove_izone(fluid_rampreset_t* preset,
  74.                                         fluid_sample_t* sample);
  75. static int fluid_rampreset_remembervoice (fluid_rampreset_t* preset,
  76.                                           fluid_voice_t* voice);
  77. static void fluid_rampreset_updatevoices (fluid_rampreset_t* preset,
  78.                                           int gen_type, float val);
  79. static int fluid_rampreset_noteon (fluid_rampreset_t* preset, fluid_synth_t* synth,
  80.                                    int chan, int key, int vel);
  83. /**
  84.  * Create a #fluid_sfont_t wrapping a #fluid_ramsfont_t
  85.  * @return New #fluid_sfont_t or NULL if out of memory
  86.  */
  87. fluid_sfont_t*
  88. fluid_ramsfont_create_sfont()
  89. {
  90.   fluid_sfont_t* sfont;
  91.   fluid_ramsfont_t* ramsfont;
  93.   ramsfont = new_fluid_ramsfont();
  94.   if (ramsfont == NULL) {
  95.     return NULL;
  96.   }
  98.   sfont = FLUID_NEW(fluid_sfont_t);
  99.   if (sfont == NULL) {
  100.     FLUID_LOG(FLUID_ERR, "Out of memory");
  101.     return NULL;
  102.   }
  104.   sfont->data = ramsfont;
  105.   sfont->free = fluid_ramsfont_sfont_delete;
  106.   sfont->get_name = fluid_ramsfont_sfont_get_name;
  107.   sfont->get_preset = fluid_ramsfont_sfont_get_preset;
  108.   sfont->iteration_start = fluid_ramsfont_sfont_iteration_start;
  109.   sfont->iteration_next = fluid_ramsfont_sfont_iteration_next;
  111.   return sfont;
  112. }
  114. /* RAM SoundFont loader method to delete SoundFont */
  115. static int
  116. fluid_ramsfont_sfont_delete(fluid_sfont_t* sfont)
  117. {
  118.   if (delete_fluid_ramsfont(sfont->data) != 0)
  119.     return -1;
  120.   FLUID_FREE(sfont);
  121.   return 0;
  122. }
  124. /* RAM SoundFont loader method to get name */
  125. static char *
  126. fluid_ramsfont_sfont_get_name(fluid_sfont_t* sfont)
  127. {
  128.   return fluid_ramsfont_get_name((fluid_ramsfont_t*) sfont->data);
  129. }
  131. /* RAM SoundFont loader method to get a preset */
  132. static fluid_preset_t *
  133. fluid_ramsfont_sfont_get_preset(fluid_sfont_t* sfont, unsigned int bank, unsigned int prenum)
  134. {
  135.   fluid_preset_t* preset;
  136.   fluid_rampreset_t* rampreset;
  138.   rampreset = fluid_ramsfont_get_preset((fluid_ramsfont_t*) sfont->data, bank, prenum);
  140.   if (rampreset == NULL) {
  141.     return NULL;
  142.   }
  144.   preset = FLUID_NEW(fluid_preset_t);
  145.   if (preset == NULL) {
  146.     FLUID_LOG(FLUID_ERR, "Out of memory");
  147.     return NULL;
  148.   }
  150.   preset->sfont = sfont;
  151.   preset->data = rampreset;
  152.   preset->free = fluid_rampreset_preset_delete;
  153.   preset->get_name = fluid_rampreset_preset_get_name;
  154.   preset->get_banknum = fluid_rampreset_preset_get_banknum;
  155.   preset->get_num = fluid_rampreset_preset_get_num;
  156.   preset->noteon = fluid_rampreset_preset_noteon;
  157.   preset->notify = NULL;
  159.   return preset;
  160. }
  162. /* RAM SoundFont loader method to start preset iteration */
  163. static void
  164. fluid_ramsfont_sfont_iteration_start(fluid_sfont_t* sfont)
  165. {
  166.   fluid_ramsfont_iteration_start((fluid_ramsfont_t*) sfont->data);
  167. }
  169. /* RAM SoundFont loader method to advance preset iteration */
  170. static int
  171. fluid_ramsfont_sfont_iteration_next(fluid_sfont_t* sfont, fluid_preset_t* preset)
  172. {
  173.   preset->free = fluid_rampreset_preset_delete;
  174.   preset->get_name = fluid_rampreset_preset_get_name;
  175.   preset->get_banknum = fluid_rampreset_preset_get_banknum;
  176.   preset->get_num = fluid_rampreset_preset_get_num;
  177.   preset->noteon = fluid_rampreset_preset_noteon;
  178.   preset->notify = NULL;
  180.   return fluid_ramsfont_iteration_next((fluid_ramsfont_t*) sfont->data, preset);
  181. }
  183. /* RAM SoundFont loader delete preset method */
  184. static int
  185. fluid_rampreset_preset_delete(fluid_preset_t* preset)
  186. {
  187.   FLUID_FREE(preset);
  189. /* TODO: free modulators */
  191.   return 0;
  192. }
  194. /* RAM SoundFont loader get preset name method */
  195. static char *
  196. fluid_rampreset_preset_get_name(fluid_preset_t* preset)
  197. {
  198.   return fluid_rampreset_get_name((fluid_rampreset_t*) preset->data);
  199. }
  201. /* RAM SoundFont loader get preset bank method */
  202. static int
  203. fluid_rampreset_preset_get_banknum(fluid_preset_t* preset)
  204. {
  205.   return fluid_rampreset_get_banknum((fluid_rampreset_t*) preset->data);
  206. }
  208. /* RAM SoundFont loader get preset program method */
  209. static int
  210. fluid_rampreset_preset_get_num(fluid_preset_t* preset)
  211. {
  212.   return fluid_rampreset_get_num((fluid_rampreset_t*) preset->data);
  213. }
  215. /* RAM SoundFont loader preset noteon method */
  216. static int
  217. fluid_rampreset_preset_noteon(fluid_preset_t* preset, fluid_synth_t* synth, int chan, int key, int vel)
  218. {
  219.   return fluid_rampreset_noteon((fluid_rampreset_t*) preset->data, synth, chan, key, vel);
  220. }
  225. /***************************************************************
  226.  *
  227.  *                           SFONT
  228.  */
  230. static fluid_ramsfont_t *
  231. new_fluid_ramsfont (void)
  232. {
  233.   fluid_ramsfont_t* sfont;
  235.   sfont = FLUID_NEW(fluid_ramsfont_t);
  236.   if (sfont == NULL) {
  237.     FLUID_LOG(FLUID_ERR, "Out of memory");
  238.     return NULL;
  239.   }
  241.   sfont->name[0] = 0;
  242.   sfont->sample = NULL;
  243.   sfont->preset = NULL;
  245.   return sfont;
  246. }
  248. static int
  249. delete_fluid_ramsfont (fluid_ramsfont_t* sfont)
  250. {
  251.   fluid_list_t *list;
  252.   fluid_rampreset_t* preset;
  254.   /* Check that no samples are currently used */
  255.   for (list = sfont->sample; list; list = fluid_list_next(list)) {
  256.     fluid_sample_t* sam = (fluid_sample_t*) fluid_list_get(list);
  257.     if (fluid_sample_refcount(sam) != 0) {
  258.       return -1;
  259.     }
  260.   }
  262.   for (list = sfont->sample; list; list = fluid_list_next(list)) {
  263.    /* in ram soundfonts, the samples hold their data : so we should free it ourselves */
  264.    fluid_sample_t* sam = (fluid_sample_t*)fluid_list_get(list);
  265.     delete_fluid_ramsample(sam);
  266.   }
  268.   if (sfont->sample) {
  269.     delete_fluid_list(sfont->sample);
  270.   }
  272.   preset = sfont->preset;
  273.   while (preset != NULL) {
  274.     sfont->preset = preset->next;
  275.     delete_fluid_rampreset(preset);
  276.     preset = sfont->preset;
  277.   }
  279.   FLUID_FREE(sfont);
  280.   return FLUID_OK;
  281. }
  283. static char *
  284. fluid_ramsfont_get_name(fluid_ramsfont_t* sfont)
  285. {
  286.   return sfont->name;
  287. }
  289. /**
  290.  * Set a RAM SoundFont name.
  291.  * @param sfont RAM SoundFont
  292.  * @param name Name to assign (should be 20 chars in length with a NULL terminator)
  293.  * @return #FLUID_OK
  294.  */
  295. int
  296. fluid_ramsfont_set_name (fluid_ramsfont_t *sfont, const char *name)
  297. {
  298.   FLUID_MEMCPY(sfont->name, name, 20);
  299.   return FLUID_OK;
  300. }
  303. /* Add a preset to a RAM SoundFont */
  304. static int
  305. fluid_ramsfont_add_preset (fluid_ramsfont_t* sfont, fluid_rampreset_t* preset)
  306. {
  307.   fluid_rampreset_t *cur, *prev;
  308.   if (sfont->preset == NULL) {
  309.     preset->next = NULL;
  310.     sfont->preset = preset;
  311.   } else {
  312.     /* sort them as we go along. very basic sorting trick. */
  313.     cur = sfont->preset;
  314.     prev = NULL;
  315.     while (cur != NULL) {
  316.       if ((preset->bank < cur->bank)
  317.   || ((preset->bank == cur->bank) && (preset->num < cur->num))) {
  318. if (prev == NULL) {
  319.   preset->next = cur;
  320.   sfont->preset = preset;
  321. } else {
  322.   preset->next = cur;
  323.   prev->next = preset;
  324. }
  325. return FLUID_OK;
  326.       }
  327.       prev = cur;
  328.       cur = cur->next;
  329.     }
  330.     preset->next = NULL;
  331.     prev->next = preset;
  332.   }
  333.   return FLUID_OK;
  334. }
  336. /**
  337.  * Creates one instrument zone for the sample inside the preset defined by
  338.  * a bank and a num
  339.  * @param sfont RAM SoundFont
  340.  * @param bank Preset bank number
  341.  * @param num Preset program number
  342.  * @param sample Sample to use for instrument zone
  343.  * @param lokey Lower MIDI key range of zone (0-127, <= a hikey)
  344.  * @param hikey Upper MIDI key range of zone (0-127, >= a lokey)
  345.  * @return #FLUID_OK on success, #FLUID_FAILED otherwise
  346.  */
  347. int
  348. fluid_ramsfont_add_izone(fluid_ramsfont_t* sfont, unsigned int bank,
  349.                          unsigned int num, fluid_sample_t* sample,
  350.                          int lokey, int hikey)
  351. {
  352. /*- find or create a preset
  353. - add it the sample using the fluid_rampreset_add_sample fucntion
  354. - add the sample to the list of samples
  355. */
  356. int err;
  358. fluid_rampreset_t* preset = fluid_ramsfont_get_preset(sfont, bank, num);
  359. if (preset == NULL) {
  360. // Create it
  361. preset = new_fluid_rampreset(sfont);
  362. if (preset == NULL) {
  363. return FLUID_FAILED;
  364. }
  366. preset->bank = bank;
  367. preset->num = num;
  369. err = fluid_rampreset_add_sample(preset, sample, lokey, hikey);
  370. if (err != FLUID_OK) {
  371. return FLUID_FAILED;
  372. }
  374. // sort the preset
  375. fluid_ramsfont_add_preset(sfont, preset);
  377. } else {
  379. // just add it
  380. err = fluid_rampreset_add_sample(preset, sample, lokey, hikey);
  381. if (err != FLUID_OK) {
  382. return FLUID_FAILED;
  383. }
  384. }
  386.   sfont->sample = fluid_list_append(sfont->sample, sample);
  387.   return FLUID_OK;
  388. }
  390. /**
  391.  * Removes the instrument zone corresponding to a bank, a num and a sample
  392.  * @param sfont RAM SoundFont
  393.  * @param bank Preset bank number
  394.  * @param num Preset program number
  395.  * @param sample Sample of the preset zone
  396.  * @return #FLUID_OK on success, #FLUID_FAILED otherwise
  397.  */
  398. int
  399. fluid_ramsfont_remove_izone (fluid_ramsfont_t* sfont, unsigned int bank,
  400.                              unsigned int num, fluid_sample_t* sample)
  401. {
  402. int err;
  403. fluid_rampreset_t* preset = fluid_ramsfont_get_preset(sfont, bank, num);
  404. if (preset == NULL) {
  405. return FLUID_FAILED;
  406. }
  408. // Fixed a crash bug : remove the sample from the sfont list after
  409. // removing the izone (aschmitt august 2005)
  410. err = fluid_rampreset_remove_izone(preset, sample);
  411. if (err != FLUID_OK)
  412. return err;
  414. // now we must remove the sample from sfont->sample
  415. sfont->sample = fluid_list_remove(sfont->sample, sample);
  417. return FLUID_OK;
  418. }
  420. /**
  421.  * Sets a generator on an instrument zone identified by a bank, a num and a sample
  422.  * @param sfont RAM SoundFont
  423.  * @param bank Preset bank number
  424.  * @param num Preset program number
  425.  * @param sample Sample of the instrument zone.
  426.  * @param gen_type Generator ID (#fluid_gen_type)
  427.  * @param value Generator value
  428.  * @return #FLUID_OK on success, #FLUID_FAILED otherwise
  429.  */
  430. int
  431. fluid_ramsfont_izone_set_gen (fluid_ramsfont_t* sfont, unsigned int bank,
  432.                               unsigned int num, fluid_sample_t* sample,
  433.                               int gen_type, float value)
  434. {
  435. fluid_rampreset_t* preset = fluid_ramsfont_get_preset(sfont, bank, num);
  436. if (preset == NULL) {
  437. return FLUID_FAILED;
  438. }
  440. return fluid_rampreset_izone_set_gen(preset, sample, gen_type, value);
  441. }
  443. /**
  444.  * Sets loop start/end values of the instrument zone identified by a bank,
  445.  * a num and a sample.
  446.  * @param sfont RAM SoundFont
  447.  * @param bank Preset bank number
  448.  * @param num Preset program number
  449.  * @param sample Sample of the instrument zone
  450.  * @param on TRUE to enable looping, FALSE for one shot (a loopstart and a loopend
  451.  *   not used)
  452.  * @param loopstart Loop start, in frames (counted from 0)
  453.  * @param loopend Loop end, in frames (counted from last frame, thus is < 0)
  454.  * @return #FLUID_OK on success, #FLUID_FAILED otherwise
  455.  */
  456. int
  457. fluid_ramsfont_izone_set_loop (fluid_ramsfont_t *sfont, unsigned int bank,
  458.                                unsigned int num, fluid_sample_t* sample,
  459.                                int on, float loopstart, float loopend)
  460. {
  461. fluid_rampreset_t* preset = fluid_ramsfont_get_preset(sfont, bank, num);
  462. if (preset == NULL) {
  463. return FLUID_FAILED;
  464. }
  466. return fluid_rampreset_izone_set_loop(preset, sample, on, loopstart, loopend);
  467. }
  469. /* Get a preset from a RAM SoundFont */
  470. static fluid_rampreset_t *
  471. fluid_ramsfont_get_preset (fluid_ramsfont_t* sfont, unsigned int bank, unsigned int num)
  472. {
  473.   fluid_rampreset_t* preset = sfont->preset;
  474.   while (preset != NULL) {
  475.     if ((preset->bank == bank) && ((preset->num == num))) {
  476.       return preset;
  477.     }
  478.     preset = preset->next;
  479.   }
  480.   return NULL;
  481. }
  483. /* Start preset iteration in a RAM SoundFont */
  484. static void
  485. fluid_ramsfont_iteration_start (fluid_ramsfont_t* sfont)
  486. {
  487.   sfont->iter_cur = sfont->preset;
  488. }
  490. /* Advance preset iteration in a RAM SoundFont */
  491. static int
  492. fluid_ramsfont_iteration_next (fluid_ramsfont_t* sfont, fluid_preset_t* preset)
  493. {
  494.   if (sfont->iter_cur == NULL) {
  495.     return 0;
  496.   }
  498.   preset->data = (void*) sfont->iter_cur;
  499.   sfont->iter_cur = fluid_rampreset_next(sfont->iter_cur);
  500.   return 1;
  501. }
  503. /***************************************************************
  504.  *
  505.  *                           PRESET
  506.  */
  508. typedef struct _fluid_rampreset_voice_t fluid_rampreset_voice_t;
  509. struct _fluid_rampreset_voice_t {
  510. fluid_voice_t *voice;
  511. unsigned int voiceID;
  512. };
  514. /* Create a new RAM SoundFont preset */
  515. static fluid_rampreset_t*
  516. new_fluid_rampreset(fluid_ramsfont_t* sfont)
  517. {
  518.   fluid_rampreset_t* preset = FLUID_NEW(fluid_rampreset_t);
  519.   if (preset == NULL) {
  520.     FLUID_LOG(FLUID_ERR, "Out of memory");
  521.     return NULL;
  522.   }
  523.   preset->next = NULL;
  524.   preset->sfont = sfont;
  525.   preset->name[0] = 0;
  526.   preset->bank = 0;
  527.   preset->num = 0;
  528.   preset->global_zone = NULL;
  529.   preset->zone = NULL;
  530.   preset->presetvoices = NULL;
  531.   return preset;
  532. }
  534. /* Delete a RAM SoundFont preset */
  535. static int
  536. delete_fluid_rampreset (fluid_rampreset_t* preset)
  537. {
  538.   int err = FLUID_OK;
  539.   fluid_preset_zone_t* zone;
  540.   fluid_rampreset_voice_t *data;
  542.   if (preset->global_zone != NULL) {
  543.     if (delete_fluid_preset_zone(preset->global_zone) != FLUID_OK) {
  544.       err = FLUID_FAILED;
  545.     }
  546.     preset->global_zone = NULL;
  547.   }
  548.   zone = preset->zone;
  549.   while (zone != NULL) {
  550.     preset->zone = zone->next;
  551.     if (delete_fluid_preset_zone(zone) != FLUID_OK) {
  552.       err = FLUID_FAILED;
  553.     }
  554.     zone = preset->zone;
  555.   }
  557.   if (preset->presetvoices != NULL) {
  558.    fluid_list_t *tmp = preset->presetvoices, *next;
  559.    while (tmp) {
  560.    data = (fluid_rampreset_voice_t *)(tmp->data);
  561.    FLUID_FREE(data);
  563.    next = tmp->next;
  564.    FLUID_FREE(tmp);
  565.    tmp = next;
  566.    }
  567.   }
  568.   preset->presetvoices = NULL;
  570.   FLUID_FREE(preset);
  571.   return err;
  572. }
  574. /* Get a RAM SoundFont preset bank */
  575. static int
  576. fluid_rampreset_get_banknum (fluid_rampreset_t* preset)
  577. {
  578.   return preset->bank;
  579. }
  581. /* Get a RAM SoundFont preset program */
  582. static int
  583. fluid_rampreset_get_num (fluid_rampreset_t* preset)
  584. {
  585.   return preset->num;
  586. }
  588. /* Get a RAM SoundFont preset name */
  589. static char *
  590. fluid_rampreset_get_name (fluid_rampreset_t* preset)
  591. {
  592.   return preset->name;
  593. }
  595. /* Advance to next preset */
  596. static fluid_rampreset_t *
  597. fluid_rampreset_next (fluid_rampreset_t* preset)
  598. {
  599.   return preset->next;
  600. }
  603. /* Add a zone to a RAM SoundFont preset */
  604. static int
  605. fluid_rampreset_add_zone(fluid_rampreset_t* preset, fluid_preset_zone_t* zone)
  606. {
  607.   if (preset->zone == NULL) {
  608.     zone->next = NULL;
  609.     preset->zone = zone;
  610.   } else {
  611.     zone->next = preset->zone;
  612.     preset->zone = zone;
  613.   }
  614.   return FLUID_OK;
  615. }
  617. /* Add a sample to a RAM SoundFont preset */
  618. static int
  619. fluid_rampreset_add_sample (fluid_rampreset_t* preset, fluid_sample_t* sample,
  620.                             int lokey, int hikey)
  621. {
  622. /* create a new instrument zone, with the given sample */
  624. /* one preset zone */
  625. if (preset->zone == NULL) {
  626. fluid_preset_zone_t* zone;
  627. zone = new_fluid_preset_zone("");
  628. if (zone == NULL) {
  629. return FLUID_FAILED;
  630. }
  632. /* its instrument */
  633. zone->inst = (fluid_inst_t*) new_fluid_inst();
  634.     if (zone->inst == NULL) {
  635.       delete_fluid_preset_zone(zone);
  636.       return FLUID_FAILED;
  637.     }
  639. fluid_rampreset_add_zone(preset, zone);
  640. }
  642. /* add an instrument zone for each sample */
  643. {
  644. fluid_inst_t* inst = fluid_preset_zone_get_inst(preset->zone);
  645. fluid_inst_zone_t* izone = new_fluid_inst_zone("");
  646. if (izone == NULL) {
  647. return FLUID_FAILED;
  648. }
  650. if (fluid_inst_add_zone(inst, izone) != FLUID_OK) {
  651. delete_fluid_inst_zone(izone);
  652. return FLUID_FAILED;
  653. }
  655. izone->sample = sample;
  656. izone->keylo = lokey;
  657. izone->keyhi = hikey;
  659. // give the preset the name of the sample
  660. FLUID_MEMCPY(preset->name, sample->name, 20);
  661. }
  663. return FLUID_OK;
  664. }
  666. /* Find an instrument zone with the given sample */
  667. static fluid_inst_zone_t *
  668. fluid_rampreset_izoneforsample (fluid_rampreset_t* preset, fluid_sample_t* sample)
  669. {
  670. fluid_inst_t* inst;
  671. fluid_inst_zone_t* izone;
  673. if (preset->zone == NULL) return NULL;
  675. inst = fluid_preset_zone_get_inst(preset->zone);
  676. izone = inst->zone;
  677. while (izone) {
  678. if (izone->sample == sample)
  679. return izone;
  680. izone = izone->next;
  681. }
  682. return NULL;
  683. }
  685. /* Set loop of an instrument zone */
  686. static int
  687. fluid_rampreset_izone_set_loop (fluid_rampreset_t* preset, fluid_sample_t* sample,
  688.                                 int on, float loopstart, float loopend)
  689. {
  690. fluid_inst_zone_t* izone = fluid_rampreset_izoneforsample(preset, sample);
  691. short coarse, fine;
  693. if (izone == NULL)
  694. return FLUID_FAILED;
  696. if (!on) {
  697. izone->gen[GEN_SAMPLEMODE].flags = GEN_SET;
  698. izone->gen[GEN_SAMPLEMODE].val = FLUID_UNLOOPED;
  699. fluid_rampreset_updatevoices(preset, GEN_SAMPLEMODE, FLUID_UNLOOPED);
  700. return FLUID_OK;
  701. }
  703. /* NOTE : We should check that (sample->startloop + loopStart <= sample->endloop - loopend - 32) */
  705. /* loopstart */
  706. if (loopstart > 32767. || loopstart < -32767.) {
  707. coarse = (short)(loopstart/32768.);
  708. fine = (short)(loopstart - (float)(coarse)*32768.);
  709. } else {
  710. coarse = 0;
  711. fine = (short)loopstart;
  712. }
  713. izone->gen[GEN_STARTLOOPADDROFS].flags = GEN_SET;
  714. izone->gen[GEN_STARTLOOPADDROFS].val = fine;
  715. fluid_rampreset_updatevoices(preset, GEN_STARTLOOPADDROFS, fine);
  716. if (coarse) {
  717. izone->gen[GEN_STARTLOOPADDRCOARSEOFS].flags = GEN_SET;
  718. izone->gen[GEN_STARTLOOPADDRCOARSEOFS].val = coarse;
  719. } else {
  720. izone->gen[GEN_STARTLOOPADDRCOARSEOFS].flags = GEN_UNUSED;
  721. }
  722. fluid_rampreset_updatevoices(preset, GEN_STARTLOOPADDRCOARSEOFS, coarse);
  724. /* loopend */
  725. if (loopend > 32767. || loopend < -32767.) {
  726. coarse = (short)(loopend/32768.);
  727. fine = (short)(loopend - (float)(coarse)*32768.);
  728. } else {
  729. coarse = 0;
  730. fine = (short)loopend;
  731. }
  732. izone->gen[GEN_ENDLOOPADDROFS].flags = GEN_SET;
  733. izone->gen[GEN_ENDLOOPADDROFS].val = fine;
  734. fluid_rampreset_updatevoices(preset, GEN_ENDLOOPADDROFS, fine);
  735. if (coarse) {
  736. izone->gen[GEN_ENDLOOPADDRCOARSEOFS].flags = GEN_SET;
  737. izone->gen[GEN_ENDLOOPADDRCOARSEOFS].val = coarse;
  738. } else {
  739. izone->gen[GEN_ENDLOOPADDRCOARSEOFS].flags = GEN_UNUSED;
  740. }
  741. fluid_rampreset_updatevoices(preset, GEN_ENDLOOPADDRCOARSEOFS, coarse);
  743. izone->gen[GEN_SAMPLEMODE].flags = GEN_SET;
  744. izone->gen[GEN_SAMPLEMODE].val = FLUID_LOOP_DURING_RELEASE;
  745. fluid_rampreset_updatevoices(preset, GEN_SAMPLEMODE, FLUID_LOOP_DURING_RELEASE);
  747. /* If the loop points are the whole samples, we are supposed to
  748.    copy the frames around in the margins (the start to the end margin and
  749.    the end to the start margin), but it works fine without this. Maybe some time
  750.    it will be needed (see SAMPLE_LOOP_MARGIN) -- Antoie Schmitt May 2003 */
  752. return FLUID_OK;
  753. }
  755. /* Set a generator on the instrument zone in preset having sample */
  756. static int
  757. fluid_rampreset_izone_set_gen (fluid_rampreset_t* preset, fluid_sample_t* sample,
  758.                                int gen_type, float value)
  759. {
  760. fluid_inst_zone_t* izone = fluid_rampreset_izoneforsample(preset, sample);
  761. if (izone == NULL)
  762. return FLUID_FAILED;
  764. izone->gen[gen_type].flags = GEN_SET;
  765. izone->gen[gen_type].val = value;
  767. fluid_rampreset_updatevoices(preset, gen_type, value);
  769. return FLUID_OK;
  770. }
  772. /* Remove the instrument zone from preset having sample */
  773. static int
  774. fluid_rampreset_remove_izone(fluid_rampreset_t* preset, fluid_sample_t* sample)
  775. {
  776. fluid_inst_t* inst;
  777. fluid_inst_zone_t* izone, * prev;
  778. int found = 0;
  780. if (preset->zone == NULL) return FLUID_FAILED;
  781. inst = fluid_preset_zone_get_inst(preset->zone);
  782. izone = inst->zone;
  783. prev = NULL;
  784. while (izone && !found) {
  785. if (izone->sample == sample) {
  786. if (prev == NULL) {
  787. inst->zone = izone->next;
  788. } else {
  789. prev->next = izone->next;
  790. }
  791. izone->next = NULL;
  792. delete_fluid_inst_zone(izone);
  793. found = 1;
  794. } else {
  795. prev = izone;
  796. izone = izone->next;
  797. }
  798. }
  799. if (!found)
  800. return FLUID_FAILED;
  802. // stop all the voices that use this sample, so that
  803. // the sample can be cleared up
  804. {
  805. fluid_list_t *tmp = preset->presetvoices;
  806. while (tmp) {
  807. fluid_rampreset_voice_t *presetvoice = (fluid_rampreset_voice_t *)(tmp->data);
  808. fluid_voice_t *voice = presetvoice->voice;
  809. if (fluid_voice_is_playing(voice) && (fluid_voice_get_id(voice) == presetvoice->voiceID)) {
  810. // still belongs to the preset
  811. if (voice->sample == sample) {
  812. // uses this sample : turn it off.
  813. // our presetvoices struct will be cleaneup at the next update
  814. fluid_voice_off(voice);
  815. }
  816. }
  817. tmp = tmp->next;
  818. }
  819. }
  820. return FLUID_OK;
  821. }
  823. /* Stores the voice and the its ID in the preset for later update on gen_set */
  824. static int
  825. fluid_rampreset_remembervoice (fluid_rampreset_t* preset, fluid_voice_t* voice)
  826. {
  827.   fluid_rampreset_voice_t *presetvoice = FLUID_NEW(fluid_rampreset_voice_t);
  828.   if (presetvoice == NULL) {
  829.     FLUID_LOG(FLUID_ERR, "Out of memory");
  830.     return FLUID_FAILED;
  831.   }
  833.   presetvoice->voice = voice;
  834.   presetvoice->voiceID = fluid_voice_get_id(voice);
  836.   preset->presetvoices = fluid_list_append(preset->presetvoices, (void *)presetvoice);
  837.   if (preset->presetvoices == NULL) {
  838.    FLUID_FREE(presetvoice);
  839.     FLUID_LOG(FLUID_ERR, "Out of memory");
  840.     return FLUID_FAILED;
  841.   }
  842.   return FLUID_OK;
  843. }
  845. /* Update a generator in realtime for a preset */
  846. static void
  847. fluid_rampreset_updatevoices (fluid_rampreset_t* preset, int gen_type, float val)
  848. {
  849. fluid_list_t *tmp = preset->presetvoices, *prev = NULL, *next;
  851. /* Walk the presetvoice to update them if they are still active and ours.
  852.  * If their ID has changed or their state is not playing, they are not
  853.  * ours, so we forget them. */
  854. while (tmp) {
  855. fluid_rampreset_voice_t *presetvoice = (fluid_rampreset_voice_t *)(tmp->data);
  856. fluid_voice_t *voice = presetvoice->voice;
  857. if (!fluid_voice_is_playing(voice) || (fluid_voice_get_id(voice) != presetvoice->voiceID)) {
  858. /* forget it */
  859.    FLUID_FREE(presetvoice);
  861. /* unlink it */
  862. next = tmp->next;
  863.    FLUID_FREE(tmp);
  864. if (prev) {
  865. prev->next = next;
  866. } else {
  867. preset->presetvoices = next;
  868. }
  869.    tmp = next;
  871. } else {
  873. /* update */
  874. fluid_voice_gen_set(voice, gen_type, val);
  875. fluid_voice_update_param(voice, gen_type);
  877. /* next */
  878. prev = tmp;
  879. tmp = tmp->next;
  880. }
  881. }
  882. }
  885. /* RAM SoundFont preset note on */
  886. static int
  887. fluid_rampreset_noteon (fluid_rampreset_t* preset, fluid_synth_t* synth, int chan,
  888.                         int key, int vel)
  889. {
  890.   fluid_preset_zone_t *preset_zone;
  891.   fluid_inst_t* inst;
  892.   fluid_inst_zone_t *inst_zone, *global_inst_zone, *z;
  893.   fluid_sample_t* sample;
  894.   fluid_voice_t* voice;
  895.   fluid_mod_t * mod;
  896.   fluid_mod_t * mod_list[FLUID_NUM_MOD]; /* list for 'sorting' preset modulators */
  897.   int mod_list_count;
  898.   int i;
  900.   /* run thru all the zones of this preset */
  901.   preset_zone = preset->zone;
  902.   while (preset_zone != NULL) {
  904.     /* check if the note falls into the key and velocity range of this
  905.        preset */
  906.     if (fluid_preset_zone_inside_range(preset_zone, key, vel)) {
  908.       inst = fluid_preset_zone_get_inst(preset_zone);
  909.       global_inst_zone = fluid_inst_get_global_zone(inst);
  911.       /* run thru all the zones of this instrument */
  912.       inst_zone = fluid_inst_get_zone(inst);
  913.       while (inst_zone != NULL) {
  915. /* make sure this instrument zone has a valid sample */
  916. sample = fluid_inst_zone_get_sample(inst_zone);
  917. if (fluid_sample_in_rom(sample) || (sample == NULL)) {
  918.   inst_zone = fluid_inst_zone_next(inst_zone);
  919.   continue;
  920. }
  922. /* check if the note falls into the key and velocity range of this
  923.    instrument */
  925. if (fluid_inst_zone_inside_range(inst_zone, key, vel) && (sample != NULL)) {
  927.   /* this is a good zone. allocate a new synthesis process and
  928.              initialize it */
  930.   voice = fluid_synth_alloc_voice(synth, sample, chan, key, vel);
  931.   if (voice == NULL) {
  932.     return FLUID_FAILED;
  933.   }
  935.   if (fluid_rampreset_remembervoice(preset, voice) != FLUID_OK) {
  936.     return FLUID_FAILED;
  937.   }
  939.   z = inst_zone;
  941.   /* Instrument level, generators */
  943.   for (i = 0; i < GEN_LAST; i++) {
  945.     /* SF 2.01 section 9.4 'bullet' 4:
  946.      *
  947.      * A generator in a local instrument zone supersedes a
  948.      * global instrument zone generator.  Both cases supersede
  949.      * the default generator -> voice_gen_set */
  951.     if (inst_zone->gen[i].flags){
  952.       fluid_voice_gen_set(voice, i, inst_zone->gen[i].val);
  954.     } else if (global_inst_zone != NULL && global_inst_zone->gen[i].flags){
  955.       fluid_voice_gen_set(voice, i, global_inst_zone->gen[i].val);
  957.     } else {
  958.       /* The generator has not been defined in this instrument.
  959.        * Do nothing, leave it at the default.
  960.        */
  961.     };
  963.   }; /* for all generators */
  965.   /* global instrument zone, modulators: Put them all into a
  966.    * list. */
  968.   mod_list_count = 0;
  970.   if (global_inst_zone){
  971.     mod = global_inst_zone->mod;
  972.     while (mod){
  973.       mod_list[mod_list_count++] = mod;
  974.       mod = mod->next;
  975.     };
  976.   };
  978.   /* local instrument zone, modulators.
  979.    * Replace modulators with the same definition in the list:
  980.    * SF 2.01 page 69, 'bullet' 8
  981.    */
  982.   mod = inst_zone->mod;
  984.   while (mod){
  986.     /* 'Identical' modulators will be deleted by setting their
  987.      *  list entry to NULL.  The list length is known, NULL
  988.      *  entries will be ignored later.  SF2.01 section 9.5.1
  989.      *  page 69, 'bullet' 3 defines 'identical'.  */
  991.     for (i = 0; i < mod_list_count; i++){
  992.       if (fluid_mod_test_identity(mod,mod_list[i])){
  993. mod_list[i] = NULL;
  994.       };
  995.     };
  997.     /* Finally add the new modulator to to the list. */
  998.     mod_list[mod_list_count++] = mod;
  999.     mod = mod->next;
  1000.   };
  1002.   /* Add instrument modulators (global / local) to the voice. */
  1003.   for (i = 0; i < mod_list_count; i++){
  1005.     mod = mod_list[i];
  1007.     if (mod != NULL){ /* disabled modulators CANNOT be skipped. */
  1009.       /* Instrument modulators -supersede- existing (default)
  1010.        * modulators.  SF 2.01 page 69, 'bullet' 6 */
  1011.       fluid_voice_add_mod(voice, mod, FLUID_VOICE_OVERWRITE);
  1012.     };
  1013.   };
  1015.   /* Preset level, generators */
  1017.   for (i = 0; i < GEN_LAST; i++) {
  1019.     /* SF 2.01 section 8.5 page 58: If some generators are
  1020.      * encountered at preset level, they should be ignored */
  1021.     if ((i != GEN_STARTADDROFS)
  1022. && (i != GEN_ENDADDROFS)
  1023. && (i != GEN_STARTLOOPADDROFS)
  1024. && (i != GEN_ENDLOOPADDROFS)
  1025. && (i != GEN_STARTADDRCOARSEOFS)
  1026. && (i != GEN_ENDADDRCOARSEOFS)
  1027. && (i != GEN_STARTLOOPADDRCOARSEOFS)
  1028. && (i != GEN_KEYNUM)
  1029. && (i != GEN_VELOCITY)
  1030. && (i != GEN_ENDLOOPADDRCOARSEOFS)
  1031. && (i != GEN_SAMPLEMODE)
  1032. && (i != GEN_EXCLUSIVECLASS)
  1033. && (i != GEN_OVERRIDEROOTKEY)) {
  1035.       /* SF 2.01 section 9.4 'bullet' 9: A generator in a
  1036.        * local preset zone supersedes a global preset zone
  1037.        * generator.  The effect is -added- to the destination
  1038.        * summing node -> voice_gen_incr */
  1040.       if (preset_zone->gen[i].flags){
  1041. fluid_voice_gen_incr(voice, i, preset_zone->gen[i].val);
  1042.       } else {
  1043. /* The generator has not been defined in this preset
  1044.  * Do nothing, leave it unchanged.
  1045.  */
  1046.       };
  1047.     }; /* if available at preset level */
  1048.   }; /* for all generators */
  1051.   /* Global preset zone, modulators: put them all into a
  1052.    * list. */
  1053.   mod_list_count = 0;
  1055.   /* Process the modulators of the local preset zone.  Kick
  1056.    * out all identical modulators from the global preset zone
  1057.    * (SF 2.01 page 69, second-last bullet) */
  1059.   mod = preset_zone->mod;
  1060.   while (mod){
  1061.     for (i = 0; i < mod_list_count; i++){
  1062.       if (fluid_mod_test_identity(mod,mod_list[i])){
  1063. mod_list[i] = NULL;
  1064.       };
  1065.     };
  1067.     /* Finally add the new modulator to the list. */
  1068.     mod_list[mod_list_count++] = mod;
  1069.     mod = mod->next;
  1070.   };
  1072.   /* Add preset modulators (global / local) to the voice. */
  1073.   for (i = 0; i < mod_list_count; i++){
  1074.     mod = mod_list[i];
  1075.     if ((mod != NULL) && (mod->amount != 0)) { /* disabled modulators can be skipped. */
  1077.       /* Preset modulators -add- to existing instrument /
  1078.        * default modulators.  SF2.01 page 70 first bullet on
  1079.        * page */
  1080.       fluid_voice_add_mod(voice, mod, FLUID_VOICE_ADD);
  1081.     };
  1082.   };
  1084.   /* add the synthesis process to the synthesis loop. */
  1085.   fluid_synth_start_voice(synth, voice);
  1087.   /* Store the ID of the first voice that was created by this noteon event.
  1088.    * Exclusive class may only terminate older voices.
  1089.    * That avoids killing voices, which have just been created.
  1090.    * (a noteon event can create several voice processes with the same exclusive
  1091.    * class - for example when using stereo samples)
  1092.    */
  1093. }
  1095. inst_zone = fluid_inst_zone_next(inst_zone);
  1096.       }
  1097.     }
  1098.     preset_zone = fluid_preset_zone_next(preset_zone);
  1099.   }
  1101.   return FLUID_OK;
  1102. }
  1106. /***************************************************************
  1107.  *
  1108.  *                           SAMPLE
  1109.  */
  1112. /**
  1113.  * Set the name of a RAM SoundFont sample.
  1114.  * @param sample RAM SoundFont sample
  1115.  * @param name Name to assign to sample (20 chars in length, 0 terminated)
  1116.  * @return #FLUID_OK
  1117.  */
  1118. int
  1119. fluid_sample_set_name(fluid_sample_t* sample, const char *name)
  1120. {
  1121.   FLUID_MEMCPY(sample->name, name, 20);
  1122.   return FLUID_OK;
  1123. }
  1125. /**
  1126.  * Assign sample data to a RAM SoundFont sample.
  1127.  * @param sample RAM SoundFont sample
  1128.  * @param data Buffer containing 16 bit audio sample data
  1129.  * @param nbframes Number of samples in a data
  1130.  * @param copy_data TRUE to copy the data, FALSE to use it directly
  1131.  * @param rootkey Root MIDI note of sample (0-127)
  1132.  * @return #FLUID_OK on success, #FLUID_FAILED otherwise
  1133.  *
  1134.  * WARNING: If a copy_data is FALSE, data should have 8 unused frames at start
  1135.  * and 8 unused frames at the end.
  1136.  */
  1137. int
  1138. fluid_sample_set_sound_data (fluid_sample_t* sample, short *data,
  1139.                              unsigned int nbframes, short copy_data, int rootkey)
  1140. {
  1141. /* 16 bit mono 44.1KHz data in */
  1142. /* in all cases, the sample has ownership of the data : it will release it in the end */
  1143. unsigned int storedNbFrames;
  1145. /* in case we already have some data */
  1146.   if (sample->data != NULL) {
  1147.    FLUID_FREE(sample->data);
  1148.   }
  1150. if (copy_data) {
  1152. /* nbframes should be >= 48 (SoundFont specs) */
  1153. storedNbFrames = nbframes;
  1154. if (storedNbFrames < 48) storedNbFrames = 48;
  1156.   sample->data = FLUID_MALLOC(storedNbFrames*2 + 4*SAMPLE_LOOP_MARGIN);
  1157.   if (sample->data == NULL) {
  1158.     FLUID_LOG(FLUID_ERR, "Out of memory");
  1159.     return FLUID_FAILED;
  1160.   }
  1161.   FLUID_MEMSET(sample->data, 0, storedNbFrames*2 + 4*SAMPLE_LOOP_MARGIN);
  1162.   FLUID_MEMCPY((char*)(sample->data) + 2*SAMPLE_LOOP_MARGIN, data, nbframes*2);
  1164. #if 0
  1165.   /* this would do the fill of the margins */
  1166.   FLUID_MEMCPY((char*)(sample->data) + 2*SAMPLE_LOOP_MARGIN + storedNbFrames*2, (char*)data, 2*SAMPLE_LOOP_MARGIN);
  1167.   FLUID_MEMCPY((char*)(sample->data), (char*)data + nbframes*2 - 2*SAMPLE_LOOP_MARGIN, 2*SAMPLE_LOOP_MARGIN);
  1168. #endif
  1170.   /* pointers */
  1171.   /* all from the start of data */
  1172.   sample->start = SAMPLE_LOOP_MARGIN;
  1173.   sample->end = SAMPLE_LOOP_MARGIN + storedNbFrames;
  1174.   } else {
  1175.    /* we cannot assure the SAMPLE_LOOP_MARGIN */
  1176.    sample->data = data;
  1177.   sample->start = 0;
  1178.   sample->end = nbframes;
  1179.   }
  1181.   /* only used as markers for the LOOP generators : set them on the first real frame */
  1182.   sample->loopstart = sample->start;
  1183.   sample->loopend = sample->end;
  1185.   sample->samplerate = 44100;
  1186.   sample->origpitch = rootkey;
  1187.   sample->pitchadj = 0;
  1188.   sample->sampletype = FLUID_SAMPLETYPE_MONO;
  1189.   sample->valid = 1;
  1191.   return FLUID_OK;
  1192. }
  1194. /**
  1195.  * Create new RAM SoundFont sample.
  1196.  * @return New RAM SoundFont sample or NULL if out of memory
  1197.  */
  1198. fluid_sample_t *
  1199. new_fluid_ramsample (void)
  1200. {
  1201. /* same as new_fluid_sample. Only here so that it is exported */
  1202.   fluid_sample_t* sample = NULL;
  1204.   sample = FLUID_NEW(fluid_sample_t);
  1205.   if (sample == NULL) {
  1206.     FLUID_LOG(FLUID_ERR, "Out of memory");
  1207.     return NULL;
  1208.   }
  1210.   memset(sample, 0, sizeof(fluid_sample_t));
  1212.   return sample;
  1213. }
  1215. /**
  1216.  * Delete a RAM SoundFont sample.
  1217.  * @param sample Sample to delete
  1218.  * @return #FLUID_OK
  1219.  */
  1220. int
  1221. delete_fluid_ramsample (fluid_sample_t* sample)
  1222. {
  1223. /* same as delete_fluid_sample, plus frees the data */
  1224.   if (sample->data != NULL) {
  1225.    FLUID_FREE(sample->data);
  1226.   }
  1227.   sample->data = NULL;
  1228.   FLUID_FREE(sample);
  1229.   return FLUID_OK;
  1230. }