fluidmax_fakefuns.c
上传用户:tjmskj2
上传日期:2020-08-17
资源大小:577k
文件大小:5k
源码类别:

midi

开发平台:

C/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.  *  This file contains the (mostly empty) implementation of some functions without 
  31.  *  which Fluidsynth wouldn't compile.
  32.  *
  33.  *  The Max/MSP version of FluidSynth tries to link only with a minimum of needed 
  34.  *  files. Some of the linked files depend on functions that are not necessary
  35.  *  and that are implemnted in files we don't want to include. So, alternate or empty
  36.  *  implemntations of these functions are provided here.
  37.  * 
  38.  */
  39. #include "ftmax.h"
  40. #include "fluidsynth.h"
  41. #include "fluidsynth_priv.h"
  42. #include "fluid_settings.h"
  43. unsigned int 
  44. fluid_curtime()
  45. {
  46.   return (unsigned int)gettime();
  47. }
  48. double
  49. fluid_utime(void)
  50. {
  51.   return 0.0;
  52. }
  53. typedef void fluid_timer_t;
  54. typedef int(*fluid_timer_callback_t)(void* data, unsigned int msec);
  55. fluid_timer_t * 
  56. new_fluid_timer(int msec, fluid_timer_callback_t callback, void* data, int new_thread, int auto_destroy)
  57. {
  58.   /* just call it right away */
  59.   (*callback)(data, msec);
  60.   
  61.   return NULL;
  62. }
  63. void 
  64. fluid_sys_config()
  65. {
  66. }
  67. char* 
  68. fluid_error()
  69. {
  70.   return NULL;
  71. }
  72. /* This code is (unelegantly) copied from fluid_sys.c since other parts of fluid_sys.c 
  73.  * that we don't need here depend on many other things that we don't want here. */
  74. char *
  75. fluid_strtok (char **str, char *delim)
  76. {
  77.   char *s, *d, *token;
  78.   char c;
  79.   
  80.   if (str == NULL || delim == NULL || !*delim)
  81.   {
  82.     FLUID_LOG(FLUID_ERR, "Null pointer");
  83.     return NULL;
  84.   }
  85.   
  86.   s = *str;
  87.   if (!s) return NULL; /* str points to a NULL pointer? (tokenize already ended) */
  88.   
  89.   /* skip delimiter chars at beginning of token */
  90.   do
  91.   {
  92.     c = *s;
  93.     if (!c) /* end of source string? */
  94.     {
  95.       *str = NULL;
  96.       return NULL;
  97.     }
  98.     
  99.     for (d = delim; *d; d++) /* is source char a token char? */
  100.     {
  101.       if (c == *d) /* token char match? */
  102.       {
  103.         s++; /* advance to next source char */
  104.         break;
  105.       }
  106.     }
  107.   } while (*d); /* while token char match */
  108.   
  109.   token = s; /* start of token found */
  110.   
  111.   /* search for next token char or end of source string */
  112.   for (s = s+1; *s; s++)
  113.   {
  114.     c = *s;
  115.     
  116.     for (d = delim; *d; d++) /* is source char a token char? */
  117.     {
  118.       if (c == *d) /* token char match? */
  119.       {
  120.         *s = ''; /* overwrite token char with zero byte to terminate token */
  121.         *str = s+1; /* update str to point to beginning of next token */
  122.         return token;
  123.       }
  124.     }
  125.   }
  126.   
  127.   /* we get here only if source string ended */
  128.   *str = NULL;
  129.   return token;
  130. }
  131. int 
  132. fluid_log(int level, char* fmt, ...)
  133. {
  134.   char buf[1024];
  135.   
  136.   va_list args; 
  137.   va_start (args, fmt); 
  138.   vsprintf(buf, fmt, args); 
  139.   va_end (args); 
  140.   if ((level > 0) && (level < LAST_LOG_LEVEL)) 
  141.     post("fluidsynth~ core (level %d): %s", level, buf);
  142.   return -1; 
  143. }
  144. void
  145. fluid_shell_settings(fluid_settings_t *settings)
  146. {
  147. }
  148. void
  149. fluid_audio_driver_settings(fluid_settings_t *settings)
  150. {
  151.   fluid_settings_register_str(settings, "audio.driver", "", 0, NULL, NULL);
  152. }
  153. void
  154. fluid_midi_driver_settings(fluid_settings_t *settings)
  155. {  
  156.   fluid_settings_register_str(settings, "midi.driver", "", 0, NULL, NULL);
  157. }
  158. int fluid_midi_event_get_type(fluid_midi_event_t* evt)
  159. {
  160. return 0;
  161. }
  162. int fluid_midi_event_set_type(fluid_midi_event_t* evt, int type)
  163. {
  164. return FLUID_OK;
  165. }
  166. int fluid_midi_event_get_channel(fluid_midi_event_t* evt)
  167. {
  168. return 0;
  169. }
  170. int fluid_midi_event_set_channel(fluid_midi_event_t* evt, int chan)
  171. {
  172. return FLUID_OK;
  173. }
  174. int fluid_midi_event_get_key(fluid_midi_event_t* evt)
  175. {
  176. return 0;
  177. }
  178. int fluid_midi_event_set_key(fluid_midi_event_t* evt, int v)
  179. {
  180. return FLUID_OK;
  181. }
  182. int fluid_midi_event_get_velocity(fluid_midi_event_t* evt)
  183. {
  184. return 0;
  185. }
  186. int fluid_midi_event_set_velocity(fluid_midi_event_t* evt, int v)
  187. {
  188. return FLUID_OK;
  189. }
  190. int fluid_midi_event_get_control(fluid_midi_event_t* evt)
  191. {
  192. return 0;
  193. }
  194. int fluid_midi_event_set_control(fluid_midi_event_t* evt, int v)
  195. {
  196. return FLUID_OK;
  197. }
  198. int fluid_midi_event_get_value(fluid_midi_event_t* evt)
  199. {
  200. return 0;
  201. }
  202. int fluid_midi_event_set_value(fluid_midi_event_t* evt, int v)
  203. {
  204. return FLUID_OK;
  205. }
  206. int fluid_midi_event_get_program(fluid_midi_event_t* evt)
  207. {
  208. return 0;
  209. }
  210. int fluid_midi_event_set_program(fluid_midi_event_t* evt, int val)
  211. {
  212. return FLUID_OK;
  213. }
  214. int fluid_midi_event_get_pitch(fluid_midi_event_t* evt)
  215. {
  216. return 0;
  217. }
  218. int fluid_midi_event_set_pitch(fluid_midi_event_t* evt, int val)
  219. {
  220. return FLUID_OK;
  221. }