fluidsynth/bindings/fluidmax/fluidmax_fakefuns.c

/***************************************************************************************
 *
 *  fluidsynth~
 *
 *  Fluid Synth soundfont synthesizer for Max/MSP.
 *
 *  Fluid Synth is written by Peter Hanappe et al.
 *  see http://www.fluidsynth.org/
 *
 *  Max/MSP integration by Norbert Schnell ATR IRCAM - Centre Pompidou
 *
 *  This program is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU General Public License
 *  as published by the Free Software Foundation; either version 2.1
 *  of the License, or (at your option) any later version.
 *  
 *  See file COPYING.LIB for further informations on licensing terms.
 * 
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 * 
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02110-1301, USA.
 *
 */
/*
 *  This file contains the (mostly empty) implementation of some functions without 
 *  which Fluidsynth wouldn't compile.
 *
 *  The Max/MSP version of FluidSynth tries to link only with a minimum of needed 
 *  files. Some of the linked files depend on functions that are not necessary
 *  and that are implemnted in files we don't want to include. So, alternate or empty
 *  implemntations of these functions are provided here.
 * 
 */
#include "ftmax.h"
#include "fluidsynth.h"
#include "fluidsynth_priv.h"
#include "fluid_settings.h"

unsigned int 
fluid_curtime()
{
  return (unsigned int)gettime();
}

double
fluid_utime(void)
{
  return 0.0;
}

typedef void fluid_timer_t;
typedef int(*fluid_timer_callback_t)(void* data, unsigned int msec);

fluid_timer_t * 
new_fluid_timer(int msec, fluid_timer_callback_t callback, void* data, int new_thread, int auto_destroy)
{
  /* just call it right away */
  (*callback)(data, msec);
  
  return NULL;
}

void 
fluid_sys_config()
{
}

char* 
fluid_error()
{
  return NULL;
}

/* This code is (unelegantly) copied from fluid_sys.c since other parts of fluid_sys.c 
 * that we don't need here depend on many other things that we don't want here. */
char *
fluid_strtok (char **str, char *delim)
{
  char *s, *d, *token;
  char c;
  
  if (str == NULL || delim == NULL || !*delim)
  {
    FLUID_LOG(FLUID_ERR, "Null pointer");
    return NULL;
  }
  
  s = *str;
  if (!s) return NULL;	/* str points to a NULL pointer? (tokenize already ended) */
  
  /* skip delimiter chars at beginning of token */
  do
  {
    c = *s;
    if (!c)	/* end of source string? */
    {
      *str = NULL;
      return NULL;
    }
    
    for (d = delim; *d; d++)	/* is source char a token char? */
    {
      if (c == *d)	/* token char match? */
      {
        s++;		/* advance to next source char */
        break;
      }
    }
  } while (*d);		/* while token char match */
  
  token = s;		/* start of token found */
  
  /* search for next token char or end of source string */
  for (s = s+1; *s; s++)
  {
    c = *s;
    
    for (d = delim; *d; d++)	/* is source char a token char? */
    {
      if (c == *d)	/* token char match? */
      {
        *s = '\0';	/* overwrite token char with zero byte to terminate token */
        *str = s+1;	/* update str to point to beginning of next token */
        return token;
      }
    }
  }
  
  /* we get here only if source string ended */
  *str = NULL;
  return token;
}

int 
fluid_log(int level, char* fmt, ...)
{
  char buf[1024];
  
  va_list args; 
  va_start (args, fmt); 
  vsprintf(buf, fmt, args); 
  va_end (args); 

  if ((level > 0) && (level < LAST_LOG_LEVEL)) 
    post("fluidsynth~ core (level %d): %s", level, buf);

  return -1; 
}

void
fluid_shell_settings(fluid_settings_t *settings)
{
}

void
fluid_audio_driver_settings(fluid_settings_t *settings)
{
  fluid_settings_register_str(settings, "audio.driver", "", 0, NULL, NULL);
}

void
fluid_midi_driver_settings(fluid_settings_t *settings)
{  
  fluid_settings_register_str(settings, "midi.driver", "", 0, NULL, NULL);
}

int fluid_midi_event_get_type(fluid_midi_event_t* evt)
{
	return 0;
}

int fluid_midi_event_set_type(fluid_midi_event_t* evt, int type)
{
	return FLUID_OK;
}

int fluid_midi_event_get_channel(fluid_midi_event_t* evt)
{
	return 0;
}

int fluid_midi_event_set_channel(fluid_midi_event_t* evt, int chan)
{
	return FLUID_OK;
}

int fluid_midi_event_get_key(fluid_midi_event_t* evt)
{
	return 0;
}

int fluid_midi_event_set_key(fluid_midi_event_t* evt, int v)
{
	return FLUID_OK;
}

int fluid_midi_event_get_velocity(fluid_midi_event_t* evt)
{
	return 0;
}

int fluid_midi_event_set_velocity(fluid_midi_event_t* evt, int v)
{
	return FLUID_OK;
}

int fluid_midi_event_get_control(fluid_midi_event_t* evt)
{
	return 0;
}

int fluid_midi_event_set_control(fluid_midi_event_t* evt, int v)
{
	return FLUID_OK;
}

int fluid_midi_event_get_value(fluid_midi_event_t* evt)
{
	return 0;
}

int fluid_midi_event_set_value(fluid_midi_event_t* evt, int v)
{
	return FLUID_OK;
}

int fluid_midi_event_get_program(fluid_midi_event_t* evt)
{
	return 0;
}

int fluid_midi_event_set_program(fluid_midi_event_t* evt, int val)
{
	return FLUID_OK;
}

int fluid_midi_event_get_pitch(fluid_midi_event_t* evt)
{
	return 0;
}

int fluid_midi_event_set_pitch(fluid_midi_event_t* evt, int val)
{
	return FLUID_OK;
}