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

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

midi

开发平台：

C/C++

fluidmax.c：源码内容
  1. /***************************************************************************************
  2.  *
  3.  *  fluidsynth~
  4.  *
  5.  *  Fluid Synth soundfont synthesizer for Max/MSP.
  6.  *
  7.  *  Fluid Synth is written by Peter Hanappe et al.
  8.  *  see http://www.fluidsynth.org/
  9.  *
  10.  *  Max/MSP integration by Norbert Schnell ATR IRCAM - Centre Pompidou
  11.  *
  12.  *  This program is free software; you can redistribute it and/or
  13.  *  modify it under the terms of the GNU General Public License
  14.  *  as published by the Free Software Foundation; either version 2.1
  15.  *  of the License, or (at your option) any later version.
  16.  *  
  17.  *  See file COPYING.LIB for further informations on licensing terms.
  18.  * 
  19.  *  This program is distributed in the hope that it will be useful,
  20.  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  21.  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  22.  *  GNU General Public License for more details.
  23.  * 
  24.  *  You should have received a copy of the GNU General Public License
  25.  *  along with this program; if not, write to the Free Software
  26.  *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  27.  *
  28.  */
  29.  
  30. /************************************************************************
  31.  *
  32.  *  versions:
  33.  *   (14): adapted to latest code base
  34.  *   (13): ???
  35.  *   (12): fixed voice stealing
  36.  *   (11): fixed arguments of fluidmax_tuning_octave() (third has to be float)
  37.  *   (10): added micro-tuning methods
  38.  *    (9): bug fix: now polyphony and # of midi channel arguments take effect
  39.  *    (8): added message resample permitting to chose resampling interpolation method
  40.  *    (7): added names for soundfonts (== file name without path and postfix)
  41.  *    (6): added message 'info'
  42.  *    (5): fixed bogus path translation at file loading
  43.  * 
  44.  */
  45. #define FLUIDMAX_VERSION "01/2009 (14)"
  47. #include "ftmax.h"
  48. #include "fluidsynth.h"
  49. #include "fluid_synth.h"
  50. #include "fluid_sfont.h"
  51. #include "fluid_chan.h"
  52. #include "fluidsynth/version.h"
  54. typedef struct
  55. {
  56.   ftmax_dsp_object_t obj;
  57.   
  58.   fluid_synth_t *synth;
  59.   fluid_settings_t *settings;
  60.   int reverb;
  61.   int chorus;
  62.   int mute;
  63.   void *outlet;
  64. } fluidmax_t;
  66. static t_messlist *fluidmax_class;
  68. static ftmax_symbol_t sym_on = NULL;
  69. static ftmax_symbol_t sym_off = NULL;
  70. static ftmax_symbol_t sym_undefined = NULL;
  71. static ftmax_symbol_t sym_gain = NULL;
  72. static ftmax_symbol_t sym_channels = NULL;
  73. static ftmax_symbol_t sym_channel = NULL;
  74. static ftmax_symbol_t sym_soundfonts = NULL;
  75. static ftmax_symbol_t sym_soundfont = NULL;
  76. static ftmax_symbol_t sym_presets = NULL;
  77. static ftmax_symbol_t sym_preset = NULL;
  78. static ftmax_symbol_t sym_reverb = NULL;
  79. static ftmax_symbol_t sym_chorus = NULL;
  80. static ftmax_symbol_t sym_polyphony = NULL;
  81. static ftmax_symbol_t sym_nearest = NULL;
  82. static ftmax_symbol_t sym_linear = NULL;
  83. static ftmax_symbol_t sym_cubic = NULL;
  84. static ftmax_symbol_t sym_sinc = NULL;
  86. /***************************************************************
  87.  *
  88.  *  generators
  89.  *
  90.  */
  91. typedef struct
  92. {
  93.   int index;
  94.   const char *name;
  95.   const char *unit;
  96. } fluidmax_gen_descr_t; 
  98. static fluidmax_gen_descr_t fluidmax_gen_info[] =
  99. {
  100.   {0, "startAddrsOffset", "samples"}, 
  101.   {1, "endAddrsOffset", "samples"}, 
  102.   {2, "startloopAddrsOffset", "samples"}, 
  103.   {3, "endloopAddrsOffset", "samples"}, 
  104.   {4, "startAddrsCoarseOffset", "32k samples"}, 
  105.   {5, "modLfoToPitch", "cent fs"}, 
  106.   {6, "vibLfoToPitch", "cent fs"}, 
  107.   {7, "modEnvToPitch", "cent fs"}, 
  108.   {8, "initialFilterFc", "cent 8.176 Hz"}, 
  109.   {9, "initialFilterQ", "cB"}, 
  110.   {10, "modLfoToFilterFc", "cent fs"}, 
  111.   {11, "modEnvToFilterFc", "cent fs "}, 
  112.   {12, "endAddrsCoarseOffset", "32k samples"}, 
  113.   {13, "modLfoToVolume", "cB fs"}, 
  114.   {14, "unused1", ""}, 
  115.   {15, "chorusEffectsSend", "0.1%"}, 
  116.   {16, "reverbEffectsSend", "0.1% "}, 
  117.   {17, "pan", "0.1%"}, 
  118.   {18, "unused2", ""}, 
  119.   {19, "unused3", ""}, 
  120.   {20, "unused4", ""}, 
  121.   {21, "delayModLFO", "timecent"}, 
  122.   {22, "freqModLFO", "cent 8.176 "}, 
  123.   {23, "delayVibLFO", "timecent "}, 
  124.   {24, "freqVibLFO", "cent 8.176"}, 
  125.   {25, "delayModEnv", "timecent"}, 
  126.   {26, "attackModEnv", "timecent "}, 
  127.   {27, "holdModEnv", "timecent"}, 
  128.   {28, "decayModEnv", "timecent"}, 
  129.   {29, "sustainModEnv", "-0.1%"}, 
  130.   {30, "releaseModEnv", "timecent"}, 
  131.   {31, "keynumToModEnvHold", "tcent/key"}, 
  132.   {32, "keynumToModEnvDecay", "tcent/key"}, 
  133.   {33, "delayVolEnv", "timecent"}, 
  134.   {34, "attackVolEnv", "timecent"}, 
  135.   {35, "holdVolEnv", "timecent"}, 
  136.   {36, "decayVolEnv", "timecent"}, 
  137.   {37, "sustainVolEnv", "cB"}, 
  138.   {38, "releaseVolEnv", "timecent "}, 
  139.   {39, "keynumToVolEnvHold", "tcent/key"}, 
  140.   {40, "keynumToVolEnvDecay", "tcent/key "}, 
  141.   {41, "instrument", ""}, 
  142.   {42, "reserved1", ""}, 
  143.   {43, "keyRange MIDI", ""},  
  144.   {44, "velRange MIDI", ""}, 
  145.   {45, "startloopAddrsCoarseOffset", "samples"}, 
  146.   {46, "keynum MIDI", ""}, 
  147.   {47, "velocity MIDI", ""}, 
  148.   {48, "initialAttenuation", "cB"}, 
  149.   {49, "reserved2", ""}, 
  150.   {50, "endloopAddrsCoarseOffset", "samples"}, 
  151.   {51, "coarseTune", "semitone"}, 
  152.   {52, "fineTune", "cent"}, 
  153.   {53, "sampleId", ""}, 
  154.   {54, "sampleModes", "Bit Flags"}, 
  155.   {55, "reserved3", ""}, 
  156.   {56, "scaleTuning", "cent/key"}, 
  157.   {57, "exclusiveClass", "arbitrary#"}, 
  158.   {58, "unused5", ""},
  159.   {59, "unused6", ""},
  160.   {60, "unused7", ""},
  161.   {61, "unused8", ""},
  162.   {62, "unused9", ""},
  163.   {63, "unused10", ""}
  164. };
  166. /***************************************************************
  167.  *
  168.  *  dsp
  169.  *
  170.  */
  171. static t_int *
  172. fluidmax_perform(t_int *w)
  173. {
  174.   fluidmax_t *self = (fluidmax_t *)(w[1]);
  175.   t_float *left = (t_float *)(w[2]);
  176.   t_float *right = (t_float *)(w[3]);
  177.   int n_tick = (int)(w[4]);
  179.   if(self->mute == 0)
  180.     fluid_synth_write_float(self->synth, n_tick, left, 0, 1, right, 0, 1);
  181.  else
  182.  {
  183.   int i;
  184.   
  185.   for(i=0; i<n_tick; i++)
  186.     left[i] = right[i] = 0.0;
  187.  }
  188.   
  189.   return (w + 5);
  190. }
  192. static void 
  193. fluidmax_dsp(fluidmax_t *self, t_signal **sp, short *count)
  194. {
  195.   int n_tick = sp[0]->s_n;
  196.         
  197.   dsp_add(fluidmax_perform, 4, self, sp[0]->s_vec, sp[1]->s_vec, n_tick);
  198. }
  200. /***************************************************************
  201.  *
  202.  *  load utlilities
  203.  *
  204.  */
  205. static char *
  206. fluidmax_translate_fullpath(char *maxpath, char *fullpath)
  207. {
  208.   int i;
  210.   strcpy(fullpath, "/Volumes/");
  211.   
  212.   for(i=0; maxpath[i] != ':'; i++)
  213.     fullpath[i + 9] = maxpath[i];
  214.     
  215.   /* skip ':' */
  216.   i++;
  217.     
  218.   strcpy(fullpath + i + 8, maxpath + i);
  219.   
  220.   return fullpath;
  221. }
  222.     
  223. static ftmax_symbol_t
  224. fluidmax_get_stripped_name(const char *fullpath)
  225. {
  226.   char stripped[1024];
  227.   int i;
  228.   
  229.   for(i=strlen(fullpath)-1; i>=0; i--)
  230.   {
  231.     if(fullpath[i] == '/')
  232.       break;
  233.   }
  234.   
  235.   if(i != 0)
  236.     i++;    
  237.   
  238.   strcpy(stripped, fullpath + i);
  239.   
  240.   for(i=0; stripped[i] != ''; i++)
  241.   {
  242.     if((stripped[i] == '.') && 
  243.        (stripped[i + 1] == 's' || stripped[i + 1] == 'S') && 
  244.        (stripped[i + 2] == 'f' || stripped[i + 2] == 'F') && 
  245.        (stripped[i + 3] == '2'))
  246.     {
  247.       stripped[i] = '';
  248.       break;
  249.     }
  250.   }
  251.   
  252.   return ftmax_new_symbol(stripped);
  253. }
  254.     
  255. static ftmax_symbol_t
  256. fluidmax_sfont_get_name(fluid_sfont_t *sfont)
  257. {
  258.   return fluidmax_get_stripped_name(fluid_sfont_get_name(sfont));
  259. }
  260.     
  261. static fluid_sfont_t *
  262. fluidmax_sfont_get_by_name(fluidmax_t *self, ftmax_symbol_t name)
  263. {
  264.   int n = fluid_synth_sfcount(self->synth);
  265.   int i;
  266.   
  267.   for(i=0; i<n; i++)
  268.   {
  269.     fluid_sfont_t *sfont = fluid_synth_get_sfont(self->synth, i);
  271.     if(fluidmax_sfont_get_name(sfont) == name)
  272.       return sfont;
  273.   }
  275.   return NULL;
  276. }
  278. static void 
  279. fluidmax_do_load(t_object *o, Symbol *s, short ac, Atom *at)
  280. {
  281.   fluidmax_t *self = (fluidmax_t *)o;
  282.   
  283.   if(ac > 0 && ftmax_is_symbol(at))  
  284.   {
  285.     const char *filename = ftmax_symbol_name(ftmax_get_symbol(at));
  286.     ftmax_symbol_t name = fluidmax_get_stripped_name(filename);
  287.     fluid_sfont_t *sf = fluidmax_sfont_get_by_name(self, name);
  288.     
  289.     if(sf == NULL)
  290.     {
  291.       int id = fluid_synth_sfload(self->synth, filename, 0);
  292.     
  293.       if(id >= 0)
  294.       {
  295.         post("fluidsynth~: loaded soundfont '%s' (id %d)", ftmax_symbol_name(name), id);
  297.         fluid_synth_program_reset(self->synth);
  298.         
  299.         outlet_bang(self->outlet);
  300.       }
  301.       else
  302.         error("fluidsynth~: cannot load soundfont from file '%s'", filename);
  303.     }
  304.     else
  305.     {
  306.       error("fluidsynth~: soundfont named '%s' is already loaded", ftmax_symbol_name(name));
  307.       return;
  308.     }
  309.   }
  310. }
  312. static void
  313. fluidmax_load_with_dialog(t_object *o, t_symbol *s, short argc, t_atom *argv)
  314. {
  315.   char filename[256];
  316.   char maxpath[1024];
  317.   char fullpath[1024];
  318.   long type;
  319.   short path;
  320.   
  321.   open_promptset("open SoundFont 2 file");
  322.   
  323.   if(open_dialog(filename, &path, &type, 0, 0))
  324.     return;
  325.     
  326.   if(path_topotentialname(path, filename, maxpath, 0) == 0)
  327.   {
  328.     ftmax_atom_t a;
  329.     
  330.     ftmax_set_symbol(&a, ftmax_new_symbol(fluidmax_translate_fullpath(maxpath, fullpath)));
  331.     fluidmax_do_load(o, NULL, 1, &a);
  332.   }
  333. }  
  335. /***************************************************************
  336.  *
  337.  *  user methods
  338.  *
  339.  */
  340. static void 
  341. fluidmax_load(t_object *o, Symbol *s, short ac, Atom *at)
  342. { 
  343.   if(ac == 0)
  344.     defer(o, (method)fluidmax_load_with_dialog, NULL, 0, 0);
  345.   else
  346.   {
  347.     if(ftmax_is_symbol(at))
  348.     {
  349.       ftmax_symbol_t name = ftmax_get_symbol(at);
  350.       char *string = (char *)ftmax_symbol_name(name);
  351.       
  352.       if(string[0] == '/')
  353.         defer(o, (method)fluidmax_do_load, NULL, ac, at);
  354.       else
  355.       {
  356.         char maxpath[1024];
  357.         char fullpath[1024];
  358.         short path;
  359.         long type;
  360.         ftmax_atom_t a;
  361.         
  362.         if(locatefile_extended(string, &path, &type, 0, 0) || path_topotentialname(path, string, maxpath, 0) != 0)
  363.         {
  364.           error("fluidsynth~: cannot find file '%s'", string);
  365.           return;
  366.         }
  367.         
  368.         ftmax_set_symbol(&a, ftmax_new_symbol(fluidmax_translate_fullpath(maxpath, fullpath)));
  369.         defer(o, (method)fluidmax_do_load, NULL, 1, &a);
  370.       }
  371.     }
  372.   }
  373. }
  375. static void 
  376. fluidmax_unload(t_object *o, Symbol *s, short ac, Atom *at)
  377. {
  378.   fluidmax_t *self = (fluidmax_t *)o;
  379.   
  380.   if(ac > 0)
  381.   {
  382.     if(ftmax_is_number(at))  
  383.     {
  384.       int id = ftmax_get_number_int(at);
  385.       fluid_sfont_t *sf = fluid_synth_get_sfont_by_id(self->synth, id);
  386.       
  387.       if(sf != NULL)
  388.       {  
  389.         ftmax_symbol_t name = fluidmax_sfont_get_name(sf);
  390.         
  391.         if(fluid_synth_sfunload(self->synth, id, 0) >= 0)
  392.         {
  393.           post("fluidsynth~: unloaded soundfont '%s' (id %d)", ftmax_symbol_name(name), id);
  394.           return;
  395.         }
  396.       }
  397.             
  398.       error("fluidsynth~: cannot unload soundfont %d", id);
  399.     }
  400.     else if (ftmax_is_symbol(at))
  401.     {
  402.       ftmax_symbol_t sym = ftmax_get_symbol(at);
  403.       
  404.       if(sym == ftmax_new_symbol("all"))
  405.       {
  406.         fluid_sfont_t *sf = fluid_synth_get_sfont(self->synth, 0);
  407.         
  408.         fluid_synth_system_reset(self->synth);
  410.         while(sf != NULL)
  411.         {
  412.           ftmax_symbol_t name = fluidmax_sfont_get_name(sf);
  413.           unsigned int id = fluid_sfont_get_id(sf);
  414.         
  415.           if(fluid_synth_sfunload(self->synth, id, 0) >= 0)
  416.             post("fluidsynth~: unloaded soundfont '%s' (id %d)", ftmax_symbol_name(name), id);
  417.           else
  418.             error("fluidsynth~: cannot unload soundfont '%s' (id %d)", ftmax_symbol_name(name), id);
  419.         
  420.           sf = fluid_synth_get_sfont(self->synth, 0);
  421.         }
  422.       }
  423.       else
  424.       {
  425.         fluid_sfont_t *sf = fluidmax_sfont_get_by_name(self, sym);
  426.         
  427.         if(sf != NULL)
  428.         {
  429.           unsigned int id = fluid_sfont_get_id(sf);
  430.           
  431.           if(fluid_synth_sfunload(self->synth, id, 0) >= 0)
  432.           {
  433.             post("fluidsynth~: unloaded soundfont '%s' (id %d)", ftmax_symbol_name(sym), id);
  434.             return;
  435.           }
  436.         }
  437.         
  438.         error("fluidsynth~: cannot unload soundfont '%s'", ftmax_symbol_name(sym));
  439.       }
  440.     }
  441.   }
  442. }
  444. static void 
  445. fluidmax_reload(t_object *o, Symbol *s, short ac, Atom *at)
  446. {
  447.   fluidmax_t *self = (fluidmax_t *)o;
  448.   
  449.   if(ac > 0)
  450.   {
  451.     if(ftmax_is_number(at))  
  452.     {
  453.       int id = ftmax_get_number_int(at);
  454.       fluid_sfont_t *sf = fluid_synth_get_sfont_by_id(self->synth, id);
  455.       
  456.       if(sf != NULL)
  457.       {
  458.         if (fluid_synth_sfreload(self->synth, id) >= 0)
  459.         {
  460.           post("fluidsynth~: reloaded soundfont '%s' (id %d)", id);
  461.           return;
  462.         }
  464.         error("fluidsynth~: cannot reload soundfont %d", id);
  465.       }
  466.     }
  467.     else if (ftmax_is_symbol(at))
  468.     {
  469.       ftmax_symbol_t sym = ftmax_get_symbol(at);
  470.       
  471.       if(sym == ftmax_new_symbol("all"))
  472.       {
  473.         int n = fluid_synth_sfcount(self->synth);
  474.         int i;
  475.         
  476.         fluid_synth_system_reset(self->synth);
  478.         for(i=0; i<n; i++)
  479.         {
  480.           fluid_sfont_t *sf = fluid_synth_get_sfont(self->synth, i);
  481.           ftmax_symbol_t name = fluidmax_sfont_get_name(sf);
  482.           unsigned int id = fluid_sfont_get_id(sf);
  483.           
  484.         
  485.           if (fluid_synth_sfreload(self->synth, id) >= 0)
  486.             post("fluidsynth~: reloaded soundfont '%s' (id %d)", ftmax_symbol_name(name), id);
  487.           else
  488.             error("fluidsynth~: cannot reload soundfont '%s' (id %d)", ftmax_symbol_name(name), id);
  489.         }
  490.       }
  491.       else
  492.       {
  493.         fluid_sfont_t *sf = fluidmax_sfont_get_by_name(self, sym);
  494.         
  495.         if(sf != NULL)
  496.         {
  497.           unsigned int id = fluid_sfont_get_id(sf);
  498.           
  499.           if(fluid_synth_sfreload(self->synth, id) >= 0)
  500.           {
  501.             post("fluidsynth~: reloaded soundfont '%s' (id %d)", ftmax_symbol_name(sym), id);
  502.             return;
  503.           }
  504.         }
  505.         
  506.         error("fluidsynth~: cannot reload soundfont '%s'", ftmax_symbol_name(sym));
  507.       }
  508.     }
  509.   }
  510. }
  512. static void 
  513. fluidmax_note(t_object *o, Symbol *s, short ac, Atom *at)
  514. {
  515.   fluidmax_t *self = (fluidmax_t *)o;
  516.   
  517.   if(ac > 0 && ftmax_is_number(at))
  518.   {
  519.     int velocity = 64;
  520.     int channel = 1;
  521.     
  522.     switch(ac)
  523.     {
  524.       default:
  525.       case 3:
  526.         if(ftmax_is_number(at + 2))
  527.         {
  528.           channel = ftmax_get_number_int(at + 2);
  529.                     
  530.           if(channel < 1)
  531.             channel = 1;
  532.           else if(channel > fluid_synth_count_midi_channels(self->synth))
  533.             channel = fluid_synth_count_midi_channels(self->synth);
  534.         }
  535.       case 2:
  536.         if(ftmax_is_number(at + 1))
  537.           velocity = ftmax_get_number_int(at + 1);
  538.       case 1:
  539.         fluid_synth_noteon(self->synth, channel - 1, ftmax_get_number_int(at), velocity);
  540.       case 0:
  541.         break;
  542.     }
  543.   }
  544. }
  546. static void 
  547. fluidmax_list(t_object *o, Symbol *s, short ac, Atom *at)
  548. {
  549.   fluidmax_note(o, NULL, ac, at);
  550. }
  553. static void 
  554. fluidmax_control_change(t_object *o, Symbol *s, short ac, Atom *at)
  555. {
  556.   fluidmax_t *self = (fluidmax_t *)o;
  557.   
  558.   if(ac > 0 && ftmax_is_number(at))
  559.   {
  560.     int value = 64;
  561.     int channel = 1;
  562.     
  563.     switch(ac)
  564.     {
  565.       default:
  566.       case 3:
  567.         if(ftmax_is_number(at + 2))
  568.         {
  569.           channel = ftmax_get_number_int(at + 2);
  570.           
  571.           if(channel < 1)
  572.             channel = 1;
  573.           else if(channel > fluid_synth_count_midi_channels(self->synth))
  574.             channel = fluid_synth_count_midi_channels(self->synth);
  575.         }
  576.       case 2:
  577.         if(ftmax_is_number(at + 1))
  578.           value = ftmax_get_number_int(at + 1);
  579.       case 1:
  580.         fluid_synth_cc(self->synth, channel - 1, ftmax_get_number_int(at), value);
  581.       case 0:
  582.         break;
  583.     }
  584.   }
  585. }
  587. static void 
  588. fluidmax_mod(t_object *o, Symbol *s, short ac, Atom *at)
  589. {
  590.   fluidmax_t *self = (fluidmax_t *)o;
  591.   
  592.   if(ac > 1 && ftmax_is_number(at) && ftmax_is_number(at + 1))
  593.   {
  594.     int param = ftmax_get_number_int(at);
  595.     float value = ftmax_get_number_float(at + 1);
  596.     int channel = 1;
  597.     
  598.     if(ac > 2 && ftmax_is_number(at + 2))
  599.     {
  600.       channel = ftmax_get_number_int(at + 2);
  601.       
  602.       if(channel < 1)
  603.         channel = 1;
  604.       else if(channel > fluid_synth_count_midi_channels(self->synth))
  605.         channel = fluid_synth_count_midi_channels(self->synth);
  606.     }
  608.     fluid_synth_set_gen(self->synth, channel - 1, param, value);
  609.   }
  610. }
  612. static void 
  613. fluidmax_pitch_bend(t_object *o, Symbol *s, short ac, Atom *at)
  614. {  
  615.   fluidmax_t *self = (fluidmax_t *)o;
  616.   
  617.   if(ac > 0 && ftmax_is_number(at))
  618.   {
  619.     int channel = 1;
  620.     double bend = 0.0;
  621.     
  622.     if(ac > 1 && ftmax_is_number(at + 1))
  623.     {
  624.       channel = ftmax_get_number_int(at + 1);
  625.           
  626.       if(channel < 1)
  627.         channel = 1;
  628.       else if(channel > fluid_synth_count_midi_channels(self->synth))
  629.         channel = fluid_synth_count_midi_channels(self->synth);
  630.     }
  631.       
  632.     bend = ftmax_get_number_float(at);
  633.     
  634.     if(bend < 0.0)
  635.       bend = 0.0;
  636.     else if(bend > 127.0)
  637.       bend = 127.0;
  638.   
  639.     fluid_synth_pitch_bend(self->synth, channel - 1, (int)(bend * 128.0));
  640.   }
  641. }
  643. static void 
  644. fluidmax_pitch_bend_wheel(t_object *o, Symbol *s, short ac, Atom *at)
  645. {  
  646.   fluidmax_t *self = (fluidmax_t *)o;
  647.   
  648.   if(ac > 0 && ftmax_is_number(at))
  649.   {
  650.     int channel = 1;
  651.     
  652.     if(ac > 1 && ftmax_is_number(at + 1))
  653.       channel = ftmax_get_number_int(at + 1);
  654.       
  655.     fluid_synth_pitch_wheel_sens(self->synth, channel - 1, ftmax_get_number_int(at));
  656.   }
  657. }
  659. static void 
  660. fluidmax_program_change(t_object *o, Symbol *s, short ac, Atom *at)
  661. {  
  662.   fluidmax_t *self = (fluidmax_t *)o;
  663.   
  664.   if(ac > 0 && ftmax_is_number(at))
  665.   {
  666.     int channel = 1;
  667.     
  668.     if(ac > 1 && ftmax_is_number(at + 1))
  669.     {
  670.       channel = ftmax_get_number_int(at + 1);
  671.           
  672.       if(channel < 1)
  673.         channel = 1;
  674.       else if(channel > fluid_synth_count_midi_channels(self->synth))
  675.         channel = fluid_synth_count_midi_channels(self->synth);
  676.     }
  677.       
  678.     fluid_synth_program_change(self->synth, channel - 1, ftmax_get_number_int(at));
  679.   }
  680. }
  682. static void 
  683. fluidmax_bank_select(t_object *o, Symbol *s, short ac, Atom *at)
  684. {
  685.   fluidmax_t *self = (fluidmax_t *)o;
  686.   
  687.   if(ac > 0 && ftmax_is_number(at))
  688.   {
  689.     int channel = 1;
  690.     unsigned int sf_id;
  691.     unsigned int bank_num;
  692.     unsigned int prog_num;
  693.     
  694.     if(ac > 1 && ftmax_is_number(at + 1))
  695.     {
  696.       channel = ftmax_get_number_int(at + 1);
  697.           
  698.       if(channel < 1)
  699.         channel = 1;
  700.       else if(channel > fluid_synth_count_midi_channels(self->synth))
  701.         channel = fluid_synth_count_midi_channels(self->synth);
  702.     }
  703.       
  704.     fluid_synth_bank_select(self->synth, channel - 1, ftmax_get_number_int(at));
  705.     fluid_synth_get_program(self->synth, channel - 1, &sf_id, &bank_num, &prog_num);
  706.     fluid_synth_program_change(self->synth, channel - 1, prog_num);
  707.   }
  708. }
  710. static void 
  711. fluidmax_select(t_object *o, Symbol *s, short ac, Atom *at)
  712. {
  713.   fluidmax_t *self = (fluidmax_t *)o;
  714.   unsigned int bank = 0;
  715.   unsigned int preset = 0;  
  716.   int channel = 1;
  717.   
  718.   switch(ac)
  719.   {
  720.     default:
  721.     case 4:
  722.       if(ftmax_is_number(at + 3))
  723.         channel = ftmax_get_number_int(at + 3);
  725.       if(channel < 1)
  726.         channel = 1;
  727.       else if(channel > fluid_synth_count_midi_channels(self->synth))
  728.         channel = fluid_synth_count_midi_channels(self->synth);
  729.         
  730.     case 3:
  731.       if(ftmax_is_number(at + 2))
  732.         preset = ftmax_get_number_int(at + 2);
  733.         
  734.     case 2:
  735.       if(ftmax_is_number(at + 1))
  736.         bank = ftmax_get_number_int(at + 1);
  737.         
  738.     case 1:
  739.       if(ftmax_is_number(at))
  740.         fluid_synth_program_select(self->synth, channel - 1, ftmax_get_number_int(at), bank, preset);
  741.       else if(ftmax_is_symbol(at))
  742.       {
  743.         ftmax_symbol_t name = ftmax_get_symbol(at);
  744.         fluid_sfont_t *sf = fluidmax_sfont_get_by_name(self, name);
  745.         
  746.         if(sf != NULL)
  747.           fluid_synth_program_select(self->synth, channel - 1, fluid_sfont_get_id(sf), bank, preset);
  748.         else
  749.           error("fluidsynth~ select:蔯annot find soundfont named '%s'", ftmax_symbol_name(name));
  750.       }
  751.     case 0:
  752.       break;
  753.   }
  754. }
  756. static void 
  757. fluidmax_reverb(t_object *o, Symbol *s, short ac, Atom *at)
  758. {
  759.   fluidmax_t *self = (fluidmax_t *)o;
  760.   
  761.   if(ac == 0)
  762.   {
  763.     fluid_synth_set_reverb_on(self->synth, 1);
  764.     fluid_revmodel_reset(self->synth->reverb);
  765.     self->reverb = 1;
  766.   }
  767.   else if(ftmax_is_number(at))
  768.   {
  769.     double room = fluid_synth_get_reverb_roomsize(self->synth);
  770.     double damping = fluid_synth_get_reverb_damp(self->synth);
  771.     double width = fluid_synth_get_reverb_width(self->synth);
  773.     fluid_synth_set_reverb_on(self->synth, 1);
  774.     self->reverb = 1;
  775.     
  776.     switch(ac)
  777.     {
  778.       default:
  779.       case 4:
  780.         if(ftmax_is_number(at + 3))
  781.           width = ftmax_get_number_float(at + 3);
  782.       case 3:
  783.         if(ftmax_is_number(at + 2))
  784.           damping = ftmax_get_number_float(at + 2);
  785.       case 2:
  786.         if(ftmax_is_number(at + 1))
  787.           room = ftmax_get_number_float(at + 1);
  788.       case 1:
  789.         fluid_synth_set_reverb(self->synth, room, damping, width, ftmax_get_number_float(at));
  790.       case 0:
  791.         break;
  792.     }
  793.   }
  794.   else if(ftmax_is_symbol(at))
  795.   {
  796.     ftmax_symbol_t sym = ftmax_get_symbol(at);
  797.     
  798.     if(sym == sym_on)
  799.     {
  800.       fluid_synth_set_reverb_on(self->synth, 1);
  801.       self->reverb = 1;
  802.     }
  803.     else if(sym == sym_off)
  804.     {
  805.       fluid_synth_set_reverb_on(self->synth, 0);
  806.       self->reverb = 0;
  807.     }
  808.   }
  809. }
  811. static void 
  812. fluidmax_chorus(t_object *o, Symbol *s, short ac, Atom *at)
  813. {
  814.   fluidmax_t *self = (fluidmax_t *)o;
  815.   
  816.   if(ac == 0)
  817.   {
  818.     fluid_synth_set_chorus_on(self->synth, 1);
  819.     fluid_chorus_reset(self->synth->chorus);
  820.     self->chorus = 1;
  821.   }
  822.   else if(ftmax_is_number(at))
  823.   {
  824.     double speed = fluid_synth_get_chorus_speed_Hz(self->synth);
  825.     double depth = fluid_synth_get_chorus_depth_ms(self->synth);
  826.     int type = fluid_synth_get_chorus_type(self->synth);
  827.     int nr = fluid_synth_get_chorus_nr(self->synth);
  829.     fluid_synth_set_chorus_on(self->synth, 1);
  830.     self->chorus = 1;
  832.     switch(ac)
  833.     {
  834.       default:
  835.       case 5:
  836.         if(ftmax_is_number(at + 4))
  837.           nr = ftmax_get_number_int(at + 4);
  838.       case 4:
  839.         if(ftmax_is_number(at + 3))
  840.           type = ftmax_get_number_int(at + 3);
  841.       case 3:
  842.         if(ftmax_is_number(at + 2))
  843.           depth = ftmax_get_number_float(at + 2);
  844.       case 2:
  845.         if(ftmax_is_number(at + 1))
  846.           speed = ftmax_get_number_float(at + 1);
  847.       case 1:
  848.         fluid_synth_set_chorus(self->synth, nr, ftmax_get_number_float(at), speed, depth, type);
  849.       case 0:
  850.         break;
  851.     }
  852.   }
  853.   else if(ftmax_is_symbol(at))
  854.   {
  855.     ftmax_symbol_t sym = ftmax_get_symbol(at);
  856.     
  857.     if(sym == sym_on)
  858.     {
  859.       fluid_synth_set_chorus_on(self->synth, 1);
  860.       self->chorus = 1;
  861.     }
  862.     else if(sym == sym_off)
  863.     {
  864.       fluid_synth_set_chorus_on(self->synth, 0);
  865.       self->chorus = 0;
  866.     }
  867.   }
  868. }
  870. static void 
  871. fluidmax_set_gain(t_object *o, Symbol *s, short ac, Atom *at)
  872. {
  873.   fluidmax_t *self = (fluidmax_t *)o;
  874.   
  875.   if(ac > 0 && ftmax_is_number(at))
  876.   {
  877.     float gain = ftmax_get_number_float(at);
  878.     
  879.     fluid_synth_set_gain(self->synth, gain);
  880.   }
  881. }
  883. static void 
  884. fluidmax_set_resampling_method(t_object *o, Symbol *s, short ac, Atom *at)
  885. {
  886.   fluidmax_t *self = (fluidmax_t *)o;
  887.   
  888.   if(ac > 0)
  889.   {
  890.     if(ftmax_is_number(at))
  891.     {
  892.       int ip = ftmax_get_int(at);
  893.       
  894.       if(ip == 0)
  895.         fluid_synth_set_interp_method(self->synth, -1, FLUID_INTERP_NONE);
  896.       else if(ip < 3)
  897.         fluid_synth_set_interp_method(self->synth, -1, FLUID_INTERP_LINEAR);
  898.       else if(ip < 6)
  899.         fluid_synth_set_interp_method(self->synth, -1, FLUID_INTERP_4THORDER);
  900.       else
  901.         fluid_synth_set_interp_method(self->synth, -1, FLUID_INTERP_7THORDER);
  902.     }
  903.     else if(ftmax_is_symbol(at))
  904.     {
  905.       ftmax_symbol_t sym = ftmax_get_symbol(at);
  906.       
  907.       if(sym == sym_nearest)
  908.         fluid_synth_set_interp_method(self->synth, -1, FLUID_INTERP_NONE);
  909.       else if(sym == sym_linear)
  910.         fluid_synth_set_interp_method(self->synth, -1, FLUID_INTERP_LINEAR);
  911.       else if(sym == sym_cubic)
  912.         fluid_synth_set_interp_method(self->synth, -1, FLUID_INTERP_4THORDER);
  913.       else if(sym == sym_sinc)
  914.         fluid_synth_set_interp_method(self->synth, -1, FLUID_INTERP_7THORDER);      
  915.       else
  916.         error("fluidsynth~: undefined resampling method: %s", ftmax_symbol_name(sym));
  917.     }
  918.   }
  919. }
  921. static void 
  922. fluidmax_panic(t_object *o, Symbol *s, short ac, Atom *at)
  923. {
  924.   fluidmax_t *self = (fluidmax_t *)o;
  926.   fluid_synth_system_reset(self->synth);
  927. }
  929. static void 
  930. fluidmax_reset(t_object *o, Symbol *s, short ac, Atom *at)
  931. {
  932.   fluidmax_t *self = (fluidmax_t *)o;
  933.   int n = fluid_synth_count_midi_channels(self->synth);
  934.   int i;
  936.   for (i=0; i<n; i++)
  937.     fluid_channel_reset(self->synth->channel[i]);
  938. }
  940. static void 
  941. fluidmax_mute(t_object *o, Symbol *s, short ac, Atom *at)
  942. {
  943.   fluidmax_t *self = (fluidmax_t *)o;
  944.   int mute = 1;
  945.   
  946.   if(ac > 0 && ftmax_is_number(at))
  947.     mute = (ftmax_get_number_int(at) != 0);
  948.   
  949.   fluid_synth_system_reset(self->synth);
  950.    
  951.   self->mute = mute;
  952. }
  954. static void 
  955. fluidmax_unmute(t_object *o)
  956. {
  957.   ftmax_atom_t a;
  958.   
  959.   ftmax_set_int(&a, 0);  
  960.   fluidmax_mute(o, NULL, 1, &a);
  961. }
  963. /* 
  964. int fluid_synth_count_audio_channels (fluid_synth_t *synth)
  965. int fluid_synth_count_audio_groups (fluid_synth_t *synth)
  966. int fluid_synth_count_effects_channels (fluid_synth_t *synth)
  967. */
  969. static void 
  970. fluidmax_tuning_octave(t_object *o, Symbol *s, short ac, Atom *at)
  971. {
  972.   fluidmax_t *self = (fluidmax_t *)o;
  973.   ftmax_symbol_t name;
  974.   int tuning_bank = 0;
  975.   int tuning_prog = 0;
  976.   double pitch[12];
  977.   int i, n;
  978.   
  979.   if(ac > 0 && ftmax_is_symbol(at))
  980.   {
  981.     name = ftmax_get_symbol(at);
  982.     at++;
  983.     ac--;
  984.   }
  985.   
  986.   n = ac - 2;
  987.   if(n > 12)
  988.     n = 12;
  990.   if(ac > 0 && ftmax_is_number(at))
  991.     tuning_bank = ftmax_get_number_int(at) % 128;
  992.   
  993.   if(ac > 1 && ftmax_is_number(at + 1))
  994.     tuning_prog = ftmax_get_number_int(at) % 128;
  995.     
  996.   for(i=0; i<n; i++)
  997.   {
  998.     if(ftmax_is_number(at + i + 2))
  999.       pitch[i] = ftmax_get_number_float(at + i + 2);
  1000.     else
  1001.       pitch[i] = 0.0;
  1002.   }
  1003.   
  1004.   for(; i<12; n++)
  1005.     pitch[i] = 0.0;
  1007.   fluid_synth_create_octave_tuning(self->synth, tuning_bank, tuning_prog, ftmax_symbol_name(name), pitch);
  1008. }
  1010. static void 
  1011. fluidmax_tuning_select(t_object *o, Symbol *s, short ac, Atom *at)
  1012. {
  1013.   fluidmax_t *self = (fluidmax_t *)o;
  1014.   int tuning_bank = 0;
  1015.   int tuning_prog = 0;
  1016.   int channel = 1;
  1017.   
  1018.   if(ac > 0 && ftmax_is_number(at))
  1019.     tuning_bank = ftmax_get_number_int(at) % 128;
  1020.     
  1021.   if(ac > 1 && ftmax_is_number(at + 1))
  1022.     tuning_prog = ftmax_get_number_int(at + 1) % 128;
  1023.   
  1024.   if(ac > 2 && ftmax_is_number(at + 2))
  1025.     channel = ftmax_get_number_int(at + 2);
  1026.     
  1027.   if(channel < 1)
  1028.     channel = 1;
  1029.   else if(channel > fluid_synth_count_midi_channels(self->synth))
  1030.     channel = fluid_synth_count_midi_channels(self->synth);
  1031.     
  1032.   fluid_synth_select_tuning(self->synth, channel - 1, tuning_bank, tuning_prog);
  1033. }
  1035. static void 
  1036. fluidmax_tuning_reset(t_object *o, Symbol *s, short ac, Atom *at)
  1037. {
  1038.   fluidmax_t *self = (fluidmax_t *)o;
  1039.   int channel = 0;
  1040.   
  1041.   if(ac > 0 && ftmax_is_number(at))
  1042.     channel = ftmax_get_number_int(at);
  1044.   if(channel < 1)
  1045.     channel = 1;
  1046.   else if(channel > fluid_synth_count_midi_channels(self->synth))
  1047.     channel = fluid_synth_count_midi_channels(self->synth);
  1048.     
  1049.   fluid_synth_reset_tuning(self->synth, channel - 1);
  1050. }
  1052. /* more tuning ??
  1053. fluid_synth_create_key_tuning (fluid_synth_t *synth, int tuning_bank, int tuning_prog, char *name, double *pitch)
  1054. fluid_synth_tune_notes (fluid_synth_t *synth, int tuning_bank, int tuning_prog, int len, int *keys, double *pitch, int apply)
  1055. fluid_synth_tuning_iteration_start (fluid_synth_t *synth)
  1056. fluid_synth_tuning_iteration_next (fluid_synth_t *synth, int *bank, int *prog)
  1057. fluid_synth_tuning_dump (fluid_synth_t *synth, int bank, int prog, char *name, int len, double *pitch)
  1058. */
  1060. static void
  1061. fluidmax_version(t_object *o)
  1062. {
  1063.   post("fluidsynth~, version %s (based on FluidSynth %s)", FLUIDMAX_VERSION, FLUIDSYNTH_VERSION);
  1064.   post("  FluidSynth is written by Peter Hanappe et al. (see fluidsynth.org)");
  1065.   post("  Max/MSP integration by Norbert Schnell IMTR IRCAM - Centre Pompidou");
  1066. }
  1068. extern fluid_gen_info_t fluid_gen_info[];
  1070. static void 
  1071. fluidmax_print(t_object *o, Symbol *s, short ac, Atom *at)
  1072. {
  1073.   fluidmax_t *self = (fluidmax_t *)o;
  1074.   
  1075.   if(ac > 0)
  1076.   {
  1077.     if(ftmax_is_symbol(at))
  1078.     {
  1079.       ftmax_symbol_t sym = ftmax_get_symbol(at);
  1080.       
  1081.       if(sym == sym_soundfonts)
  1082.       {
  1083.         int n = fluid_synth_sfcount(self->synth);
  1084.         int i;
  1085.         
  1086.         if(n > 0)
  1087.           post("fluidsynth~ soundfonts:");
  1088.         else
  1089.           post("fluidsynth~: no soundfonts loaded");          
  1090.         
  1091.         for(i=0; i<n; i++)
  1092.         {
  1093.           fluid_sfont_t *sf = fluid_synth_get_sfont(self->synth, i);
  1094.           ftmax_symbol_t name = fluidmax_sfont_get_name(sf);
  1095.           unsigned int id = fluid_sfont_get_id(sf);
  1096.           
  1097.           post("  %d: '%s' (id %d)", i, ftmax_symbol_name(name), id);
  1098.         }
  1099.       }
  1100.       else if(sym == sym_presets)
  1101.       {
  1102.         int n = fluid_synth_sfcount(self->synth);
  1103.         
  1104.         if(n > 0)
  1105.         {
  1106.           if(ac > 1)
  1107.           {
  1108.             fluid_sfont_t *sf = NULL;
  1109.             ftmax_symbol_t name;
  1110.          
  1111.             if(ftmax_is_symbol(at + 1))
  1112.             {
  1113.               name = ftmax_get_symbol(at + 1);
  1114.               sf = fluidmax_sfont_get_by_name(self, name);
  1115.             }
  1116.             else if(ftmax_is_int(at + 1))
  1117.             {
  1118.               int id = ftmax_get_int(at + 1);
  1119.               
  1120.               sf = fluid_synth_get_sfont_by_id(self->synth, id);
  1121.               name = fluidmax_sfont_get_name(sf);
  1122.             }
  1123.             
  1124.             if(sf != NULL)
  1125.             {
  1126.               fluid_preset_t preset;
  1127.               
  1128.               fluid_sfont_iteration_start(sf);
  1129.               
  1130.               post("fluidsynth~ presets of soundfont '%s':", ftmax_symbol_name(name));
  1131.               
  1132.               while(fluid_sfont_iteration_next(sf, &preset) > 0)
  1133.               {
  1134.                 char *preset_str = fluid_preset_get_name(&preset);
  1135.                 ftmax_symbol_t preset_name = ftmax_new_symbol(preset_str);
  1136.                 int bank_num = fluid_preset_get_banknum(&preset);
  1137.                 int prog_num = fluid_preset_get_num(&preset);
  1138.                 
  1139.                 post("  '%s': bank %d, program %d", ftmax_symbol_name(preset_name), bank_num, prog_num);
  1140.               }
  1141.             }
  1142.           }
  1143.           else
  1144.           {
  1145.             int i;
  1147.             post("fluidsynth~ presets:");
  1148.             
  1149.             for(i=0; i<128; i++)
  1150.             {
  1151.               int j;
  1152.               
  1153.               for(j=0; j<128; j++)
  1154.               {
  1155.                 fluid_preset_t *preset = NULL;
  1156.                 fluid_sfont_t *sf = NULL;
  1157.                 int k;
  1158.                 
  1159.                 for(k=0; k<n; k++)
  1160.                 {
  1161.                   sf = fluid_synth_get_sfont(self->synth, k);                  
  1162.                   preset = fluid_sfont_get_preset(sf, i, j);
  1163.                   
  1164.                   if(preset != NULL)
  1165.                     break;
  1166.                 }
  1167.                 
  1168.                 if(preset != NULL)
  1169.                 {
  1170.                   ftmax_symbol_t sf_name = fluidmax_sfont_get_name(sf);
  1171.                   char *preset_str = fluid_preset_get_name(preset);
  1172.                   ftmax_symbol_t preset_name = ftmax_new_symbol(preset_str);
  1173.                   
  1174.                   post("  '%s': soundfont '%s', bank %d, program %d", 
  1175.                     ftmax_symbol_name(preset_name), ftmax_symbol_name(sf_name), i, j);
  1176.                 }
  1177.               }
  1178.             }
  1179.           }
  1180.         }
  1181.         else
  1182.           error("fluidsynth~: no soundfonts loaded");
  1183.       }
  1184.       else if(sym == sym_channels)
  1185.       {
  1186.         int n = fluid_synth_count_midi_channels(self->synth);
  1187.         int i;
  1188.         
  1189.         post("fluidsynth~ channels:");
  1190.         
  1191.         for(i=0; i<n; i++)
  1192.         {
  1193.           fluid_preset_t *preset = fluid_synth_get_channel_preset(self->synth, i);
  1194.           
  1195.           if(preset != NULL)
  1196.           {
  1197.             char *preset_str = fluid_preset_get_name(preset);
  1198.             ftmax_symbol_t preset_name = ftmax_new_symbol(preset_str);
  1199.             unsigned int sf_id;
  1200.             unsigned int bank_num;
  1201.             unsigned int prog_num;
  1202.             fluid_sfont_t *sf;
  1203.             
  1204.             fluid_synth_get_program(self->synth, i, &sf_id, &bank_num, &prog_num);
  1205.             sf = fluid_synth_get_sfont_by_id(self->synth, sf_id);
  1206.             
  1207.             post("  %d: soundfont '%s', bank %d, program %d: '%s'", 
  1208.               i + 1, ftmax_symbol_name(fluidmax_sfont_get_name(sf)), bank_num, prog_num, ftmax_symbol_name(preset_name));
  1209.           }
  1210.           else
  1211.             post("  channel %d: no preset", i + 1);
  1212.         }
  1213.       }
  1214.       else if(sym == ftmax_new_symbol("generators"))
  1215.       {
  1216.         int channel = 1;
  1217.         int n = GEN_LAST;
  1218.         int i;
  1219.         
  1220.         if(ac > 1 && ftmax_is_number(at + 1))
  1221.           channel = ftmax_get_number_int(at + 1);
  1223.         if(channel < 1)
  1224.           channel = 1;
  1225.         else if(channel > fluid_synth_count_midi_channels(self->synth))
  1226.           channel = fluid_synth_count_midi_channels(self->synth);
  1227.           
  1228.         post("fluidsynth~ generators of channel %d:", channel);
  1229.         
  1230.         for(i=0; i<n; i++)
  1231.         {
  1232.           const char *name = fluidmax_gen_info[i].name;
  1233.           const char *unit = fluidmax_gen_info[i].unit;
  1234.           double incr = fluid_synth_get_gen(self->synth, channel - 1, i);
  1235.           double min = fluid_gen_info[i].min;
  1236.           double max = fluid_gen_info[i].max;
  1237.           
  1238.           post("  %d '%s': %s %g [%g ... %g] (%s)", i, name, (incr >= 0)? "": "-" , fabs(incr), min, max, unit);
  1239.         }
  1240.       }
  1241.       else if(sym == sym_gain)
  1242.       {
  1243.         double gain = fluid_synth_get_gain(self->synth);
  1245.         post("gain: %g", gain);
  1246.       }
  1247.       else if(sym == sym_reverb)
  1248.       {
  1249.         double level = fluid_synth_get_reverb_level(self->synth);
  1250.         double room = fluid_synth_get_reverb_roomsize(self->synth);
  1251.         double damping = fluid_synth_get_reverb_damp(self->synth);
  1252.         double width = fluid_synth_get_reverb_width(self->synth);
  1253.         
  1254.         if(self->reverb != 0)
  1255.         {
  1256.           post("fluidsynth~ current reverb parameters:");
  1257.           post("  level: %f", level);
  1258.           post("  room size: %f", room);
  1259.           post("  damping: %f", damping);
  1260.           post("  width: %f", width);
  1261.         }
  1262.         else
  1263.           post("fluidsynth~: reverb off");        
  1264.       }
  1265.       else if(sym == sym_chorus)
  1266.       {
  1267.         if(self->chorus != 0)
  1268.         {
  1269.           double level = fluid_synth_get_chorus_level(self->synth);
  1270.           double speed = fluid_synth_get_chorus_speed_Hz(self->synth);
  1271.           double depth = fluid_synth_get_chorus_depth_ms(self->synth);
  1272.           int type = fluid_synth_get_chorus_type(self->synth);
  1273.           int nr = fluid_synth_get_chorus_nr(self->synth);
  1274.           
  1275.           post("fluidsynth~ current chorus parameters:");
  1276.           post("  level: %f", level);
  1277.           post("  speed: %f Hz", speed);
  1278.           post("  depth: %f msec", depth);
  1279.           post("  type: %d (%s)", type, type? "triangle": "sine");
  1280.           post("  %d units", nr);
  1281.         }
  1282.         else
  1283.           post("fluidsynth~: chorus off");
  1284.       }
  1285.     }
  1286.   }
  1287. }
  1289. static void 
  1290. fluidmax_info(t_object *o, Symbol *s, short ac, Atom *at)
  1291. {
  1292.   fluidmax_t *self = (fluidmax_t *)o;
  1293.   
  1294.   if(ac > 0)
  1295.   {
  1296.     if(ftmax_is_symbol(at))
  1297.     {
  1298.       ftmax_symbol_t sym = ftmax_get_symbol(at);
  1299.       
  1300.       if(sym == sym_soundfonts)
  1301.       {
  1302.         int n = fluid_synth_sfcount(self->synth);
  1303.         int i;
  1304.         
  1305.         for(i=0; i<n; i++)
  1306.         {
  1307.           fluid_sfont_t *sf = fluid_synth_get_sfont(self->synth, i);
  1308.           unsigned int id = fluid_sfont_get_id(sf);
  1309.           ftmax_atom_t a[2];
  1310.           
  1311.           ftmax_set_int(a, i);
  1312.           ftmax_set_symbol(a + 1, fluidmax_sfont_get_name(sf));
  1313.           ftmax_set_int(a + 2, id);
  1314.           outlet_anything(self->outlet, sym_soundfont, 3, a);
  1315.         }
  1316.       }
  1317.       else if(sym == sym_presets)
  1318.       {
  1319.         int n = fluid_synth_sfcount(self->synth);
  1320.         
  1321.         if(n > 0)
  1322.         {
  1323.           if(ac > 1)
  1324.           {
  1325.             fluid_sfont_t *sf = NULL;
  1326.             ftmax_symbol_t sf_name;
  1327.          
  1328.             if(ftmax_is_symbol(at + 1))
  1329.             {
  1330.               sf_name = ftmax_get_symbol(at + 1);
  1331.               sf = fluidmax_sfont_get_by_name(self, sf_name);
  1332.             }
  1333.             else if(ftmax_is_int(at + 1))
  1334.             {
  1335.               int id = ftmax_get_int(at + 1);
  1336.               
  1337.               sf = fluid_synth_get_sfont_by_id(self->synth, id);
  1338.               sf_name = fluidmax_sfont_get_name(sf);
  1339.             }
  1340.             
  1341.             if(sf != NULL)
  1342.             {
  1343.               fluid_preset_t preset;
  1344.               
  1345.               fluid_sfont_iteration_start(sf);
  1346.               
  1347.               while(fluid_sfont_iteration_next(sf, &preset) > 0)
  1348.               {
  1349.                 char *preset_str = fluid_preset_get_name(&preset);
  1350.                 ftmax_symbol_t preset_name = ftmax_new_symbol(preset_str);
  1351.                 int bank_num = fluid_preset_get_banknum(&preset);
  1352.                 int prog_num = fluid_preset_get_num(&preset);
  1353.                 ftmax_atom_t a[4];
  1354.                 
  1355.                 ftmax_set_symbol(a , preset_name);
  1356.                 ftmax_set_symbol(a + 1, sf_name);
  1357.                 ftmax_set_int(a + 2, bank_num);
  1358.                 ftmax_set_int(a + 3, prog_num);
  1359.                 outlet_anything(self->outlet, sym_preset, 4, a);
  1360.               }
  1361.             }
  1362.           }
  1363.           else
  1364.           {
  1365.             int i;
  1367.             for(i=0; i<128; i++)
  1368.             {
  1369.               int j;
  1370.               
  1371.               for(j=0; j<128; j++)
  1372.               {
  1373.                 fluid_preset_t *preset = NULL;
  1374.                 fluid_sfont_t *sf = NULL;
  1375.                 int k;
  1376.                 
  1377.                 for(k=0; k<n; k++)
  1378.                 {
  1379.                   sf = fluid_synth_get_sfont(self->synth, k);                  
  1380.                   preset = fluid_sfont_get_preset(sf, i, j);
  1381.                   
  1382.                   if(preset != NULL)
  1383.                     break;
  1384.                 }
  1385.                 
  1386.                 if(preset != NULL)
  1387.                 {
  1388.                   ftmax_symbol_t sf_name = fluidmax_sfont_get_name(sf);
  1389.                   char *preset_str = fluid_preset_get_name(preset);
  1390.                   ftmax_symbol_t preset_name = ftmax_new_symbol(preset_str);
  1391.                   ftmax_atom_t a[4];
  1392.                   
  1393.                   ftmax_set_symbol(a , preset_name);
  1394.                   ftmax_set_symbol(a + 1, sf_name);
  1395.                   ftmax_set_int(a + 2, i);
  1396.                   ftmax_set_int(a + 3, j);
  1397.                   outlet_anything(self->outlet, sym_preset, 4, a);
  1398.                 }
  1399.               }
  1400.             }
  1401.           }
  1402.         }
  1403.         else
  1404.           error("fluidsynth~ info: no soundfonts loaded");
  1405.       }
  1406.       else if(sym == sym_channels)
  1407.       {
  1408.         int n = fluid_synth_count_midi_channels(self->synth);
  1409.         int i;
  1410.         
  1411.         for(i=0; i<n; i++)
  1412.         {
  1413.           fluid_preset_t *preset = fluid_synth_get_channel_preset(self->synth, i);
  1414.           
  1415.           if(preset != NULL)
  1416.           {
  1417.             char *preset_str = fluid_preset_get_name(preset);
  1418.             ftmax_symbol_t preset_name = ftmax_new_symbol(preset_str);
  1419.             unsigned int sf_id, bank_num, prog_num;
  1420.             fluid_sfont_t *sf;
  1421.             ftmax_atom_t a[5];
  1422.             
  1423.             fluid_synth_get_program(self->synth, i, &sf_id, &bank_num, &prog_num);
  1424.             sf = fluid_synth_get_sfont_by_id(self->synth, sf_id);
  1426.             ftmax_set_int(a, i + 1);
  1427.             ftmax_set_symbol(a + 1, fluidmax_sfont_get_name(sf));
  1428.             ftmax_set_int(a + 2, bank_num);
  1429.             ftmax_set_int(a + 3, prog_num);
  1430.             ftmax_set_symbol(a + 4, preset_name);
  1431.             outlet_anything(self->outlet, sym_channel, 5, a);
  1432.           }
  1433.           else
  1434.           {
  1435.             ftmax_atom_t a[2];
  1436.             
  1437.             ftmax_set_int(a, i + 1);
  1438.             ftmax_set_symbol(a + 1, sym_undefined);
  1439.             outlet_anything(self->outlet, sym_channel, 2, a);
  1440.           }
  1441.         }
  1442.       }
  1443.       else if(sym == sym_gain)
  1444.       {
  1445.         ftmax_atom_t a;
  1446.         double gain = fluid_synth_get_gain(self->synth);
  1448.         ftmax_set_float(&a, gain);
  1449.         outlet_anything(self->outlet, sym_channel, 1, &a);
  1450.       }
  1451.       else if(sym == sym_reverb)
  1452.       {
  1453.         if(self->reverb != 0)
  1454.         {
  1455.           double level = fluid_synth_get_reverb_level(self->synth);
  1456.           double room = fluid_synth_get_reverb_roomsize(self->synth);
  1457.           double damping = fluid_synth_get_reverb_damp(self->synth);
  1458.           double width = fluid_synth_get_reverb_width(self->synth);
  1459.           ftmax_atom_t a[4];
  1460.           
  1461.           ftmax_set_float(a, level);
  1462.           ftmax_set_float(a + 1, room);
  1463.           ftmax_set_float(a + 2, damping);
  1464.           ftmax_set_float(a + 3, width);
  1465.           outlet_anything(self->outlet, sym_reverb, 4, a);          
  1466.         }
  1467.         else
  1468.         {
  1469.           ftmax_atom_t a;
  1470.           
  1471.           ftmax_set_symbol(&a, sym_off);
  1472.           outlet_anything(self->outlet, sym_reverb, 1, &a);
  1473.         }
  1474.       }
  1475.       else if(sym == sym_chorus)
  1476.       {
  1477.         if(self->chorus != 0)
  1478.         {
  1479.           double level = fluid_synth_get_chorus_level(self->synth);
  1480.           double speed = fluid_synth_get_chorus_speed_Hz(self->synth);
  1481.           double depth = fluid_synth_get_chorus_depth_ms(self->synth);
  1482.           int type = fluid_synth_get_chorus_type(self->synth);
  1483.           int nr = fluid_synth_get_chorus_nr(self->synth);
  1484.           ftmax_atom_t a[5];
  1485.           
  1486.           ftmax_set_float(a, level);
  1487.           ftmax_set_float(a + 1, speed);
  1488.           ftmax_set_float(a + 2, depth);
  1489.           ftmax_set_int(a + 3, type);
  1490.           ftmax_set_int(a + 4, nr);
  1491.           outlet_anything(self->outlet, sym_chorus, 5, a);
  1492.         }
  1493.         else
  1494.         {
  1495.           ftmax_atom_t a;
  1496.           
  1497.           ftmax_set_symbol(&a, sym_off);
  1498.           outlet_anything(self->outlet, sym_chorus, 1, &a);
  1499.         }
  1500.       }
  1501.       else if(sym == sym_polyphony)
  1502.       {
  1503.         int polyphony = fluid_synth_get_polyphony(self->synth);
  1504.         ftmax_atom_t a;
  1505.         
  1506.         ftmax_set_int(&a, polyphony);
  1507.         outlet_anything(self->outlet, sym_polyphony, 1, &a);
  1508.       }
  1509.     }
  1510.   }
  1511. }
  1513. /***************************************************************
  1514.  *
  1515.  *  class
  1516.  *
  1517.  */
  1518. static void *
  1519. fluidmax_new(Symbol *s, short ac, Atom *at)
  1520. {  
  1521.   fluidmax_t *self = (fluidmax_t *)newobject(fluidmax_class);
  1522.   int polyphony = 256;
  1523.   int midi_channels = 16;
  1525.   self->outlet = outlet_new(self, "anything");
  1527.   dsp_setup((t_pxobject *)self, 0);
  1528.   outlet_new(self, "signal");
  1529.   outlet_new(self, "signal");
  1531.   self->synth = NULL;
  1532.   self->settings = new_fluid_settings();
  1533.   self->reverb = 0;
  1534.   self->chorus = 0;
  1535.   self->mute = 0;
  1536.   
  1537.   if(ac > 0 && ftmax_is_number(at))
  1538.   {
  1539.     polyphony = ftmax_get_number_int(at);
  1540.     ac--;
  1541.     at++;
  1542.   }
  1543.   
  1544.   if(ac > 0 && ftmax_is_number(at))
  1545.   {
  1546.     midi_channels = ftmax_get_number_int(at);
  1547.     ac--;
  1548.     at++;
  1549.   }
  1550.   
  1551.   if(ac > 0 && ftmax_is_symbol(at))
  1552.   {
  1553.     fluidmax_load((t_object *)self, NULL, 1, at);
  1554.   }
  1555.   
  1556.   if(self->settings != NULL)
  1557.   {
  1558.     fluid_settings_setint(self->settings, "synth.midi-channels", midi_channels);
  1559.     fluid_settings_setint(self->settings, "synth.polyphony", polyphony);
  1560.     fluid_settings_setnum(self->settings, "synth.gain", 0.600000);
  1561.     fluid_settings_setnum(self->settings, "synth.sample-rate", sys_getsr());
  1562.   
  1563.     self->synth = new_fluid_synth(self->settings);
  1564.     
  1565.     if(self->synth != NULL)
  1566.     {
  1567.       fluid_synth_set_reverb_on(self->synth, 0);
  1568.       fluid_synth_set_chorus_on(self->synth, 0);      
  1569.     
  1570.       if(ac > 0 && ftmax_is_symbol(at))
  1571.         fluidmax_load((t_object *)self, NULL, ac, at);
  1573.       return self;
  1574.     }
  1576.     delete_fluid_settings(self->settings);
  1577.   }
  1579.   error("fluidsynth~: cannot create FluidSynth core");
  1580.   
  1581.   return NULL;
  1582. }
  1584. static void
  1585. fluidmax_free(t_pxobject *o)
  1586. {
  1587.   fluidmax_t *self = (fluidmax_t *)o;
  1589.   if(self->settings != NULL )
  1590.     delete_fluid_settings(self->settings);
  1592.   if(self->synth != NULL )
  1593.     delete_fluid_synth(self->synth);
  1595.   dsp_free(o);
  1596. }
  1598. int 
  1599. main(void)
  1600. {
  1601.   setup(&fluidmax_class, (method)fluidmax_new, (method)fluidmax_free, (short)sizeof(fluidmax_t), 0, A_GIMME, 0);
  1602.   dsp_initclass();
  1604.   addmess((method)fluidmax_dsp, "dsp", A_CANT, 0);
  1606.   addmess((method)fluidmax_version, "version", 0);
  1607.   addmess((method)fluidmax_print, "print", A_GIMME, 0);
  1609.   addmess((method)fluidmax_load, "load", A_GIMME, 0);
  1610.   addmess((method)fluidmax_unload, "unload", A_GIMME, 0);
  1611.   addmess((method)fluidmax_reload, "reload", A_GIMME, 0);
  1612.   addmess((method)fluidmax_info, "info", A_GIMME, 0);
  1613.   
  1614.   addmess((method)fluidmax_panic, "panic", A_GIMME, 0);
  1615.   addmess((method)fluidmax_reset, "reset", A_GIMME, 0);
  1616.   addmess((method)fluidmax_mute, "mute", A_GIMME, 0);
  1617.   addmess((method)fluidmax_unmute, "unmute", 0);
  1619.   /*addmess((method)fluidmax_tuning_keys, "tuning-keys", A_GIMME, 0);*/
  1620.   addmess((method)fluidmax_tuning_octave, "tuning-octave", A_GIMME, 0);
  1621.   addmess((method)fluidmax_tuning_select, "tuning-select", A_GIMME, 0);
  1622.   addmess((method)fluidmax_tuning_reset, "tuning-reset", A_GIMME, 0);
  1624.   addmess((method)fluidmax_reverb, "reverb", A_GIMME, 0);
  1625.   addmess((method)fluidmax_chorus, "chorus", A_GIMME, 0);  
  1626.   addmess((method)fluidmax_set_gain, "gain", A_GIMME, 0);  
  1627.   addmess((method)fluidmax_set_resampling_method, "resample", A_GIMME, 0);  
  1628.     
  1629.   addmess((method)fluidmax_note, "note", A_GIMME, 0);
  1630.   addmess((method)fluidmax_list, "list", A_GIMME, 0);
  1632.   addmess((method)fluidmax_control_change, "control", A_GIMME, 0);
  1633.   addmess((method)fluidmax_mod, "mod", A_GIMME, 0);
  1634.   
  1635.   addmess((method)fluidmax_pitch_bend, "bend", A_GIMME, 0);
  1636.   addmess((method)fluidmax_pitch_bend_wheel, "wheel", A_GIMME, 0);
  1638.   addmess((method)fluidmax_program_change, "program", A_GIMME, 0);
  1639.   addmess((method)fluidmax_bank_select, "bank", A_GIMME, 0);
  1640.   addmess((method)fluidmax_select, "select", A_GIMME, 0);
  1642.   sym_on = ftmax_new_symbol("on");
  1643.   sym_off = ftmax_new_symbol("off");
  1644.   sym_undefined = ftmax_new_symbol("undefined");
  1645.   sym_gain = ftmax_new_symbol("gain");
  1646.   sym_channels = ftmax_new_symbol("channels");
  1647.   sym_channel = ftmax_new_symbol("channel");
  1648.   sym_soundfonts = ftmax_new_symbol("soundfonts");
  1649.   sym_soundfont = ftmax_new_symbol("soundfont");
  1650.   sym_presets = ftmax_new_symbol("presets");
  1651.   sym_preset = ftmax_new_symbol("preset");
  1652.   sym_reverb = ftmax_new_symbol("reverb");
  1653.   sym_chorus = ftmax_new_symbol("chorus");
  1654.   sym_polyphony = ftmax_new_symbol("polyphony");
  1655.   sym_nearest = ftmax_new_symbol("nearest");
  1656.   sym_linear = ftmax_new_symbol("linear");
  1657.   sym_cubic = ftmax_new_symbol("cubic");
  1658.   sym_sinc = ftmax_new_symbol("sinc");
  1660.   
  1661.   fluidmax_version(NULL);
  1662.   
  1663.   return 0;
  1664. }