Added the same server than tamtam has and deleted the csound module from the sources - this is installed already.

3 files changed, 446 insertions, 3167 deletions

diff --git a/csserver/_csnd.so b/csserver/_csnd.so
deleted file mode 100755
index c87469b..0000000
--- a/csserver/_csnd.so
+++ /dev/null
diff --git a/csserver/csnd.py b/csserver/csnd.py
deleted file mode 100644
index 0891a4d..0000000
--- a/csserver/csnd.py
+++ /dev/null
@@ -1,3028 +0,0 @@
-# This file was created automatically by SWIG 1.3.29.
-# Don't modify this file, modify the SWIG interface instead.
-# This file is compatible with both classic and new-style classes.
-
-import _csnd
-import new
-new_instancemethod = new.instancemethod
-def _swig_setattr_nondynamic(self,class_type,name,value,static=1):
-    if (name == "thisown"): return self.this.own(value)
-    if (name == "this"):
-        if type(value).__name__ == 'PySwigObject':
-            self.__dict__[name] = value
-            return
-    method = class_type.__swig_setmethods__.get(name,None)
-    if method: return method(self,value)
-    if (not static) or hasattr(self,name):
-        self.__dict__[name] = value
-    else:
-        raise AttributeError("You cannot add attributes to %s" % self)
-
-def _swig_setattr(self,class_type,name,value):
-    return _swig_setattr_nondynamic(self,class_type,name,value,0)
-
-def _swig_getattr(self,class_type,name):
-    if (name == "thisown"): return self.this.own()
-    method = class_type.__swig_getmethods__.get(name,None)
-    if method: return method(self)
-    raise AttributeError,name
-
-def _swig_repr(self):
-    try: strthis = "proxy of " + self.this.__repr__()
-    except: strthis = ""
-    return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,)
-
-import types
-try:
-    _object = types.ObjectType
-    _newclass = 1
-except AttributeError:
-    class _object : pass
-    _newclass = 0
-del types
-
-
-try:
-    import weakref
-    weakref_proxy = weakref.proxy
-except:
-    weakref_proxy = lambda x: x
-
-
-class PySwigIterator(_object):
-    __swig_setmethods__ = {}
-    __setattr__ = lambda self, name, value: _swig_setattr(self, PySwigIterator, name, value)
-    __swig_getmethods__ = {}
-    __getattr__ = lambda self, name: _swig_getattr(self, PySwigIterator, name)
-    def __init__(self): raise AttributeError, "No constructor defined"
-    __repr__ = _swig_repr
-    __swig_destroy__ = _csnd.delete_PySwigIterator
-    __del__ = lambda self : None;
-    def value(*args): return _csnd.PySwigIterator_value(*args)
-    def incr(*args): return _csnd.PySwigIterator_incr(*args)
-    def decr(*args): return _csnd.PySwigIterator_decr(*args)
-    def distance(*args): return _csnd.PySwigIterator_distance(*args)
-    def equal(*args): return _csnd.PySwigIterator_equal(*args)
-    def copy(*args): return _csnd.PySwigIterator_copy(*args)
-    def next(*args): return _csnd.PySwigIterator_next(*args)
-    def previous(*args): return _csnd.PySwigIterator_previous(*args)
-    def advance(*args): return _csnd.PySwigIterator_advance(*args)
-    def __eq__(*args): return _csnd.PySwigIterator___eq__(*args)
-    def __ne__(*args): return _csnd.PySwigIterator___ne__(*args)
-    def __iadd__(*args): return _csnd.PySwigIterator___iadd__(*args)
-    def __isub__(*args): return _csnd.PySwigIterator___isub__(*args)
-    def __add__(*args): return _csnd.PySwigIterator___add__(*args)
-    def __sub__(*args): return _csnd.PySwigIterator___sub__(*args)
-    def __iter__(self): return self
-PySwigIterator_swigregister = _csnd.PySwigIterator_swigregister
-PySwigIterator_swigregister(PySwigIterator)
-
-CSOUND_SUCCESS = _csnd.CSOUND_SUCCESS
-CSOUND_ERROR = _csnd.CSOUND_ERROR
-CSOUND_INITIALIZATION = _csnd.CSOUND_INITIALIZATION
-CSOUND_PERFORMANCE = _csnd.CSOUND_PERFORMANCE
-CSOUND_MEMORY = _csnd.CSOUND_MEMORY
-CSOUND_SIGNAL = _csnd.CSOUND_SIGNAL
-CSOUND_EXITJMP_SUCCESS = _csnd.CSOUND_EXITJMP_SUCCESS
-CSOUNDINIT_NO_SIGNAL_HANDLER = _csnd.CSOUNDINIT_NO_SIGNAL_HANDLER
-CSOUNDINIT_NO_ATEXIT = _csnd.CSOUNDINIT_NO_ATEXIT
-CSOUND_CONTROL_CHANNEL = _csnd.CSOUND_CONTROL_CHANNEL
-CSOUND_AUDIO_CHANNEL = _csnd.CSOUND_AUDIO_CHANNEL
-CSOUND_STRING_CHANNEL = _csnd.CSOUND_STRING_CHANNEL
-CSOUND_CHANNEL_TYPE_MASK = _csnd.CSOUND_CHANNEL_TYPE_MASK
-CSOUND_INPUT_CHANNEL = _csnd.CSOUND_INPUT_CHANNEL
-CSOUND_OUTPUT_CHANNEL = _csnd.CSOUND_OUTPUT_CHANNEL
-CSOUND_CONTROL_CHANNEL_INT = _csnd.CSOUND_CONTROL_CHANNEL_INT
-CSOUND_CONTROL_CHANNEL_LIN = _csnd.CSOUND_CONTROL_CHANNEL_LIN
-CSOUND_CONTROL_CHANNEL_EXP = _csnd.CSOUND_CONTROL_CHANNEL_EXP
-CSOUND_CALLBACK_KBD_EVENT = _csnd.CSOUND_CALLBACK_KBD_EVENT
-CSOUND_CALLBACK_KBD_TEXT = _csnd.CSOUND_CALLBACK_KBD_TEXT
-class csRtAudioParams(_object):
-    """Proxy of C++ csRtAudioParams class"""
-    __swig_setmethods__ = {}
-    __setattr__ = lambda self, name, value: _swig_setattr(self, csRtAudioParams, name, value)
-    __swig_getmethods__ = {}
-    __getattr__ = lambda self, name: _swig_getattr(self, csRtAudioParams, name)
-    __repr__ = _swig_repr
-    __swig_setmethods__["devName"] = _csnd.csRtAudioParams_devName_set
-    __swig_getmethods__["devName"] = _csnd.csRtAudioParams_devName_get
-    if _newclass:devName = property(_csnd.csRtAudioParams_devName_get, _csnd.csRtAudioParams_devName_set)
-    __swig_setmethods__["devNum"] = _csnd.csRtAudioParams_devNum_set
-    __swig_getmethods__["devNum"] = _csnd.csRtAudioParams_devNum_get
-    if _newclass:devNum = property(_csnd.csRtAudioParams_devNum_get, _csnd.csRtAudioParams_devNum_set)
-    __swig_setmethods__["bufSamp_SW"] = _csnd.csRtAudioParams_bufSamp_SW_set
-    __swig_getmethods__["bufSamp_SW"] = _csnd.csRtAudioParams_bufSamp_SW_get
-    if _newclass:bufSamp_SW = property(_csnd.csRtAudioParams_bufSamp_SW_get, _csnd.csRtAudioParams_bufSamp_SW_set)
-    __swig_setmethods__["bufSamp_HW"] = _csnd.csRtAudioParams_bufSamp_HW_set
-    __swig_getmethods__["bufSamp_HW"] = _csnd.csRtAudioParams_bufSamp_HW_get
-    if _newclass:bufSamp_HW = property(_csnd.csRtAudioParams_bufSamp_HW_get, _csnd.csRtAudioParams_bufSamp_HW_set)
-    __swig_setmethods__["nChannels"] = _csnd.csRtAudioParams_nChannels_set
-    __swig_getmethods__["nChannels"] = _csnd.csRtAudioParams_nChannels_get
-    if _newclass:nChannels = property(_csnd.csRtAudioParams_nChannels_get, _csnd.csRtAudioParams_nChannels_set)
-    __swig_setmethods__["sampleFormat"] = _csnd.csRtAudioParams_sampleFormat_set
-    __swig_getmethods__["sampleFormat"] = _csnd.csRtAudioParams_sampleFormat_get
-    if _newclass:sampleFormat = property(_csnd.csRtAudioParams_sampleFormat_get, _csnd.csRtAudioParams_sampleFormat_set)
-    __swig_setmethods__["sampleRate"] = _csnd.csRtAudioParams_sampleRate_set
-    __swig_getmethods__["sampleRate"] = _csnd.csRtAudioParams_sampleRate_get
-    if _newclass:sampleRate = property(_csnd.csRtAudioParams_sampleRate_get, _csnd.csRtAudioParams_sampleRate_set)
-    def __init__(self, *args): 
-        """__init__(self) -> csRtAudioParams"""
-        this = _csnd.new_csRtAudioParams(*args)
-        try: self.this.append(this)
-        except: self.this = this
-    __swig_destroy__ = _csnd.delete_csRtAudioParams
-    __del__ = lambda self : None;
-csRtAudioParams_swigregister = _csnd.csRtAudioParams_swigregister
-csRtAudioParams_swigregister(csRtAudioParams)
-
-class RTCLOCK(_object):
-    """Proxy of C++ RTCLOCK class"""
-    __swig_setmethods__ = {}
-    __setattr__ = lambda self, name, value: _swig_setattr(self, RTCLOCK, name, value)
-    __swig_getmethods__ = {}
-    __getattr__ = lambda self, name: _swig_getattr(self, RTCLOCK, name)
-    __repr__ = _swig_repr
-    __swig_setmethods__["starttime_real"] = _csnd.RTCLOCK_starttime_real_set
-    __swig_getmethods__["starttime_real"] = _csnd.RTCLOCK_starttime_real_get
-    if _newclass:starttime_real = property(_csnd.RTCLOCK_starttime_real_get, _csnd.RTCLOCK_starttime_real_set)
-    __swig_setmethods__["starttime_CPU"] = _csnd.RTCLOCK_starttime_CPU_set
-    __swig_getmethods__["starttime_CPU"] = _csnd.RTCLOCK_starttime_CPU_get
-    if _newclass:starttime_CPU = property(_csnd.RTCLOCK_starttime_CPU_get, _csnd.RTCLOCK_starttime_CPU_set)
-    def __init__(self, *args): 
-        """__init__(self) -> RTCLOCK"""
-        this = _csnd.new_RTCLOCK(*args)
-        try: self.this.append(this)
-        except: self.this = this
-    __swig_destroy__ = _csnd.delete_RTCLOCK
-    __del__ = lambda self : None;
-RTCLOCK_swigregister = _csnd.RTCLOCK_swigregister
-RTCLOCK_swigregister(RTCLOCK)
-
-class opcodeListEntry(_object):
-    """Proxy of C++ opcodeListEntry class"""
-    __swig_setmethods__ = {}
-    __setattr__ = lambda self, name, value: _swig_setattr(self, opcodeListEntry, name, value)
-    __swig_getmethods__ = {}
-    __getattr__ = lambda self, name: _swig_getattr(self, opcodeListEntry, name)
-    __repr__ = _swig_repr
-    __swig_setmethods__["opname"] = _csnd.opcodeListEntry_opname_set
-    __swig_getmethods__["opname"] = _csnd.opcodeListEntry_opname_get
-    if _newclass:opname = property(_csnd.opcodeListEntry_opname_get, _csnd.opcodeListEntry_opname_set)
-    __swig_setmethods__["outypes"] = _csnd.opcodeListEntry_outypes_set
-    __swig_getmethods__["outypes"] = _csnd.opcodeListEntry_outypes_get
-    if _newclass:outypes = property(_csnd.opcodeListEntry_outypes_get, _csnd.opcodeListEntry_outypes_set)
-    __swig_setmethods__["intypes"] = _csnd.opcodeListEntry_intypes_set
-    __swig_getmethods__["intypes"] = _csnd.opcodeListEntry_intypes_get
-    if _newclass:intypes = property(_csnd.opcodeListEntry_intypes_get, _csnd.opcodeListEntry_intypes_set)
-    def __init__(self, *args): 
-        """__init__(self) -> opcodeListEntry"""
-        this = _csnd.new_opcodeListEntry(*args)
-        try: self.this.append(this)
-        except: self.this = this
-    __swig_destroy__ = _csnd.delete_opcodeListEntry
-    __del__ = lambda self : None;
-opcodeListEntry_swigregister = _csnd.opcodeListEntry_swigregister
-opcodeListEntry_swigregister(opcodeListEntry)
-
-class CsoundRandMTState(_object):
-    """Proxy of C++ CsoundRandMTState class"""
-    __swig_setmethods__ = {}
-    __setattr__ = lambda self, name, value: _swig_setattr(self, CsoundRandMTState, name, value)
-    __swig_getmethods__ = {}
-    __getattr__ = lambda self, name: _swig_getattr(self, CsoundRandMTState, name)
-    __repr__ = _swig_repr
-    __swig_setmethods__["mti"] = _csnd.CsoundRandMTState_mti_set
-    __swig_getmethods__["mti"] = _csnd.CsoundRandMTState_mti_get
-    if _newclass:mti = property(_csnd.CsoundRandMTState_mti_get, _csnd.CsoundRandMTState_mti_set)
-    __swig_setmethods__["mt"] = _csnd.CsoundRandMTState_mt_set
-    __swig_getmethods__["mt"] = _csnd.CsoundRandMTState_mt_get
-    if _newclass:mt = property(_csnd.CsoundRandMTState_mt_get, _csnd.CsoundRandMTState_mt_set)
-    def __init__(self, *args): 
-        """__init__(self) -> CsoundRandMTState"""
-        this = _csnd.new_CsoundRandMTState(*args)
-        try: self.this.append(this)
-        except: self.this = this
-    __swig_destroy__ = _csnd.delete_CsoundRandMTState
-    __del__ = lambda self : None;
-CsoundRandMTState_swigregister = _csnd.CsoundRandMTState_swigregister
-CsoundRandMTState_swigregister(CsoundRandMTState)
-
-class CsoundChannelListEntry(_object):
-    """Proxy of C++ CsoundChannelListEntry class"""
-    __swig_setmethods__ = {}
-    __setattr__ = lambda self, name, value: _swig_setattr(self, CsoundChannelListEntry, name, value)
-    __swig_getmethods__ = {}
-    __getattr__ = lambda self, name: _swig_getattr(self, CsoundChannelListEntry, name)
-    __repr__ = _swig_repr
-    __swig_setmethods__["name"] = _csnd.CsoundChannelListEntry_name_set
-    __swig_getmethods__["name"] = _csnd.CsoundChannelListEntry_name_get
-    if _newclass:name = property(_csnd.CsoundChannelListEntry_name_get, _csnd.CsoundChannelListEntry_name_set)
-    __swig_setmethods__["type"] = _csnd.CsoundChannelListEntry_type_set
-    __swig_getmethods__["type"] = _csnd.CsoundChannelListEntry_type_get
-    if _newclass:type = property(_csnd.CsoundChannelListEntry_type_get, _csnd.CsoundChannelListEntry_type_set)
-    def __init__(self, *args): 
-        """__init__(self) -> CsoundChannelListEntry"""
-        this = _csnd.new_CsoundChannelListEntry(*args)
-        try: self.this.append(this)
-        except: self.this = this
-    __swig_destroy__ = _csnd.delete_CsoundChannelListEntry
-    __del__ = lambda self : None;
-CsoundChannelListEntry_swigregister = _csnd.CsoundChannelListEntry_swigregister
-CsoundChannelListEntry_swigregister(CsoundChannelListEntry)
-
-class PVSDATEXT(_object):
-    """Proxy of C++ PVSDATEXT class"""
-    __swig_setmethods__ = {}
-    __setattr__ = lambda self, name, value: _swig_setattr(self, PVSDATEXT, name, value)
-    __swig_getmethods__ = {}
-    __getattr__ = lambda self, name: _swig_getattr(self, PVSDATEXT, name)
-    __repr__ = _swig_repr
-    __swig_setmethods__["N"] = _csnd.PVSDATEXT_N_set
-    __swig_getmethods__["N"] = _csnd.PVSDATEXT_N_get
-    if _newclass:N = property(_csnd.PVSDATEXT_N_get, _csnd.PVSDATEXT_N_set)
-    __swig_setmethods__["overlap"] = _csnd.PVSDATEXT_overlap_set
-    __swig_getmethods__["overlap"] = _csnd.PVSDATEXT_overlap_get
-    if _newclass:overlap = property(_csnd.PVSDATEXT_overlap_get, _csnd.PVSDATEXT_overlap_set)
-    __swig_setmethods__["winsize"] = _csnd.PVSDATEXT_winsize_set
-    __swig_getmethods__["winsize"] = _csnd.PVSDATEXT_winsize_get
-    if _newclass:winsize = property(_csnd.PVSDATEXT_winsize_get, _csnd.PVSDATEXT_winsize_set)
-    __swig_setmethods__["wintype"] = _csnd.PVSDATEXT_wintype_set
-    __swig_getmethods__["wintype"] = _csnd.PVSDATEXT_wintype_get
-    if _newclass:wintype = property(_csnd.PVSDATEXT_wintype_get, _csnd.PVSDATEXT_wintype_set)
-    __swig_setmethods__["format"] = _csnd.PVSDATEXT_format_set
-    __swig_getmethods__["format"] = _csnd.PVSDATEXT_format_get
-    if _newclass:format = property(_csnd.PVSDATEXT_format_get, _csnd.PVSDATEXT_format_set)
-    __swig_setmethods__["framecount"] = _csnd.PVSDATEXT_framecount_set
-    __swig_getmethods__["framecount"] = _csnd.PVSDATEXT_framecount_get
-    if _newclass:framecount = property(_csnd.PVSDATEXT_framecount_get, _csnd.PVSDATEXT_framecount_set)
-    __swig_setmethods__["frame"] = _csnd.PVSDATEXT_frame_set
-    __swig_getmethods__["frame"] = _csnd.PVSDATEXT_frame_get
-    if _newclass:frame = property(_csnd.PVSDATEXT_frame_get, _csnd.PVSDATEXT_frame_set)
-    def __init__(self, *args): 
-        """__init__(self) -> PVSDATEXT"""
-        this = _csnd.new_PVSDATEXT(*args)
-        try: self.this.append(this)
-        except: self.this = this
-    __swig_destroy__ = _csnd.delete_PVSDATEXT
-    __del__ = lambda self : None;
-PVSDATEXT_swigregister = _csnd.PVSDATEXT_swigregister
-PVSDATEXT_swigregister(PVSDATEXT)
-
-
-def csoundInitialize(*args):
-  """csoundInitialize(int argc, char argv, int flags) -> int"""
-  return _csnd.csoundInitialize(*args)
-
-def csoundCreate(*args):
-  """csoundCreate(void hostData) -> CSOUND"""
-  return _csnd.csoundCreate(*args)
-
-def csoundPreCompile(*args):
-  """csoundPreCompile(CSOUND ?) -> int"""
-  return _csnd.csoundPreCompile(*args)
-
-def csoundInitializeCscore(*args):
-  """csoundInitializeCscore(CSOUND ?, FILE insco, FILE outsco) -> int"""
-  return _csnd.csoundInitializeCscore(*args)
-
-def csoundQueryInterface(*args):
-  """csoundQueryInterface(char name, void iface, int version) -> int"""
-  return _csnd.csoundQueryInterface(*args)
-
-def csoundDestroy(*args):
-  """csoundDestroy(CSOUND ?)"""
-  return _csnd.csoundDestroy(*args)
-
-def csoundGetVersion(*args):
-  """csoundGetVersion() -> int"""
-  return _csnd.csoundGetVersion(*args)
-
-def csoundGetAPIVersion(*args):
-  """csoundGetAPIVersion() -> int"""
-  return _csnd.csoundGetAPIVersion(*args)
-
-def csoundGetHostData(*args):
-  """csoundGetHostData(CSOUND ?) -> void"""
-  return _csnd.csoundGetHostData(*args)
-
-def csoundSetHostData(*args):
-  """csoundSetHostData(CSOUND ?, void hostData)"""
-  return _csnd.csoundSetHostData(*args)
-
-def csoundGetEnv(*args):
-  """csoundGetEnv(CSOUND csound, char name) -> char"""
-  return _csnd.csoundGetEnv(*args)
-
-def csoundSetGlobalEnv(*args):
-  """csoundSetGlobalEnv(char name, char value) -> int"""
-  return _csnd.csoundSetGlobalEnv(*args)
-
-def csoundCompile(*args):
-  """csoundCompile(CSOUND ?, int argc, char argv) -> int"""
-  return _csnd.csoundCompile(*args)
-
-def csoundPerform(*args):
-  """csoundPerform(CSOUND ?) -> int"""
-  return _csnd.csoundPerform(*args)
-
-def csoundPerformKsmps(*args):
-  """csoundPerformKsmps(CSOUND ?) -> int"""
-  return _csnd.csoundPerformKsmps(*args)
-
-def csoundPerformKsmpsAbsolute(*args):
-  """csoundPerformKsmpsAbsolute(CSOUND ?) -> int"""
-  return _csnd.csoundPerformKsmpsAbsolute(*args)
-
-def csoundPerformBuffer(*args):
-  """csoundPerformBuffer(CSOUND ?) -> int"""
-  return _csnd.csoundPerformBuffer(*args)
-
-def csoundStop(*args):
-  """csoundStop(CSOUND ?)"""
-  return _csnd.csoundStop(*args)
-
-def csoundCleanup(*args):
-  """csoundCleanup(CSOUND ?) -> int"""
-  return _csnd.csoundCleanup(*args)
-
-def csoundReset(*args):
-  """csoundReset(CSOUND ?)"""
-  return _csnd.csoundReset(*args)
-
-def csoundGetSr(*args):
-  """csoundGetSr(CSOUND ?) -> float"""
-  return _csnd.csoundGetSr(*args)
-
-def csoundGetKr(*args):
-  """csoundGetKr(CSOUND ?) -> float"""
-  return _csnd.csoundGetKr(*args)
-
-def csoundGetKsmps(*args):
-  """csoundGetKsmps(CSOUND ?) -> int"""
-  return _csnd.csoundGetKsmps(*args)
-
-def csoundGetNchnls(*args):
-  """csoundGetNchnls(CSOUND ?) -> int"""
-  return _csnd.csoundGetNchnls(*args)
-
-def csoundGet0dBFS(*args):
-  """csoundGet0dBFS(CSOUND ?) -> float"""
-  return _csnd.csoundGet0dBFS(*args)
-
-def csoundGetStrVarMaxLen(*args):
-  """csoundGetStrVarMaxLen(CSOUND ?) -> int"""
-  return _csnd.csoundGetStrVarMaxLen(*args)
-
-def csoundGetSampleFormat(*args):
-  """csoundGetSampleFormat(CSOUND ?) -> int"""
-  return _csnd.csoundGetSampleFormat(*args)
-
-def csoundGetSampleSize(*args):
-  """csoundGetSampleSize(CSOUND ?) -> int"""
-  return _csnd.csoundGetSampleSize(*args)
-
-def csoundGetInputBufferSize(*args):
-  """csoundGetInputBufferSize(CSOUND ?) -> long"""
-  return _csnd.csoundGetInputBufferSize(*args)
-
-def csoundGetOutputBufferSize(*args):
-  """csoundGetOutputBufferSize(CSOUND ?) -> long"""
-  return _csnd.csoundGetOutputBufferSize(*args)
-
-def csoundGetInputBuffer(*args):
-  """csoundGetInputBuffer(CSOUND ?) -> float"""
-  return _csnd.csoundGetInputBuffer(*args)
-
-def csoundGetOutputBuffer(*args):
-  """csoundGetOutputBuffer(CSOUND ?) -> float"""
-  return _csnd.csoundGetOutputBuffer(*args)
-
-def csoundGetSpin(*args):
-  """csoundGetSpin(CSOUND ?) -> float"""
-  return _csnd.csoundGetSpin(*args)
-
-def csoundGetSpout(*args):
-  """csoundGetSpout(CSOUND ?) -> float"""
-  return _csnd.csoundGetSpout(*args)
-
-def csoundGetOutputFileName(*args):
-  """csoundGetOutputFileName(CSOUND ?) -> char"""
-  return _csnd.csoundGetOutputFileName(*args)
-
-def csoundSetHostImplementedAudioIO(*args):
-  """csoundSetHostImplementedAudioIO(CSOUND ?, int state, int bufSize)"""
-  return _csnd.csoundSetHostImplementedAudioIO(*args)
-
-def csoundGetScoreTime(*args):
-  """csoundGetScoreTime(CSOUND ?) -> double"""
-  return _csnd.csoundGetScoreTime(*args)
-
-def csoundIsScorePending(*args):
-  """csoundIsScorePending(CSOUND ?) -> int"""
-  return _csnd.csoundIsScorePending(*args)
-
-def csoundSetScorePending(*args):
-  """csoundSetScorePending(CSOUND ?, int pending)"""
-  return _csnd.csoundSetScorePending(*args)
-
-def csoundGetScoreOffsetSeconds(*args):
-  """csoundGetScoreOffsetSeconds(CSOUND ?) -> float"""
-  return _csnd.csoundGetScoreOffsetSeconds(*args)
-
-def csoundSetScoreOffsetSeconds(*args):
-  """csoundSetScoreOffsetSeconds(CSOUND ?, float time)"""
-  return _csnd.csoundSetScoreOffsetSeconds(*args)
-
-def csoundRewindScore(*args):
-  """csoundRewindScore(CSOUND ?)"""
-  return _csnd.csoundRewindScore(*args)
-
-def csoundScoreSort(*args):
-  """csoundScoreSort(CSOUND ?, FILE inFile, FILE outFile) -> int"""
-  return _csnd.csoundScoreSort(*args)
-
-def csoundScoreExtract(*args):
-  """csoundScoreExtract(CSOUND ?, FILE inFile, FILE outFile, FILE extractFile) -> int"""
-  return _csnd.csoundScoreExtract(*args)
-
-def csoundMessage(*args):
-  """csoundMessage(CSOUND ?, char format, v(...) ?)"""
-  return _csnd.csoundMessage(*args)
-
-def csoundMessageS(*args):
-  """csoundMessageS(CSOUND ?, int attr, char format, v(...) ?)"""
-  return _csnd.csoundMessageS(*args)
-
-def csoundGetMessageLevel(*args):
-  """csoundGetMessageLevel(CSOUND ?) -> int"""
-  return _csnd.csoundGetMessageLevel(*args)
-
-def csoundSetMessageLevel(*args):
-  """csoundSetMessageLevel(CSOUND ?, int messageLevel)"""
-  return _csnd.csoundSetMessageLevel(*args)
-
-def csoundInputMessage(*args):
-  """csoundInputMessage(CSOUND ?, char message)"""
-  return _csnd.csoundInputMessage(*args)
-
-def csoundKeyPress(*args):
-  """csoundKeyPress(CSOUND ?, char c)"""
-  return _csnd.csoundKeyPress(*args)
-
-def csoundScoreEvent(*args):
-  """csoundScoreEvent(CSOUND ?, char type, float pFields, long numFields) -> int"""
-  return _csnd.csoundScoreEvent(*args)
-
-def csoundNewOpcodeList(*args):
-  """csoundNewOpcodeList(CSOUND ?, opcodeListEntry opcodelist) -> int"""
-  return _csnd.csoundNewOpcodeList(*args)
-
-def csoundDisposeOpcodeList(*args):
-  """csoundDisposeOpcodeList(CSOUND ?, opcodeListEntry opcodelist)"""
-  return _csnd.csoundDisposeOpcodeList(*args)
-
-def csoundAppendOpcode(*args):
-  """
-    csoundAppendOpcode(CSOUND ?, char opname, int dsblksiz, int thread, char outypes, 
-        char intypes, int iopadr, int kopadr, 
-        int aopadr) -> int
-    """
-  return _csnd.csoundAppendOpcode(*args)
-
-def csoundOpenLibrary(*args):
-  """csoundOpenLibrary(void library, char libraryPath) -> int"""
-  return _csnd.csoundOpenLibrary(*args)
-
-def csoundCloseLibrary(*args):
-  """csoundCloseLibrary(void library) -> int"""
-  return _csnd.csoundCloseLibrary(*args)
-
-def csoundGetLibrarySymbol(*args):
-  """csoundGetLibrarySymbol(void library, char symbolName) -> void"""
-  return _csnd.csoundGetLibrarySymbol(*args)
-
-def csoundGetDebug(*args):
-  """csoundGetDebug(CSOUND ?) -> int"""
-  return _csnd.csoundGetDebug(*args)
-
-def csoundSetDebug(*args):
-  """csoundSetDebug(CSOUND ?, int debug)"""
-  return _csnd.csoundSetDebug(*args)
-
-def csoundTableLength(*args):
-  """csoundTableLength(CSOUND ?, int table) -> int"""
-  return _csnd.csoundTableLength(*args)
-
-def csoundTableGet(*args):
-  """csoundTableGet(CSOUND ?, int table, int index) -> float"""
-  return _csnd.csoundTableGet(*args)
-
-def csoundTableSet(*args):
-  """csoundTableSet(CSOUND ?, int table, int index, float value)"""
-  return _csnd.csoundTableSet(*args)
-
-def csoundGetTable(*args):
-  """csoundGetTable(CSOUND ?, float tablePtr, int tableNum) -> int"""
-  return _csnd.csoundGetTable(*args)
-
-def csoundCreateThread(*args):
-  """csoundCreateThread(uintptr_t threadRoutine, void userdata) -> void"""
-  return _csnd.csoundCreateThread(*args)
-
-def csoundGetCurrentThreadId(*args):
-  """csoundGetCurrentThreadId() -> void"""
-  return _csnd.csoundGetCurrentThreadId(*args)
-
-def csoundJoinThread(*args):
-  """csoundJoinThread(void thread) -> uintptr_t"""
-  return _csnd.csoundJoinThread(*args)
-
-def csoundRunCommand(*args):
-  """csoundRunCommand(char argv, int noWait) -> long"""
-  return _csnd.csoundRunCommand(*args)
-
-def csoundCreateThreadLock(*args):
-  """csoundCreateThreadLock() -> void"""
-  return _csnd.csoundCreateThreadLock(*args)
-
-def csoundWaitThreadLock(*args):
-  """csoundWaitThreadLock(void lock, size_t milliseconds) -> int"""
-  return _csnd.csoundWaitThreadLock(*args)
-
-def csoundWaitThreadLockNoTimeout(*args):
-  """csoundWaitThreadLockNoTimeout(void lock)"""
-  return _csnd.csoundWaitThreadLockNoTimeout(*args)
-
-def csoundNotifyThreadLock(*args):
-  """csoundNotifyThreadLock(void lock)"""
-  return _csnd.csoundNotifyThreadLock(*args)
-
-def csoundDestroyThreadLock(*args):
-  """csoundDestroyThreadLock(void lock)"""
-  return _csnd.csoundDestroyThreadLock(*args)
-
-def csoundCreateMutex(*args):
-  """csoundCreateMutex(int isRecursive) -> void"""
-  return _csnd.csoundCreateMutex(*args)
-
-def csoundLockMutex(*args):
-  """csoundLockMutex(void mutex_)"""
-  return _csnd.csoundLockMutex(*args)
-
-def csoundLockMutexNoWait(*args):
-  """csoundLockMutexNoWait(void mutex_) -> int"""
-  return _csnd.csoundLockMutexNoWait(*args)
-
-def csoundUnlockMutex(*args):
-  """csoundUnlockMutex(void mutex_)"""
-  return _csnd.csoundUnlockMutex(*args)
-
-def csoundDestroyMutex(*args):
-  """csoundDestroyMutex(void mutex_)"""
-  return _csnd.csoundDestroyMutex(*args)
-
-def csoundSleep(*args):
-  """csoundSleep(size_t milliseconds)"""
-  return _csnd.csoundSleep(*args)
-
-def csoundInitTimerStruct(*args):
-  """csoundInitTimerStruct( ?)"""
-  return _csnd.csoundInitTimerStruct(*args)
-
-def csoundGetRealTime(*args):
-  """csoundGetRealTime( ?) -> double"""
-  return _csnd.csoundGetRealTime(*args)
-
-def csoundGetCPUTime(*args):
-  """csoundGetCPUTime( ?) -> double"""
-  return _csnd.csoundGetCPUTime(*args)
-
-def csoundGetRandomSeedFromTime(*args):
-  """csoundGetRandomSeedFromTime() -> uint32_t"""
-  return _csnd.csoundGetRandomSeedFromTime(*args)
-
-def csoundSetLanguage(*args):
-  """csoundSetLanguage(cslanguage_t lang_code)"""
-  return _csnd.csoundSetLanguage(*args)
-
-def csoundLocalizeString(*args):
-  """csoundLocalizeString(char s) -> char"""
-  return _csnd.csoundLocalizeString(*args)
-
-def csoundCreateGlobalVariable(*args):
-  """csoundCreateGlobalVariable(CSOUND ?, char name, size_t nbytes) -> int"""
-  return _csnd.csoundCreateGlobalVariable(*args)
-
-def csoundQueryGlobalVariable(*args):
-  """csoundQueryGlobalVariable(CSOUND ?, char name) -> void"""
-  return _csnd.csoundQueryGlobalVariable(*args)
-
-def csoundQueryGlobalVariableNoCheck(*args):
-  """csoundQueryGlobalVariableNoCheck(CSOUND ?, char name) -> void"""
-  return _csnd.csoundQueryGlobalVariableNoCheck(*args)
-
-def csoundDestroyGlobalVariable(*args):
-  """csoundDestroyGlobalVariable(CSOUND ?, char name) -> int"""
-  return _csnd.csoundDestroyGlobalVariable(*args)
-
-def csoundGetSizeOfMYFLT(*args):
-  """csoundGetSizeOfMYFLT() -> int"""
-  return _csnd.csoundGetSizeOfMYFLT(*args)
-
-def csoundGetRtRecordUserData(*args):
-  """csoundGetRtRecordUserData(CSOUND ?) -> void"""
-  return _csnd.csoundGetRtRecordUserData(*args)
-
-def csoundGetRtPlayUserData(*args):
-  """csoundGetRtPlayUserData(CSOUND ?) -> void"""
-  return _csnd.csoundGetRtPlayUserData(*args)
-
-def csoundRunUtility(*args):
-  """csoundRunUtility(CSOUND ?, char name, int argc, char argv) -> int"""
-  return _csnd.csoundRunUtility(*args)
-
-def csoundListUtilities(*args):
-  """csoundListUtilities(CSOUND ?) -> char"""
-  return _csnd.csoundListUtilities(*args)
-
-def csoundDeleteUtilityList(*args):
-  """csoundDeleteUtilityList(CSOUND ?, char lst)"""
-  return _csnd.csoundDeleteUtilityList(*args)
-
-def csoundGetUtilityDescription(*args):
-  """csoundGetUtilityDescription(CSOUND ?, char utilName) -> char"""
-  return _csnd.csoundGetUtilityDescription(*args)
-
-def csoundGetChannelPtr(*args):
-  """csoundGetChannelPtr(CSOUND ?, float p, char name, int type) -> int"""
-  return _csnd.csoundGetChannelPtr(*args)
-
-def csoundListChannels(*args):
-  """csoundListChannels(CSOUND ?,  lst) -> int"""
-  return _csnd.csoundListChannels(*args)
-
-def csoundDeleteChannelList(*args):
-  """csoundDeleteChannelList(CSOUND ?,  lst)"""
-  return _csnd.csoundDeleteChannelList(*args)
-
-def csoundSetControlChannelParams(*args):
-  """
-    csoundSetControlChannelParams(CSOUND ?, char name, int type, float dflt, float min, 
-        float max) -> int
-    """
-  return _csnd.csoundSetControlChannelParams(*args)
-
-def csoundGetControlChannelParams(*args):
-  """csoundGetControlChannelParams(CSOUND ?, char name, float dflt, float min, float max) -> int"""
-  return _csnd.csoundGetControlChannelParams(*args)
-
-def csoundSetChannelIOCallback(*args):
-  """csoundSetChannelIOCallback(CSOUND ?, CsoundChannelIOCallback_t func)"""
-  return _csnd.csoundSetChannelIOCallback(*args)
-
-def csoundRand31(*args):
-  """csoundRand31(int seedVal) -> int"""
-  return _csnd.csoundRand31(*args)
-
-def csoundSeedRandMT(*args):
-  """csoundSeedRandMT( p, uint32_t initKey, uint32_t keyLength)"""
-  return _csnd.csoundSeedRandMT(*args)
-
-def csoundRandMT(*args):
-  """csoundRandMT( p) -> uint32_t"""
-  return _csnd.csoundRandMT(*args)
-
-def csoundChanIKSet(*args):
-  """csoundChanIKSet(CSOUND ?, float value, int n) -> int"""
-  return _csnd.csoundChanIKSet(*args)
-
-def csoundChanOKGet(*args):
-  """csoundChanOKGet(CSOUND ?, float value, int n) -> int"""
-  return _csnd.csoundChanOKGet(*args)
-
-def csoundChanIASet(*args):
-  """csoundChanIASet(CSOUND ?, float value, int n) -> int"""
-  return _csnd.csoundChanIASet(*args)
-
-def csoundChanOAGet(*args):
-  """csoundChanOAGet(CSOUND ?, float value, int n) -> int"""
-  return _csnd.csoundChanOAGet(*args)
-
-def csoundPvsinSet(*args):
-  """csoundPvsinSet(CSOUND ?,  fin, int n) -> int"""
-  return _csnd.csoundPvsinSet(*args)
-
-def csoundPvsoutGet(*args):
-  """csoundPvsoutGet(CSOUND csound,  fout, int n) -> int"""
-  return _csnd.csoundPvsoutGet(*args)
-
-def csoundSetCallback(*args):
-  """csoundSetCallback(CSOUND ?, int func, void userData, unsigned int typeMask) -> int"""
-  return _csnd.csoundSetCallback(*args)
-
-def csoundRemoveCallback(*args):
-  """csoundRemoveCallback(CSOUND ?, int func)"""
-  return _csnd.csoundRemoveCallback(*args)
-class csCfgVariableHead_t(_object):
-    """Proxy of C++ csCfgVariableHead_t class"""
-    __swig_setmethods__ = {}
-    __setattr__ = lambda self, name, value: _swig_setattr(self, csCfgVariableHead_t, name, value)
-    __swig_getmethods__ = {}
-    __getattr__ = lambda self, name: _swig_getattr(self, csCfgVariableHead_t, name)
-    __repr__ = _swig_repr
-    __swig_setmethods__["nxt"] = _csnd.csCfgVariableHead_t_nxt_set
-    __swig_getmethods__["nxt"] = _csnd.csCfgVariableHead_t_nxt_get
-    if _newclass:nxt = property(_csnd.csCfgVariableHead_t_nxt_get, _csnd.csCfgVariableHead_t_nxt_set)
-    __swig_setmethods__["name"] = _csnd.csCfgVariableHead_t_name_set
-    __swig_getmethods__["name"] = _csnd.csCfgVariableHead_t_name_get
-    if _newclass:name = property(_csnd.csCfgVariableHead_t_name_get, _csnd.csCfgVariableHead_t_name_set)
-    __swig_setmethods__["p"] = _csnd.csCfgVariableHead_t_p_set
-    __swig_getmethods__["p"] = _csnd.csCfgVariableHead_t_p_get
-    if _newclass:p = property(_csnd.csCfgVariableHead_t_p_get, _csnd.csCfgVariableHead_t_p_set)
-    __swig_setmethods__["type"] = _csnd.csCfgVariableHead_t_type_set
-    __swig_getmethods__["type"] = _csnd.csCfgVariableHead_t_type_get
-    if _newclass:type = property(_csnd.csCfgVariableHead_t_type_get, _csnd.csCfgVariableHead_t_type_set)
-    __swig_setmethods__["flags"] = _csnd.csCfgVariableHead_t_flags_set
-    __swig_getmethods__["flags"] = _csnd.csCfgVariableHead_t_flags_get
-    if _newclass:flags = property(_csnd.csCfgVariableHead_t_flags_get, _csnd.csCfgVariableHead_t_flags_set)
-    __swig_setmethods__["shortDesc"] = _csnd.csCfgVariableHead_t_shortDesc_set
-    __swig_getmethods__["shortDesc"] = _csnd.csCfgVariableHead_t_shortDesc_get
-    if _newclass:shortDesc = property(_csnd.csCfgVariableHead_t_shortDesc_get, _csnd.csCfgVariableHead_t_shortDesc_set)
-    __swig_setmethods__["longDesc"] = _csnd.csCfgVariableHead_t_longDesc_set
-    __swig_getmethods__["longDesc"] = _csnd.csCfgVariableHead_t_longDesc_get
-    if _newclass:longDesc = property(_csnd.csCfgVariableHead_t_longDesc_get, _csnd.csCfgVariableHead_t_longDesc_set)
-    def __init__(self, *args): 
-        """__init__(self) -> csCfgVariableHead_t"""
-        this = _csnd.new_csCfgVariableHead_t(*args)
-        try: self.this.append(this)
-        except: self.this = this
-    __swig_destroy__ = _csnd.delete_csCfgVariableHead_t
-    __del__ = lambda self : None;
-csCfgVariableHead_t_swigregister = _csnd.csCfgVariableHead_t_swigregister
-csCfgVariableHead_t_swigregister(csCfgVariableHead_t)
-
-class csCfgVariableInt_t(_object):
-    """Proxy of C++ csCfgVariableInt_t class"""
-    __swig_setmethods__ = {}
-    __setattr__ = lambda self, name, value: _swig_setattr(self, csCfgVariableInt_t, name, value)
-    __swig_getmethods__ = {}
-    __getattr__ = lambda self, name: _swig_getattr(self, csCfgVariableInt_t, name)
-    __repr__ = _swig_repr
-    __swig_setmethods__["nxt"] = _csnd.csCfgVariableInt_t_nxt_set
-    __swig_getmethods__["nxt"] = _csnd.csCfgVariableInt_t_nxt_get
-    if _newclass:nxt = property(_csnd.csCfgVariableInt_t_nxt_get, _csnd.csCfgVariableInt_t_nxt_set)
-    __swig_setmethods__["name"] = _csnd.csCfgVariableInt_t_name_set
-    __swig_getmethods__["name"] = _csnd.csCfgVariableInt_t_name_get
-    if _newclass:name = property(_csnd.csCfgVariableInt_t_name_get, _csnd.csCfgVariableInt_t_name_set)
-    __swig_setmethods__["p"] = _csnd.csCfgVariableInt_t_p_set
-    __swig_getmethods__["p"] = _csnd.csCfgVariableInt_t_p_get
-    if _newclass:p = property(_csnd.csCfgVariableInt_t_p_get, _csnd.csCfgVariableInt_t_p_set)
-    __swig_setmethods__["type"] = _csnd.csCfgVariableInt_t_type_set
-    __swig_getmethods__["type"] = _csnd.csCfgVariableInt_t_type_get
-    if _newclass:type = property(_csnd.csCfgVariableInt_t_type_get, _csnd.csCfgVariableInt_t_type_set)
-    __swig_setmethods__["flags"] = _csnd.csCfgVariableInt_t_flags_set
-    __swig_getmethods__["flags"] = _csnd.csCfgVariableInt_t_flags_get
-    if _newclass:flags = property(_csnd.csCfgVariableInt_t_flags_get, _csnd.csCfgVariableInt_t_flags_set)
-    __swig_setmethods__["shortDesc"] = _csnd.csCfgVariableInt_t_shortDesc_set
-    __swig_getmethods__["shortDesc"] = _csnd.csCfgVariableInt_t_shortDesc_get
-    if _newclass:shortDesc = property(_csnd.csCfgVariableInt_t_shortDesc_get, _csnd.csCfgVariableInt_t_shortDesc_set)
-    __swig_setmethods__["longDesc"] = _csnd.csCfgVariableInt_t_longDesc_set
-    __swig_getmethods__["longDesc"] = _csnd.csCfgVariableInt_t_longDesc_get
-    if _newclass:longDesc = property(_csnd.csCfgVariableInt_t_longDesc_get, _csnd.csCfgVariableInt_t_longDesc_set)
-    __swig_setmethods__["min"] = _csnd.csCfgVariableInt_t_min_set
-    __swig_getmethods__["min"] = _csnd.csCfgVariableInt_t_min_get
-    if _newclass:min = property(_csnd.csCfgVariableInt_t_min_get, _csnd.csCfgVariableInt_t_min_set)
-    __swig_setmethods__["max"] = _csnd.csCfgVariableInt_t_max_set
-    __swig_getmethods__["max"] = _csnd.csCfgVariableInt_t_max_get
-    if _newclass:max = property(_csnd.csCfgVariableInt_t_max_get, _csnd.csCfgVariableInt_t_max_set)
-    def __init__(self, *args): 
-        """__init__(self) -> csCfgVariableInt_t"""
-        this = _csnd.new_csCfgVariableInt_t(*args)
-        try: self.this.append(this)
-        except: self.this = this
-    __swig_destroy__ = _csnd.delete_csCfgVariableInt_t
-    __del__ = lambda self : None;
-csCfgVariableInt_t_swigregister = _csnd.csCfgVariableInt_t_swigregister
-csCfgVariableInt_t_swigregister(csCfgVariableInt_t)
-
-class csCfgVariableBoolean_t(_object):
-    """Proxy of C++ csCfgVariableBoolean_t class"""
-    __swig_setmethods__ = {}
-    __setattr__ = lambda self, name, value: _swig_setattr(self, csCfgVariableBoolean_t, name, value)
-    __swig_getmethods__ = {}
-    __getattr__ = lambda self, name: _swig_getattr(self, csCfgVariableBoolean_t, name)
-    __repr__ = _swig_repr
-    __swig_setmethods__["nxt"] = _csnd.csCfgVariableBoolean_t_nxt_set
-    __swig_getmethods__["nxt"] = _csnd.csCfgVariableBoolean_t_nxt_get
-    if _newclass:nxt = property(_csnd.csCfgVariableBoolean_t_nxt_get, _csnd.csCfgVariableBoolean_t_nxt_set)
-    __swig_setmethods__["name"] = _csnd.csCfgVariableBoolean_t_name_set
-    __swig_getmethods__["name"] = _csnd.csCfgVariableBoolean_t_name_get
-    if _newclass:name = property(_csnd.csCfgVariableBoolean_t_name_get, _csnd.csCfgVariableBoolean_t_name_set)
-    __swig_setmethods__["p"] = _csnd.csCfgVariableBoolean_t_p_set
-    __swig_getmethods__["p"] = _csnd.csCfgVariableBoolean_t_p_get
-    if _newclass:p = property(_csnd.csCfgVariableBoolean_t_p_get, _csnd.csCfgVariableBoolean_t_p_set)
-    __swig_setmethods__["type"] = _csnd.csCfgVariableBoolean_t_type_set
-    __swig_getmethods__["type"] = _csnd.csCfgVariableBoolean_t_type_get
-    if _newclass:type = property(_csnd.csCfgVariableBoolean_t_type_get, _csnd.csCfgVariableBoolean_t_type_set)
-    __swig_setmethods__["flags"] = _csnd.csCfgVariableBoolean_t_flags_set
-    __swig_getmethods__["flags"] = _csnd.csCfgVariableBoolean_t_flags_get
-    if _newclass:flags = property(_csnd.csCfgVariableBoolean_t_flags_get, _csnd.csCfgVariableBoolean_t_flags_set)
-    __swig_setmethods__["shortDesc"] = _csnd.csCfgVariableBoolean_t_shortDesc_set
-    __swig_getmethods__["shortDesc"] = _csnd.csCfgVariableBoolean_t_shortDesc_get
-    if _newclass:shortDesc = property(_csnd.csCfgVariableBoolean_t_shortDesc_get, _csnd.csCfgVariableBoolean_t_shortDesc_set)
-    __swig_setmethods__["longDesc"] = _csnd.csCfgVariableBoolean_t_longDesc_set
-    __swig_getmethods__["longDesc"] = _csnd.csCfgVariableBoolean_t_longDesc_get
-    if _newclass:longDesc = property(_csnd.csCfgVariableBoolean_t_longDesc_get, _csnd.csCfgVariableBoolean_t_longDesc_set)
-    def __init__(self, *args): 
-        """__init__(self) -> csCfgVariableBoolean_t"""
-        this = _csnd.new_csCfgVariableBoolean_t(*args)
-        try: self.this.append(this)
-        except: self.this = this
-    __swig_destroy__ = _csnd.delete_csCfgVariableBoolean_t
-    __del__ = lambda self : None;
-csCfgVariableBoolean_t_swigregister = _csnd.csCfgVariableBoolean_t_swigregister
-csCfgVariableBoolean_t_swigregister(csCfgVariableBoolean_t)
-
-class csCfgVariableFloat_t(_object):
-    """Proxy of C++ csCfgVariableFloat_t class"""
-    __swig_setmethods__ = {}
-    __setattr__ = lambda self, name, value: _swig_setattr(self, csCfgVariableFloat_t, name, value)
-    __swig_getmethods__ = {}
-    __getattr__ = lambda self, name: _swig_getattr(self, csCfgVariableFloat_t, name)
-    __repr__ = _swig_repr
-    __swig_setmethods__["nxt"] = _csnd.csCfgVariableFloat_t_nxt_set
-    __swig_getmethods__["nxt"] = _csnd.csCfgVariableFloat_t_nxt_get
-    if _newclass:nxt = property(_csnd.csCfgVariableFloat_t_nxt_get, _csnd.csCfgVariableFloat_t_nxt_set)
-    __swig_setmethods__["name"] = _csnd.csCfgVariableFloat_t_name_set
-    __swig_getmethods__["name"] = _csnd.csCfgVariableFloat_t_name_get
-    if _newclass:name = property(_csnd.csCfgVariableFloat_t_name_get, _csnd.csCfgVariableFloat_t_name_set)
-    __swig_setmethods__["p"] = _csnd.csCfgVariableFloat_t_p_set
-    __swig_getmethods__["p"] = _csnd.csCfgVariableFloat_t_p_get
-    if _newclass:p = property(_csnd.csCfgVariableFloat_t_p_get, _csnd.csCfgVariableFloat_t_p_set)
-    __swig_setmethods__["type"] = _csnd.csCfgVariableFloat_t_type_set
-    __swig_getmethods__["type"] = _csnd.csCfgVariableFloat_t_type_get
-    if _newclass:type = property(_csnd.csCfgVariableFloat_t_type_get, _csnd.csCfgVariableFloat_t_type_set)
-    __swig_setmethods__["flags"] = _csnd.csCfgVariableFloat_t_flags_set
-    __swig_getmethods__["flags"] = _csnd.csCfgVariableFloat_t_flags_get
-    if _newclass:flags = property(_csnd.csCfgVariableFloat_t_flags_get, _csnd.csCfgVariableFloat_t_flags_set)
-    __swig_setmethods__["shortDesc"] = _csnd.csCfgVariableFloat_t_shortDesc_set
-    __swig_getmethods__["shortDesc"] = _csnd.csCfgVariableFloat_t_shortDesc_get
-    if _newclass:shortDesc = property(_csnd.csCfgVariableFloat_t_shortDesc_get, _csnd.csCfgVariableFloat_t_shortDesc_set)
-    __swig_setmethods__["longDesc"] = _csnd.csCfgVariableFloat_t_longDesc_set
-    __swig_getmethods__["longDesc"] = _csnd.csCfgVariableFloat_t_longDesc_get
-    if _newclass:longDesc = property(_csnd.csCfgVariableFloat_t_longDesc_get, _csnd.csCfgVariableFloat_t_longDesc_set)
-    __swig_setmethods__["min"] = _csnd.csCfgVariableFloat_t_min_set
-    __swig_getmethods__["min"] = _csnd.csCfgVariableFloat_t_min_get
-    if _newclass:min = property(_csnd.csCfgVariableFloat_t_min_get, _csnd.csCfgVariableFloat_t_min_set)
-    __swig_setmethods__["max"] = _csnd.csCfgVariableFloat_t_max_set
-    __swig_getmethods__["max"] = _csnd.csCfgVariableFloat_t_max_get
-    if _newclass:max = property(_csnd.csCfgVariableFloat_t_max_get, _csnd.csCfgVariableFloat_t_max_set)
-    def __init__(self, *args): 
-        """__init__(self) -> csCfgVariableFloat_t"""
-        this = _csnd.new_csCfgVariableFloat_t(*args)
-        try: self.this.append(this)
-        except: self.this = this
-    __swig_destroy__ = _csnd.delete_csCfgVariableFloat_t
-    __del__ = lambda self : None;
-csCfgVariableFloat_t_swigregister = _csnd.csCfgVariableFloat_t_swigregister
-csCfgVariableFloat_t_swigregister(csCfgVariableFloat_t)
-
-class csCfgVariableDouble_t(_object):
-    """Proxy of C++ csCfgVariableDouble_t class"""
-    __swig_setmethods__ = {}
-    __setattr__ = lambda self, name, value: _swig_setattr(self, csCfgVariableDouble_t, name, value)
-    __swig_getmethods__ = {}
-    __getattr__ = lambda self, name: _swig_getattr(self, csCfgVariableDouble_t, name)
-    __repr__ = _swig_repr
-    __swig_setmethods__["nxt"] = _csnd.csCfgVariableDouble_t_nxt_set
-    __swig_getmethods__["nxt"] = _csnd.csCfgVariableDouble_t_nxt_get
-    if _newclass:nxt = property(_csnd.csCfgVariableDouble_t_nxt_get, _csnd.csCfgVariableDouble_t_nxt_set)
-    __swig_setmethods__["name"] = _csnd.csCfgVariableDouble_t_name_set
-    __swig_getmethods__["name"] = _csnd.csCfgVariableDouble_t_name_get
-    if _newclass:name = property(_csnd.csCfgVariableDouble_t_name_get, _csnd.csCfgVariableDouble_t_name_set)
-    __swig_setmethods__["p"] = _csnd.csCfgVariableDouble_t_p_set
-    __swig_getmethods__["p"] = _csnd.csCfgVariableDouble_t_p_get
-    if _newclass:p = property(_csnd.csCfgVariableDouble_t_p_get, _csnd.csCfgVariableDouble_t_p_set)
-    __swig_setmethods__["type"] = _csnd.csCfgVariableDouble_t_type_set
-    __swig_getmethods__["type"] = _csnd.csCfgVariableDouble_t_type_get
-    if _newclass:type = property(_csnd.csCfgVariableDouble_t_type_get, _csnd.csCfgVariableDouble_t_type_set)
-    __swig_setmethods__["flags"] = _csnd.csCfgVariableDouble_t_flags_set
-    __swig_getmethods__["flags"] = _csnd.csCfgVariableDouble_t_flags_get
-    if _newclass:flags = property(_csnd.csCfgVariableDouble_t_flags_get, _csnd.csCfgVariableDouble_t_flags_set)
-    __swig_setmethods__["shortDesc"] = _csnd.csCfgVariableDouble_t_shortDesc_set
-    __swig_getmethods__["shortDesc"] = _csnd.csCfgVariableDouble_t_shortDesc_get
-    if _newclass:shortDesc = property(_csnd.csCfgVariableDouble_t_shortDesc_get, _csnd.csCfgVariableDouble_t_shortDesc_set)
-    __swig_setmethods__["longDesc"] = _csnd.csCfgVariableDouble_t_longDesc_set
-    __swig_getmethods__["longDesc"] = _csnd.csCfgVariableDouble_t_longDesc_get
-    if _newclass:longDesc = property(_csnd.csCfgVariableDouble_t_longDesc_get, _csnd.csCfgVariableDouble_t_longDesc_set)
-    __swig_setmethods__["min"] = _csnd.csCfgVariableDouble_t_min_set
-    __swig_getmethods__["min"] = _csnd.csCfgVariableDouble_t_min_get
-    if _newclass:min = property(_csnd.csCfgVariableDouble_t_min_get, _csnd.csCfgVariableDouble_t_min_set)
-    __swig_setmethods__["max"] = _csnd.csCfgVariableDouble_t_max_set
-    __swig_getmethods__["max"] = _csnd.csCfgVariableDouble_t_max_get
-    if _newclass:max = property(_csnd.csCfgVariableDouble_t_max_get, _csnd.csCfgVariableDouble_t_max_set)
-    def __init__(self, *args): 
-        """__init__(self) -> csCfgVariableDouble_t"""
-        this = _csnd.new_csCfgVariableDouble_t(*args)
-        try: self.this.append(this)
-        except: self.this = this
-    __swig_destroy__ = _csnd.delete_csCfgVariableDouble_t
-    __del__ = lambda self : None;
-csCfgVariableDouble_t_swigregister = _csnd.csCfgVariableDouble_t_swigregister
-csCfgVariableDouble_t_swigregister(csCfgVariableDouble_t)
-
-class csCfgVariableMYFLT_t(_object):
-    """Proxy of C++ csCfgVariableMYFLT_t class"""
-    __swig_setmethods__ = {}
-    __setattr__ = lambda self, name, value: _swig_setattr(self, csCfgVariableMYFLT_t, name, value)
-    __swig_getmethods__ = {}
-    __getattr__ = lambda self, name: _swig_getattr(self, csCfgVariableMYFLT_t, name)
-    __repr__ = _swig_repr
-    __swig_setmethods__["nxt"] = _csnd.csCfgVariableMYFLT_t_nxt_set
-    __swig_getmethods__["nxt"] = _csnd.csCfgVariableMYFLT_t_nxt_get
-    if _newclass:nxt = property(_csnd.csCfgVariableMYFLT_t_nxt_get, _csnd.csCfgVariableMYFLT_t_nxt_set)
-    __swig_setmethods__["name"] = _csnd.csCfgVariableMYFLT_t_name_set
-    __swig_getmethods__["name"] = _csnd.csCfgVariableMYFLT_t_name_get
-    if _newclass:name = property(_csnd.csCfgVariableMYFLT_t_name_get, _csnd.csCfgVariableMYFLT_t_name_set)
-    __swig_setmethods__["p"] = _csnd.csCfgVariableMYFLT_t_p_set
-    __swig_getmethods__["p"] = _csnd.csCfgVariableMYFLT_t_p_get
-    if _newclass:p = property(_csnd.csCfgVariableMYFLT_t_p_get, _csnd.csCfgVariableMYFLT_t_p_set)
-    __swig_setmethods__["type"] = _csnd.csCfgVariableMYFLT_t_type_set
-    __swig_getmethods__["type"] = _csnd.csCfgVariableMYFLT_t_type_get
-    if _newclass:type = property(_csnd.csCfgVariableMYFLT_t_type_get, _csnd.csCfgVariableMYFLT_t_type_set)
-    __swig_setmethods__["flags"] = _csnd.csCfgVariableMYFLT_t_flags_set
-    __swig_getmethods__["flags"] = _csnd.csCfgVariableMYFLT_t_flags_get
-    if _newclass:flags = property(_csnd.csCfgVariableMYFLT_t_flags_get, _csnd.csCfgVariableMYFLT_t_flags_set)
-    __swig_setmethods__["shortDesc"] = _csnd.csCfgVariableMYFLT_t_shortDesc_set
-    __swig_getmethods__["shortDesc"] = _csnd.csCfgVariableMYFLT_t_shortDesc_get
-    if _newclass:shortDesc = property(_csnd.csCfgVariableMYFLT_t_shortDesc_get, _csnd.csCfgVariableMYFLT_t_shortDesc_set)
-    __swig_setmethods__["longDesc"] = _csnd.csCfgVariableMYFLT_t_longDesc_set
-    __swig_getmethods__["longDesc"] = _csnd.csCfgVariableMYFLT_t_longDesc_get
-    if _newclass:longDesc = property(_csnd.csCfgVariableMYFLT_t_longDesc_get, _csnd.csCfgVariableMYFLT_t_longDesc_set)
-    __swig_setmethods__["min"] = _csnd.csCfgVariableMYFLT_t_min_set
-    __swig_getmethods__["min"] = _csnd.csCfgVariableMYFLT_t_min_get
-    if _newclass:min = property(_csnd.csCfgVariableMYFLT_t_min_get, _csnd.csCfgVariableMYFLT_t_min_set)
-    __swig_setmethods__["max"] = _csnd.csCfgVariableMYFLT_t_max_set
-    __swig_getmethods__["max"] = _csnd.csCfgVariableMYFLT_t_max_get
-    if _newclass:max = property(_csnd.csCfgVariableMYFLT_t_max_get, _csnd.csCfgVariableMYFLT_t_max_set)
-    def __init__(self, *args): 
-        """__init__(self) -> csCfgVariableMYFLT_t"""
-        this = _csnd.new_csCfgVariableMYFLT_t(*args)
-        try: self.this.append(this)
-        except: self.this = this
-    __swig_destroy__ = _csnd.delete_csCfgVariableMYFLT_t
-    __del__ = lambda self : None;
-csCfgVariableMYFLT_t_swigregister = _csnd.csCfgVariableMYFLT_t_swigregister
-csCfgVariableMYFLT_t_swigregister(csCfgVariableMYFLT_t)
-
-class csCfgVariableString_t(_object):
-    """Proxy of C++ csCfgVariableString_t class"""
-    __swig_setmethods__ = {}
-    __setattr__ = lambda self, name, value: _swig_setattr(self, csCfgVariableString_t, name, value)
-    __swig_getmethods__ = {}
-    __getattr__ = lambda self, name: _swig_getattr(self, csCfgVariableString_t, name)
-    __repr__ = _swig_repr
-    __swig_setmethods__["nxt"] = _csnd.csCfgVariableString_t_nxt_set
-    __swig_getmethods__["nxt"] = _csnd.csCfgVariableString_t_nxt_get
-    if _newclass:nxt = property(_csnd.csCfgVariableString_t_nxt_get, _csnd.csCfgVariableString_t_nxt_set)
-    __swig_setmethods__["name"] = _csnd.csCfgVariableString_t_name_set
-    __swig_getmethods__["name"] = _csnd.csCfgVariableString_t_name_get
-    if _newclass:name = property(_csnd.csCfgVariableString_t_name_get, _csnd.csCfgVariableString_t_name_set)
-    __swig_setmethods__["p"] = _csnd.csCfgVariableString_t_p_set
-    __swig_getmethods__["p"] = _csnd.csCfgVariableString_t_p_get
-    if _newclass:p = property(_csnd.csCfgVariableString_t_p_get, _csnd.csCfgVariableString_t_p_set)
-    __swig_setmethods__["type"] = _csnd.csCfgVariableString_t_type_set
-    __swig_getmethods__["type"] = _csnd.csCfgVariableString_t_type_get
-    if _newclass:type = property(_csnd.csCfgVariableString_t_type_get, _csnd.csCfgVariableString_t_type_set)
-    __swig_setmethods__["flags"] = _csnd.csCfgVariableString_t_flags_set
-    __swig_getmethods__["flags"] = _csnd.csCfgVariableString_t_flags_get
-    if _newclass:flags = property(_csnd.csCfgVariableString_t_flags_get, _csnd.csCfgVariableString_t_flags_set)
-    __swig_setmethods__["shortDesc"] = _csnd.csCfgVariableString_t_shortDesc_set
-    __swig_getmethods__["shortDesc"] = _csnd.csCfgVariableString_t_shortDesc_get
-    if _newclass:shortDesc = property(_csnd.csCfgVariableString_t_shortDesc_get, _csnd.csCfgVariableString_t_shortDesc_set)
-    __swig_setmethods__["longDesc"] = _csnd.csCfgVariableString_t_longDesc_set
-    __swig_getmethods__["longDesc"] = _csnd.csCfgVariableString_t_longDesc_get
-    if _newclass:longDesc = property(_csnd.csCfgVariableString_t_longDesc_get, _csnd.csCfgVariableString_t_longDesc_set)
-    __swig_setmethods__["maxlen"] = _csnd.csCfgVariableString_t_maxlen_set
-    __swig_getmethods__["maxlen"] = _csnd.csCfgVariableString_t_maxlen_get
-    if _newclass:maxlen = property(_csnd.csCfgVariableString_t_maxlen_get, _csnd.csCfgVariableString_t_maxlen_set)
-    def __init__(self, *args): 
-        """__init__(self) -> csCfgVariableString_t"""
-        this = _csnd.new_csCfgVariableString_t(*args)
-        try: self.this.append(this)
-        except: self.this = this
-    __swig_destroy__ = _csnd.delete_csCfgVariableString_t
-    __del__ = lambda self : None;
-csCfgVariableString_t_swigregister = _csnd.csCfgVariableString_t_swigregister
-csCfgVariableString_t_swigregister(csCfgVariableString_t)
-
-class csCfgVariable_t(_object):
-    """Proxy of C++ csCfgVariable_t class"""
-    __swig_setmethods__ = {}
-    __setattr__ = lambda self, name, value: _swig_setattr(self, csCfgVariable_t, name, value)
-    __swig_getmethods__ = {}
-    __getattr__ = lambda self, name: _swig_getattr(self, csCfgVariable_t, name)
-    __repr__ = _swig_repr
-    __swig_setmethods__["h"] = _csnd.csCfgVariable_t_h_set
-    __swig_getmethods__["h"] = _csnd.csCfgVariable_t_h_get
-    if _newclass:h = property(_csnd.csCfgVariable_t_h_get, _csnd.csCfgVariable_t_h_set)
-    __swig_setmethods__["i"] = _csnd.csCfgVariable_t_i_set
-    __swig_getmethods__["i"] = _csnd.csCfgVariable_t_i_get
-    if _newclass:i = property(_csnd.csCfgVariable_t_i_get, _csnd.csCfgVariable_t_i_set)
-    __swig_setmethods__["b"] = _csnd.csCfgVariable_t_b_set
-    __swig_getmethods__["b"] = _csnd.csCfgVariable_t_b_get
-    if _newclass:b = property(_csnd.csCfgVariable_t_b_get, _csnd.csCfgVariable_t_b_set)
-    __swig_setmethods__["f"] = _csnd.csCfgVariable_t_f_set
-    __swig_getmethods__["f"] = _csnd.csCfgVariable_t_f_get
-    if _newclass:f = property(_csnd.csCfgVariable_t_f_get, _csnd.csCfgVariable_t_f_set)
-    __swig_setmethods__["d"] = _csnd.csCfgVariable_t_d_set
-    __swig_getmethods__["d"] = _csnd.csCfgVariable_t_d_get
-    if _newclass:d = property(_csnd.csCfgVariable_t_d_get, _csnd.csCfgVariable_t_d_set)
-    __swig_setmethods__["m"] = _csnd.csCfgVariable_t_m_set
-    __swig_getmethods__["m"] = _csnd.csCfgVariable_t_m_get
-    if _newclass:m = property(_csnd.csCfgVariable_t_m_get, _csnd.csCfgVariable_t_m_set)
-    __swig_setmethods__["s"] = _csnd.csCfgVariable_t_s_set
-    __swig_getmethods__["s"] = _csnd.csCfgVariable_t_s_get
-    if _newclass:s = property(_csnd.csCfgVariable_t_s_get, _csnd.csCfgVariable_t_s_set)
-    def __init__(self, *args): 
-        """__init__(self) -> csCfgVariable_t"""
-        this = _csnd.new_csCfgVariable_t(*args)
-        try: self.this.append(this)
-        except: self.this = this
-    __swig_destroy__ = _csnd.delete_csCfgVariable_t
-    __del__ = lambda self : None;
-csCfgVariable_t_swigregister = _csnd.csCfgVariable_t_swigregister
-csCfgVariable_t_swigregister(csCfgVariable_t)
-
-CSOUNDCFG_INTEGER = _csnd.CSOUNDCFG_INTEGER
-CSOUNDCFG_BOOLEAN = _csnd.CSOUNDCFG_BOOLEAN
-CSOUNDCFG_FLOAT = _csnd.CSOUNDCFG_FLOAT
-CSOUNDCFG_DOUBLE = _csnd.CSOUNDCFG_DOUBLE
-CSOUNDCFG_MYFLT = _csnd.CSOUNDCFG_MYFLT
-CSOUNDCFG_STRING = _csnd.CSOUNDCFG_STRING
-CSOUNDCFG_POWOFTWO = _csnd.CSOUNDCFG_POWOFTWO
-CSOUNDCFG_SUCCESS = _csnd.CSOUNDCFG_SUCCESS
-CSOUNDCFG_INVALID_NAME = _csnd.CSOUNDCFG_INVALID_NAME
-CSOUNDCFG_INVALID_TYPE = _csnd.CSOUNDCFG_INVALID_TYPE
-CSOUNDCFG_INVALID_FLAG = _csnd.CSOUNDCFG_INVALID_FLAG
-CSOUNDCFG_NULL_POINTER = _csnd.CSOUNDCFG_NULL_POINTER
-CSOUNDCFG_TOO_HIGH = _csnd.CSOUNDCFG_TOO_HIGH
-CSOUNDCFG_TOO_LOW = _csnd.CSOUNDCFG_TOO_LOW
-CSOUNDCFG_NOT_POWOFTWO = _csnd.CSOUNDCFG_NOT_POWOFTWO
-CSOUNDCFG_INVALID_BOOLEAN = _csnd.CSOUNDCFG_INVALID_BOOLEAN
-CSOUNDCFG_MEMORY = _csnd.CSOUNDCFG_MEMORY
-CSOUNDCFG_STRING_LENGTH = _csnd.CSOUNDCFG_STRING_LENGTH
-CSOUNDCFG_LASTERROR = _csnd.CSOUNDCFG_LASTERROR
-
-def csoundCreateConfigurationVariable(*args):
-  """
-    csoundCreateConfigurationVariable(CSOUND csound, char name, void p, int type, int flags, 
-        void min, void max, char shortDesc, char longDesc) -> int
-    """
-  return _csnd.csoundCreateConfigurationVariable(*args)
-
-def csoundSetConfigurationVariable(*args):
-  """csoundSetConfigurationVariable(CSOUND csound, char name, void value) -> int"""
-  return _csnd.csoundSetConfigurationVariable(*args)
-
-def csoundParseConfigurationVariable(*args):
-  """csoundParseConfigurationVariable(CSOUND csound, char name, char value) -> int"""
-  return _csnd.csoundParseConfigurationVariable(*args)
-
-def csoundQueryConfigurationVariable(*args):
-  """csoundQueryConfigurationVariable(CSOUND csound, char name)"""
-  return _csnd.csoundQueryConfigurationVariable(*args)
-
-def csoundListConfigurationVariables(*args):
-  """csoundListConfigurationVariables(CSOUND csound)"""
-  return _csnd.csoundListConfigurationVariables(*args)
-
-def csoundDeleteCfgVarList(*args):
-  """csoundDeleteCfgVarList( lst)"""
-  return _csnd.csoundDeleteCfgVarList(*args)
-
-def csoundDeleteConfigurationVariable(*args):
-  """csoundDeleteConfigurationVariable(CSOUND csound, char name) -> int"""
-  return _csnd.csoundDeleteConfigurationVariable(*args)
-
-def csoundCfgErrorCodeToString(*args):
-  """csoundCfgErrorCodeToString(int errcode) -> char"""
-  return _csnd.csoundCfgErrorCodeToString(*args)
-CSOUNDMSG_DEFAULT = _csnd.CSOUNDMSG_DEFAULT
-CSOUNDMSG_ERROR = _csnd.CSOUNDMSG_ERROR
-CSOUNDMSG_ORCH = _csnd.CSOUNDMSG_ORCH
-CSOUNDMSG_REALTIME = _csnd.CSOUNDMSG_REALTIME
-CSOUNDMSG_WARNING = _csnd.CSOUNDMSG_WARNING
-CSOUNDMSG_FG_BLACK = _csnd.CSOUNDMSG_FG_BLACK
-CSOUNDMSG_FG_RED = _csnd.CSOUNDMSG_FG_RED
-CSOUNDMSG_FG_GREEN = _csnd.CSOUNDMSG_FG_GREEN
-CSOUNDMSG_FG_YELLOW = _csnd.CSOUNDMSG_FG_YELLOW
-CSOUNDMSG_FG_BLUE = _csnd.CSOUNDMSG_FG_BLUE
-CSOUNDMSG_FG_MAGENTA = _csnd.CSOUNDMSG_FG_MAGENTA
-CSOUNDMSG_FG_CYAN = _csnd.CSOUNDMSG_FG_CYAN
-CSOUNDMSG_FG_WHITE = _csnd.CSOUNDMSG_FG_WHITE
-CSOUNDMSG_FG_BOLD = _csnd.CSOUNDMSG_FG_BOLD
-CSOUNDMSG_FG_UNDERLINE = _csnd.CSOUNDMSG_FG_UNDERLINE
-CSOUNDMSG_BG_BLACK = _csnd.CSOUNDMSG_BG_BLACK
-CSOUNDMSG_BG_RED = _csnd.CSOUNDMSG_BG_RED
-CSOUNDMSG_BG_GREEN = _csnd.CSOUNDMSG_BG_GREEN
-CSOUNDMSG_BG_ORANGE = _csnd.CSOUNDMSG_BG_ORANGE
-CSOUNDMSG_BG_BLUE = _csnd.CSOUNDMSG_BG_BLUE
-CSOUNDMSG_BG_MAGENTA = _csnd.CSOUNDMSG_BG_MAGENTA
-CSOUNDMSG_BG_CYAN = _csnd.CSOUNDMSG_BG_CYAN
-CSOUNDMSG_BG_GREY = _csnd.CSOUNDMSG_BG_GREY
-CSOUNDMSG_TYPE_MASK = _csnd.CSOUNDMSG_TYPE_MASK
-CSOUNDMSG_FG_COLOR_MASK = _csnd.CSOUNDMSG_FG_COLOR_MASK
-CSOUNDMSG_FG_ATTR_MASK = _csnd.CSOUNDMSG_FG_ATTR_MASK
-CSOUNDMSG_BG_COLOR_MASK = _csnd.CSOUNDMSG_BG_COLOR_MASK
-CS_PACKAGE_NAME = _csnd.CS_PACKAGE_NAME
-CS_PACKAGE_STRING = _csnd.CS_PACKAGE_STRING
-CS_PACKAGE_TARNAME = _csnd.CS_PACKAGE_TARNAME
-CS_PACKAGE_VERSION = _csnd.CS_PACKAGE_VERSION
-CS_VERSION = _csnd.CS_VERSION
-CS_SUBVER = _csnd.CS_SUBVER
-CS_PATCHLEVEL = _csnd.CS_PATCHLEVEL
-CS_APIVERSION = _csnd.CS_APIVERSION
-CS_APISUBVER = _csnd.CS_APISUBVER
-class Csound(_object):
-    """Proxy of C++ Csound class"""
-    __swig_setmethods__ = {}
-    __setattr__ = lambda self, name, value: _swig_setattr(self, Csound, name, value)
-    __swig_getmethods__ = {}
-    __getattr__ = lambda self, name: _swig_getattr(self, Csound, name)
-    __repr__ = _swig_repr
-    def GetCsound(*args):
-        """GetCsound(self) -> CSOUND"""
-        return _csnd.Csound_GetCsound(*args)
-
-    def PreCompile(*args):
-        """PreCompile(self) -> int"""
-        return _csnd.Csound_PreCompile(*args)
-
-    def InitializeCscore(*args):
-        """InitializeCscore(self, FILE insco, FILE outsco) -> int"""
-        return _csnd.Csound_InitializeCscore(*args)
-
-    def GetHostData(*args):
-        """GetHostData(self) -> void"""
-        return _csnd.Csound_GetHostData(*args)
-
-    def SetHostData(*args):
-        """SetHostData(self, void hostData)"""
-        return _csnd.Csound_SetHostData(*args)
-
-    def GetEnv(*args):
-        """GetEnv(self, char name) -> char"""
-        return _csnd.Csound_GetEnv(*args)
-
-    def Compile(*args):
-        """
-        Compile(self, int argc, char argv) -> int
-        Compile(self, char csdName) -> int
-        Compile(self, char orcName, char scoName) -> int
-        Compile(self, char arg1, char arg2, char arg3) -> int
-        Compile(self, char arg1, char arg2, char arg3, char arg4) -> int
-        Compile(self, char arg1, char arg2, char arg3, char arg4, char arg5) -> int
-        """
-        return _csnd.Csound_Compile(*args)
-
-    def Perform(*args):
-        """
-        Perform(self) -> int
-        Perform(self, int argc, char argv) -> int
-        Perform(self, char csdName) -> int
-        Perform(self, char orcName, char scoName) -> int
-        Perform(self, char arg1, char arg2, char arg3) -> int
-        Perform(self, char arg1, char arg2, char arg3, char arg4) -> int
-        Perform(self, char arg1, char arg2, char arg3, char arg4, char arg5) -> int
-        """
-        return _csnd.Csound_Perform(*args)
-
-    def PerformKsmps(*args):
-        """PerformKsmps(self) -> int"""
-        return _csnd.Csound_PerformKsmps(*args)
-
-    def PerformKsmpsAbsolute(*args):
-        """PerformKsmpsAbsolute(self) -> int"""
-        return _csnd.Csound_PerformKsmpsAbsolute(*args)
-
-    def PerformBuffer(*args):
-        """PerformBuffer(self) -> int"""
-        return _csnd.Csound_PerformBuffer(*args)
-
-    def Stop(*args):
-        """Stop(self)"""
-        return _csnd.Csound_Stop(*args)
-
-    def Cleanup(*args):
-        """Cleanup(self) -> int"""
-        return _csnd.Csound_Cleanup(*args)
-
-    def Reset(*args):
-        """Reset(self)"""
-        return _csnd.Csound_Reset(*args)
-
-    def GetSr(*args):
-        """GetSr(self) -> float"""
-        return _csnd.Csound_GetSr(*args)
-
-    def GetKr(*args):
-        """GetKr(self) -> float"""
-        return _csnd.Csound_GetKr(*args)
-
-    def GetKsmps(*args):
-        """GetKsmps(self) -> int"""
-        return _csnd.Csound_GetKsmps(*args)
-
-    def GetNchnls(*args):
-        """GetNchnls(self) -> int"""
-        return _csnd.Csound_GetNchnls(*args)
-
-    def Get0dBFS(*args):
-        """Get0dBFS(self) -> float"""
-        return _csnd.Csound_Get0dBFS(*args)
-
-    def GetStrVarMaxLen(*args):
-        """GetStrVarMaxLen(self) -> int"""
-        return _csnd.Csound_GetStrVarMaxLen(*args)
-
-    def GetSampleFormat(*args):
-        """GetSampleFormat(self) -> int"""
-        return _csnd.Csound_GetSampleFormat(*args)
-
-    def GetSampleSize(*args):
-        """GetSampleSize(self) -> int"""
-        return _csnd.Csound_GetSampleSize(*args)
-
-    def GetInputBufferSize(*args):
-        """GetInputBufferSize(self) -> long"""
-        return _csnd.Csound_GetInputBufferSize(*args)
-
-    def GetOutputBufferSize(*args):
-        """GetOutputBufferSize(self) -> long"""
-        return _csnd.Csound_GetOutputBufferSize(*args)
-
-    def GetInputBuffer(*args):
-        """GetInputBuffer(self) -> float"""
-        return _csnd.Csound_GetInputBuffer(*args)
-
-    def GetOutputBuffer(*args):
-        """GetOutputBuffer(self) -> float"""
-        return _csnd.Csound_GetOutputBuffer(*args)
-
-    def GetSpin(*args):
-        """GetSpin(self) -> float"""
-        return _csnd.Csound_GetSpin(*args)
-
-    def GetSpout(*args):
-        """GetSpout(self) -> float"""
-        return _csnd.Csound_GetSpout(*args)
-
-    def GetOutputFileName(*args):
-        """GetOutputFileName(self) -> char"""
-        return _csnd.Csound_GetOutputFileName(*args)
-
-    def SetHostImplementedAudioIO(*args):
-        """SetHostImplementedAudioIO(self, int state, int bufSize)"""
-        return _csnd.Csound_SetHostImplementedAudioIO(*args)
-
-    def GetScoreTime(*args):
-        """GetScoreTime(self) -> double"""
-        return _csnd.Csound_GetScoreTime(*args)
-
-    def IsScorePending(*args):
-        """IsScorePending(self) -> int"""
-        return _csnd.Csound_IsScorePending(*args)
-
-    def SetScorePending(*args):
-        """SetScorePending(self, int pending)"""
-        return _csnd.Csound_SetScorePending(*args)
-
-    def GetScoreOffsetSeconds(*args):
-        """GetScoreOffsetSeconds(self) -> float"""
-        return _csnd.Csound_GetScoreOffsetSeconds(*args)
-
-    def SetScoreOffsetSeconds(*args):
-        """SetScoreOffsetSeconds(self, double time)"""
-        return _csnd.Csound_SetScoreOffsetSeconds(*args)
-
-    def RewindScore(*args):
-        """RewindScore(self)"""
-        return _csnd.Csound_RewindScore(*args)
-
-    def ScoreSort(*args):
-        """ScoreSort(self, FILE inFile, FILE outFile) -> int"""
-        return _csnd.Csound_ScoreSort(*args)
-
-    def ScoreExtract(*args):
-        """ScoreExtract(self, FILE inFile, FILE outFile, FILE extractFile) -> int"""
-        return _csnd.Csound_ScoreExtract(*args)
-
-    def Message(*args):
-        """Message(self, char format, v(...) ?)"""
-        return _csnd.Csound_Message(*args)
-
-    def MessageS(*args):
-        """MessageS(self, int attr, char format, v(...) ?)"""
-        return _csnd.Csound_MessageS(*args)
-
-    def GetMessageLevel(*args):
-        """GetMessageLevel(self) -> int"""
-        return _csnd.Csound_GetMessageLevel(*args)
-
-    def SetMessageLevel(*args):
-        """SetMessageLevel(self, int messageLevel)"""
-        return _csnd.Csound_SetMessageLevel(*args)
-
-    def InputMessage(*args):
-        """InputMessage(self, char message)"""
-        return _csnd.Csound_InputMessage(*args)
-
-    def KeyPress(*args):
-        """KeyPress(self, char c)"""
-        return _csnd.Csound_KeyPress(*args)
-
-    def ScoreEvent(*args):
-        """ScoreEvent(self, char type, float pFields, long numFields) -> int"""
-        return _csnd.Csound_ScoreEvent(*args)
-
-    def NewOpcodeList(*args):
-        """NewOpcodeList(self, opcodeListEntry opcodelist) -> int"""
-        return _csnd.Csound_NewOpcodeList(*args)
-
-    def DisposeOpcodeList(*args):
-        """DisposeOpcodeList(self, opcodeListEntry opcodelist)"""
-        return _csnd.Csound_DisposeOpcodeList(*args)
-
-    def AppendOpcode(*args):
-        """
-        AppendOpcode(self, char opname, int dsblksiz, int thread, char outypes, 
-            char intypes, int iopadr, int kopadr, int aopadr) -> int
-        """
-        return _csnd.Csound_AppendOpcode(*args)
-
-    def GetDebug(*args):
-        """GetDebug(self) -> int"""
-        return _csnd.Csound_GetDebug(*args)
-
-    def SetDebug(*args):
-        """SetDebug(self, int debug)"""
-        return _csnd.Csound_SetDebug(*args)
-
-    def TableLength(*args):
-        """TableLength(self, int table) -> int"""
-        return _csnd.Csound_TableLength(*args)
-
-    def TableGet(*args):
-        """TableGet(self, int table, int index) -> float"""
-        return _csnd.Csound_TableGet(*args)
-
-    def TableSet(*args):
-        """TableSet(self, int table, int index, double value)"""
-        return _csnd.Csound_TableSet(*args)
-
-    def GetTable(*args):
-        """GetTable(self, float tablePtr, int tableNum) -> int"""
-        return _csnd.Csound_GetTable(*args)
-
-    def CreateGlobalVariable(*args):
-        """CreateGlobalVariable(self, char name, size_t nbytes) -> int"""
-        return _csnd.Csound_CreateGlobalVariable(*args)
-
-    def QueryGlobalVariable(*args):
-        """QueryGlobalVariable(self, char name) -> void"""
-        return _csnd.Csound_QueryGlobalVariable(*args)
-
-    def QueryGlobalVariableNoCheck(*args):
-        """QueryGlobalVariableNoCheck(self, char name) -> void"""
-        return _csnd.Csound_QueryGlobalVariableNoCheck(*args)
-
-    def DestroyGlobalVariable(*args):
-        """DestroyGlobalVariable(self, char name) -> int"""
-        return _csnd.Csound_DestroyGlobalVariable(*args)
-
-    def GetRtRecordUserData(*args):
-        """GetRtRecordUserData(self) -> void"""
-        return _csnd.Csound_GetRtRecordUserData(*args)
-
-    def GetRtPlayUserData(*args):
-        """GetRtPlayUserData(self) -> void"""
-        return _csnd.Csound_GetRtPlayUserData(*args)
-
-    def RunUtility(*args):
-        """RunUtility(self, char name, int argc, char argv) -> int"""
-        return _csnd.Csound_RunUtility(*args)
-
-    def ListUtilities(*args):
-        """ListUtilities(self) -> char"""
-        return _csnd.Csound_ListUtilities(*args)
-
-    def DeleteUtilityList(*args):
-        """DeleteUtilityList(self, char lst)"""
-        return _csnd.Csound_DeleteUtilityList(*args)
-
-    def GetUtilityDescription(*args):
-        """GetUtilityDescription(self, char utilName) -> char"""
-        return _csnd.Csound_GetUtilityDescription(*args)
-
-    def GetChannelPtr(*args):
-        """GetChannelPtr(self, float p, char name, int type) -> int"""
-        return _csnd.Csound_GetChannelPtr(*args)
-
-    def ListChannels(*args):
-        """ListChannels(self,  lst) -> int"""
-        return _csnd.Csound_ListChannels(*args)
-
-    def DeleteChannelList(*args):
-        """DeleteChannelList(self,  lst)"""
-        return _csnd.Csound_DeleteChannelList(*args)
-
-    def SetControlChannelParams(*args):
-        """SetControlChannelParams(self, char name, int type, double dflt, double min, double max) -> int"""
-        return _csnd.Csound_SetControlChannelParams(*args)
-
-    def GetControlChannelParams(*args):
-        """GetControlChannelParams(self, char name, float dflt, float min, float max) -> int"""
-        return _csnd.Csound_GetControlChannelParams(*args)
-
-    def SetChannel(*args):
-        """
-        SetChannel(self, char name, double value)
-        SetChannel(self, char name, char value)
-        """
-        return _csnd.Csound_SetChannel(*args)
-
-    def GetChannel(*args):
-        """GetChannel(self, char name) -> float"""
-        return _csnd.Csound_GetChannel(*args)
-
-    def ChanIKSet(*args):
-        """ChanIKSet(self, double value, int n) -> int"""
-        return _csnd.Csound_ChanIKSet(*args)
-
-    def ChanOKGet(*args):
-        """ChanOKGet(self, float value, int n) -> int"""
-        return _csnd.Csound_ChanOKGet(*args)
-
-    def ChanIASet(*args):
-        """ChanIASet(self, float value, int n) -> int"""
-        return _csnd.Csound_ChanIASet(*args)
-
-    def ChanOAGet(*args):
-        """ChanOAGet(self, float value, int n) -> int"""
-        return _csnd.Csound_ChanOAGet(*args)
-
-    def PvsBusInit(*args):
-        """
-        PvsBusInit(self, int N=1024, int olaps=256, int wsize=256, int wtype=1, 
-            int format=0)
-        PvsBusInit(self, int N=1024, int olaps=256, int wsize=256, int wtype=1)
-        PvsBusInit(self, int N=1024, int olaps=256, int wsize=256)
-        PvsBusInit(self, int N=1024, int olaps=256)
-        PvsBusInit(self, int N=1024)
-        PvsBusInit(self)
-        """
-        return _csnd.Csound_PvsBusInit(*args)
-
-    def PvsBusDestroy(*args):
-        """PvsBusDestroy(self)"""
-        return _csnd.Csound_PvsBusDestroy(*args)
-
-    def PvsinSet(*args):
-        """
-        PvsinSet(self, float val, int k, int n)
-        PvsinSet(self,  value, int n) -> int
-        """
-        return _csnd.Csound_PvsinSet(*args)
-
-    def PvsoutGet(*args):
-        """
-        PvsoutGet(self, int k, int n) -> float
-        PvsoutGet(self,  value, int n) -> int
-        """
-        return _csnd.Csound_PvsoutGet(*args)
-
-    def CreateConfigurationVariable(*args):
-        """
-        CreateConfigurationVariable(self, char name, void p, int type, int flags, void min, void max, 
-            char shortDesc, char longDesc) -> int
-        """
-        return _csnd.Csound_CreateConfigurationVariable(*args)
-
-    def SetConfigurationVariable(*args):
-        """SetConfigurationVariable(self, char name, void value) -> int"""
-        return _csnd.Csound_SetConfigurationVariable(*args)
-
-    def ParseConfigurationVariable(*args):
-        """ParseConfigurationVariable(self, char name, char value) -> int"""
-        return _csnd.Csound_ParseConfigurationVariable(*args)
-
-    def QueryConfigurationVariable(*args):
-        """QueryConfigurationVariable(self, char name)"""
-        return _csnd.Csound_QueryConfigurationVariable(*args)
-
-    def ListConfigurationVariables(*args):
-        """ListConfigurationVariables(self)"""
-        return _csnd.Csound_ListConfigurationVariables(*args)
-
-    def DeleteConfigurationVariable(*args):
-        """DeleteConfigurationVariable(self, char name) -> int"""
-        return _csnd.Csound_DeleteConfigurationVariable(*args)
-
-    def SetChannelIOCallback(*args):
-        """SetChannelIOCallback(self, CsoundChannelIOCallback_t func)"""
-        return _csnd.Csound_SetChannelIOCallback(*args)
-
-    def __init__(self, *args): 
-        """
-        __init__(self) -> Csound
-        __init__(self, void hostData) -> Csound
-        """
-        this = _csnd.new_Csound(*args)
-        try: self.this.append(this)
-        except: self.this = this
-    __swig_destroy__ = _csnd.delete_Csound
-    __del__ = lambda self : None;
-    def EnableMessageBuffer(*args):
-        """EnableMessageBuffer(self, int toStdOut)"""
-        return _csnd.Csound_EnableMessageBuffer(*args)
-
-    def GetFirstMessage(*args):
-        """GetFirstMessage(self) -> char"""
-        return _csnd.Csound_GetFirstMessage(*args)
-
-    def GetFirstMessageAttr(*args):
-        """GetFirstMessageAttr(self) -> int"""
-        return _csnd.Csound_GetFirstMessageAttr(*args)
-
-    def PopFirstMessage(*args):
-        """PopFirstMessage(self)"""
-        return _csnd.Csound_PopFirstMessage(*args)
-
-    def GetMessageCnt(*args):
-        """GetMessageCnt(self) -> int"""
-        return _csnd.Csound_GetMessageCnt(*args)
-
-    def DestroyMessageBuffer(*args):
-        """DestroyMessageBuffer(self)"""
-        return _csnd.Csound_DestroyMessageBuffer(*args)
-
-Csound_swigregister = _csnd.Csound_swigregister
-Csound_swigregister(Csound)
-
-class CsoundThreadLock(_object):
-    """Proxy of C++ CsoundThreadLock class"""
-    __swig_setmethods__ = {}
-    __setattr__ = lambda self, name, value: _swig_setattr(self, CsoundThreadLock, name, value)
-    __swig_getmethods__ = {}
-    __getattr__ = lambda self, name: _swig_getattr(self, CsoundThreadLock, name)
-    __repr__ = _swig_repr
-    def Lock(*args):
-        """
-        Lock(self, size_t milliseconds) -> int
-        Lock(self)
-        """
-        return _csnd.CsoundThreadLock_Lock(*args)
-
-    def TryLock(*args):
-        """TryLock(self) -> int"""
-        return _csnd.CsoundThreadLock_TryLock(*args)
-
-    def Unlock(*args):
-        """Unlock(self)"""
-        return _csnd.CsoundThreadLock_Unlock(*args)
-
-    def __init__(self, *args): 
-        """
-        __init__(self) -> CsoundThreadLock
-        __init__(self, int locked) -> CsoundThreadLock
-        """
-        this = _csnd.new_CsoundThreadLock(*args)
-        try: self.this.append(this)
-        except: self.this = this
-    __swig_destroy__ = _csnd.delete_CsoundThreadLock
-    __del__ = lambda self : None;
-CsoundThreadLock_swigregister = _csnd.CsoundThreadLock_swigregister
-CsoundThreadLock_swigregister(CsoundThreadLock)
-
-class CsoundMutex(_object):
-    """Proxy of C++ CsoundMutex class"""
-    __swig_setmethods__ = {}
-    __setattr__ = lambda self, name, value: _swig_setattr(self, CsoundMutex, name, value)
-    __swig_getmethods__ = {}
-    __getattr__ = lambda self, name: _swig_getattr(self, CsoundMutex, name)
-    __repr__ = _swig_repr
-    def Lock(*args):
-        """Lock(self)"""
-        return _csnd.CsoundMutex_Lock(*args)
-
-    def TryLock(*args):
-        """TryLock(self) -> int"""
-        return _csnd.CsoundMutex_TryLock(*args)
-
-    def Unlock(*args):
-        """Unlock(self)"""
-        return _csnd.CsoundMutex_Unlock(*args)
-
-    def __init__(self, *args): 
-        """
-        __init__(self) -> CsoundMutex
-        __init__(self, int isRecursive) -> CsoundMutex
-        """
-        this = _csnd.new_CsoundMutex(*args)
-        try: self.this.append(this)
-        except: self.this = this
-    __swig_destroy__ = _csnd.delete_CsoundMutex
-    __del__ = lambda self : None;
-CsoundMutex_swigregister = _csnd.CsoundMutex_swigregister
-CsoundMutex_swigregister(CsoundMutex)
-
-class CsoundRandMT(_object):
-    """Proxy of C++ CsoundRandMT class"""
-    __swig_setmethods__ = {}
-    __setattr__ = lambda self, name, value: _swig_setattr(self, CsoundRandMT, name, value)
-    __swig_getmethods__ = {}
-    __getattr__ = lambda self, name: _swig_getattr(self, CsoundRandMT, name)
-    __repr__ = _swig_repr
-    def Random(*args):
-        """Random(self) -> uint32_t"""
-        return _csnd.CsoundRandMT_Random(*args)
-
-    def Seed(*args):
-        """
-        Seed(self, uint32_t seedVal)
-        Seed(self, uint32_t initKey, int keyLength)
-        """
-        return _csnd.CsoundRandMT_Seed(*args)
-
-    def __init__(self, *args): 
-        """
-        __init__(self) -> CsoundRandMT
-        __init__(self, uint32_t seedVal) -> CsoundRandMT
-        __init__(self, uint32_t initKey, int keyLength) -> CsoundRandMT
-        """
-        this = _csnd.new_CsoundRandMT(*args)
-        try: self.this.append(this)
-        except: self.this = this
-    __swig_destroy__ = _csnd.delete_CsoundRandMT
-    __del__ = lambda self : None;
-CsoundRandMT_swigregister = _csnd.CsoundRandMT_swigregister
-CsoundRandMT_swigregister(CsoundRandMT)
-
-class CsoundTimer(_object):
-    """Proxy of C++ CsoundTimer class"""
-    __swig_setmethods__ = {}
-    __setattr__ = lambda self, name, value: _swig_setattr(self, CsoundTimer, name, value)
-    __swig_getmethods__ = {}
-    __getattr__ = lambda self, name: _swig_getattr(self, CsoundTimer, name)
-    __repr__ = _swig_repr
-    def GetRealTime(*args):
-        """GetRealTime(self) -> double"""
-        return _csnd.CsoundTimer_GetRealTime(*args)
-
-    def GetCPUTime(*args):
-        """GetCPUTime(self) -> double"""
-        return _csnd.CsoundTimer_GetCPUTime(*args)
-
-    def Reset(*args):
-        """Reset(self)"""
-        return _csnd.CsoundTimer_Reset(*args)
-
-    def __init__(self, *args): 
-        """__init__(self) -> CsoundTimer"""
-        this = _csnd.new_CsoundTimer(*args)
-        try: self.this.append(this)
-        except: self.this = this
-    __swig_destroy__ = _csnd.delete_CsoundTimer
-    __del__ = lambda self : None;
-CsoundTimer_swigregister = _csnd.CsoundTimer_swigregister
-CsoundTimer_swigregister(CsoundTimer)
-
-class CsoundOpcodeList(_object):
-    """Proxy of C++ CsoundOpcodeList class"""
-    __swig_setmethods__ = {}
-    __setattr__ = lambda self, name, value: _swig_setattr(self, CsoundOpcodeList, name, value)
-    __swig_getmethods__ = {}
-    __getattr__ = lambda self, name: _swig_getattr(self, CsoundOpcodeList, name)
-    __repr__ = _swig_repr
-    def Count(*args):
-        """Count(self) -> int"""
-        return _csnd.CsoundOpcodeList_Count(*args)
-
-    def Name(*args):
-        """Name(self, int ndx) -> char"""
-        return _csnd.CsoundOpcodeList_Name(*args)
-
-    def OutTypes(*args):
-        """OutTypes(self, int ndx) -> char"""
-        return _csnd.CsoundOpcodeList_OutTypes(*args)
-
-    def InTypes(*args):
-        """InTypes(self, int ndx) -> char"""
-        return _csnd.CsoundOpcodeList_InTypes(*args)
-
-    def Clear(*args):
-        """Clear(self)"""
-        return _csnd.CsoundOpcodeList_Clear(*args)
-
-    def __init__(self, *args): 
-        """
-        __init__(self, CSOUND csound) -> CsoundOpcodeList
-        __init__(self, Csound csound) -> CsoundOpcodeList
-        """
-        this = _csnd.new_CsoundOpcodeList(*args)
-        try: self.this.append(this)
-        except: self.this = this
-    __swig_destroy__ = _csnd.delete_CsoundOpcodeList
-    __del__ = lambda self : None;
-CsoundOpcodeList_swigregister = _csnd.CsoundOpcodeList_swigregister
-CsoundOpcodeList_swigregister(CsoundOpcodeList)
-
-class CsoundChannelList(_object):
-    """Proxy of C++ CsoundChannelList class"""
-    __swig_setmethods__ = {}
-    __setattr__ = lambda self, name, value: _swig_setattr(self, CsoundChannelList, name, value)
-    __swig_getmethods__ = {}
-    __getattr__ = lambda self, name: _swig_getattr(self, CsoundChannelList, name)
-    __repr__ = _swig_repr
-    def Count(*args):
-        """Count(self) -> int"""
-        return _csnd.CsoundChannelList_Count(*args)
-
-    def Name(*args):
-        """Name(self, int ndx) -> char"""
-        return _csnd.CsoundChannelList_Name(*args)
-
-    def Type(*args):
-        """Type(self, int ndx) -> int"""
-        return _csnd.CsoundChannelList_Type(*args)
-
-    def IsControlChannel(*args):
-        """IsControlChannel(self, int ndx) -> int"""
-        return _csnd.CsoundChannelList_IsControlChannel(*args)
-
-    def IsAudioChannel(*args):
-        """IsAudioChannel(self, int ndx) -> int"""
-        return _csnd.CsoundChannelList_IsAudioChannel(*args)
-
-    def IsStringChannel(*args):
-        """IsStringChannel(self, int ndx) -> int"""
-        return _csnd.CsoundChannelList_IsStringChannel(*args)
-
-    def IsInputChannel(*args):
-        """IsInputChannel(self, int ndx) -> int"""
-        return _csnd.CsoundChannelList_IsInputChannel(*args)
-
-    def IsOutputChannel(*args):
-        """IsOutputChannel(self, int ndx) -> int"""
-        return _csnd.CsoundChannelList_IsOutputChannel(*args)
-
-    def SubType(*args):
-        """SubType(self, int ndx) -> int"""
-        return _csnd.CsoundChannelList_SubType(*args)
-
-    def DefaultValue(*args):
-        """DefaultValue(self, int ndx) -> double"""
-        return _csnd.CsoundChannelList_DefaultValue(*args)
-
-    def MinValue(*args):
-        """MinValue(self, int ndx) -> double"""
-        return _csnd.CsoundChannelList_MinValue(*args)
-
-    def MaxValue(*args):
-        """MaxValue(self, int ndx) -> double"""
-        return _csnd.CsoundChannelList_MaxValue(*args)
-
-    def Clear(*args):
-        """Clear(self)"""
-        return _csnd.CsoundChannelList_Clear(*args)
-
-    def __init__(self, *args): 
-        """
-        __init__(self, CSOUND csound) -> CsoundChannelList
-        __init__(self, Csound csound) -> CsoundChannelList
-        """
-        this = _csnd.new_CsoundChannelList(*args)
-        try: self.this.append(this)
-        except: self.this = this
-    __swig_destroy__ = _csnd.delete_CsoundChannelList
-    __del__ = lambda self : None;
-CsoundChannelList_swigregister = _csnd.CsoundChannelList_swigregister
-CsoundChannelList_swigregister(CsoundChannelList)
-
-class CsoundUtilityList(_object):
-    """Proxy of C++ CsoundUtilityList class"""
-    __swig_setmethods__ = {}
-    __setattr__ = lambda self, name, value: _swig_setattr(self, CsoundUtilityList, name, value)
-    __swig_getmethods__ = {}
-    __getattr__ = lambda self, name: _swig_getattr(self, CsoundUtilityList, name)
-    __repr__ = _swig_repr
-    def Count(*args):
-        """Count(self) -> int"""
-        return _csnd.CsoundUtilityList_Count(*args)
-
-    def Name(*args):
-        """Name(self, int ndx) -> char"""
-        return _csnd.CsoundUtilityList_Name(*args)
-
-    def Clear(*args):
-        """Clear(self)"""
-        return _csnd.CsoundUtilityList_Clear(*args)
-
-    def __init__(self, *args): 
-        """
-        __init__(self, CSOUND csound) -> CsoundUtilityList
-        __init__(self, Csound csound) -> CsoundUtilityList
-        """
-        this = _csnd.new_CsoundUtilityList(*args)
-        try: self.this.append(this)
-        except: self.this = this
-    __swig_destroy__ = _csnd.delete_CsoundUtilityList
-    __del__ = lambda self : None;
-CsoundUtilityList_swigregister = _csnd.CsoundUtilityList_swigregister
-CsoundUtilityList_swigregister(CsoundUtilityList)
-
-class CsoundMYFLTArray(_object):
-    """Proxy of C++ CsoundMYFLTArray class"""
-    __swig_setmethods__ = {}
-    __setattr__ = lambda self, name, value: _swig_setattr(self, CsoundMYFLTArray, name, value)
-    __swig_getmethods__ = {}
-    __getattr__ = lambda self, name: _swig_getattr(self, CsoundMYFLTArray, name)
-    __repr__ = _swig_repr
-    def GetPtr(*args):
-        """
-        GetPtr(self) -> float
-        GetPtr(self, int ndx) -> float
-        """
-        return _csnd.CsoundMYFLTArray_GetPtr(*args)
-
-    def SetPtr(*args):
-        """SetPtr(self, float ptr)"""
-        return _csnd.CsoundMYFLTArray_SetPtr(*args)
-
-    def SetValue(*args):
-        """SetValue(self, int ndx, double value)"""
-        return _csnd.CsoundMYFLTArray_SetValue(*args)
-
-    def GetValue(*args):
-        """GetValue(self, int ndx) -> double"""
-        return _csnd.CsoundMYFLTArray_GetValue(*args)
-
-    def SetValues(*args):
-        """
-        SetValues(self, int ndx, double v0, double v1)
-        SetValues(self, int ndx, double v0, double v1, double v2)
-        SetValues(self, int ndx, double v0, double v1, double v2, double v3)
-        SetValues(self, int ndx, double v0, double v1, double v2, double v3, 
-            double v4)
-        SetValues(self, int ndx, double v0, double v1, double v2, double v3, 
-            double v4, double v5)
-        SetValues(self, int ndx, double v0, double v1, double v2, double v3, 
-            double v4, double v5, double v6)
-        SetValues(self, int ndx, double v0, double v1, double v2, double v3, 
-            double v4, double v5, double v6, double v7)
-        SetValues(self, int ndx, double v0, double v1, double v2, double v3, 
-            double v4, double v5, double v6, double v7, 
-            double v8)
-        SetValues(self, int ndx, double v0, double v1, double v2, double v3, 
-            double v4, double v5, double v6, double v7, 
-            double v8, double v9)
-        SetValues(self, int ndx, int n, float src)
-        """
-        return _csnd.CsoundMYFLTArray_SetValues(*args)
-
-    def GetValues(*args):
-        """GetValues(self, float dst, int ndx, int n)"""
-        return _csnd.CsoundMYFLTArray_GetValues(*args)
-
-    def SetStringValue(*args):
-        """SetStringValue(self, char s, int maxLen)"""
-        return _csnd.CsoundMYFLTArray_SetStringValue(*args)
-
-    def GetStringValue(*args):
-        """GetStringValue(self) -> char"""
-        return _csnd.CsoundMYFLTArray_GetStringValue(*args)
-
-    def Clear(*args):
-        """Clear(self)"""
-        return _csnd.CsoundMYFLTArray_Clear(*args)
-
-    def __init__(self, *args): 
-        """
-        __init__(self) -> CsoundMYFLTArray
-        __init__(self, int n) -> CsoundMYFLTArray
-        """
-        this = _csnd.new_CsoundMYFLTArray(*args)
-        try: self.this.append(this)
-        except: self.this = this
-    __swig_destroy__ = _csnd.delete_CsoundMYFLTArray
-    __del__ = lambda self : None;
-CsoundMYFLTArray_swigregister = _csnd.CsoundMYFLTArray_swigregister
-CsoundMYFLTArray_swigregister(CsoundMYFLTArray)
-
-class CsoundArgVList(_object):
-    """Proxy of C++ CsoundArgVList class"""
-    __swig_setmethods__ = {}
-    __setattr__ = lambda self, name, value: _swig_setattr(self, CsoundArgVList, name, value)
-    __swig_getmethods__ = {}
-    __getattr__ = lambda self, name: _swig_getattr(self, CsoundArgVList, name)
-    __repr__ = _swig_repr
-    def argc(*args):
-        """argc(self) -> int"""
-        return _csnd.CsoundArgVList_argc(*args)
-
-    def argv(*args):
-        """
-        argv(self) -> char
-        argv(self, int ndx) -> char
-        """
-        return _csnd.CsoundArgVList_argv(*args)
-
-    def Insert(*args):
-        """Insert(self, int ndx, char s)"""
-        return _csnd.CsoundArgVList_Insert(*args)
-
-    def Append(*args):
-        """Append(self, char s)"""
-        return _csnd.CsoundArgVList_Append(*args)
-
-    def Clear(*args):
-        """Clear(self)"""
-        return _csnd.CsoundArgVList_Clear(*args)
-
-    def __init__(self, *args): 
-        """__init__(self) -> CsoundArgVList"""
-        this = _csnd.new_CsoundArgVList(*args)
-        try: self.this.append(this)
-        except: self.this = this
-    __swig_destroy__ = _csnd.delete_CsoundArgVList
-    __del__ = lambda self : None;
-CsoundArgVList_swigregister = _csnd.CsoundArgVList_swigregister
-CsoundArgVList_swigregister(CsoundArgVList)
-
-class CsoundCallbackWrapper(_object):
-    """Proxy of C++ CsoundCallbackWrapper class"""
-    __swig_setmethods__ = {}
-    __setattr__ = lambda self, name, value: _swig_setattr(self, CsoundCallbackWrapper, name, value)
-    __swig_getmethods__ = {}
-    __getattr__ = lambda self, name: _swig_getattr(self, CsoundCallbackWrapper, name)
-    __repr__ = _swig_repr
-    def MessageCallback(*args):
-        """MessageCallback(self, int attr, char msg)"""
-        return _csnd.CsoundCallbackWrapper_MessageCallback(*args)
-
-    def InputValueCallback(*args):
-        """InputValueCallback(self, char chnName) -> double"""
-        return _csnd.CsoundCallbackWrapper_InputValueCallback(*args)
-
-    def OutputValueCallback(*args):
-        """OutputValueCallback(self, char chnName, double value)"""
-        return _csnd.CsoundCallbackWrapper_OutputValueCallback(*args)
-
-    def YieldCallback(*args):
-        """YieldCallback(self) -> int"""
-        return _csnd.CsoundCallbackWrapper_YieldCallback(*args)
-
-    def MidiInputCallback(*args):
-        """MidiInputCallback(self, CsoundMidiInputBuffer p)"""
-        return _csnd.CsoundCallbackWrapper_MidiInputCallback(*args)
-
-    def MidiOutputCallback(*args):
-        """MidiOutputCallback(self, CsoundMidiOutputBuffer p)"""
-        return _csnd.CsoundCallbackWrapper_MidiOutputCallback(*args)
-
-    def ControlChannelInputCallback(*args):
-        """ControlChannelInputCallback(self, char chnName) -> double"""
-        return _csnd.CsoundCallbackWrapper_ControlChannelInputCallback(*args)
-
-    def ControlChannelOutputCallback(*args):
-        """ControlChannelOutputCallback(self, char chnName, double value)"""
-        return _csnd.CsoundCallbackWrapper_ControlChannelOutputCallback(*args)
-
-    def StringChannelInputCallback(*args):
-        """StringChannelInputCallback(self, char chnName) -> char"""
-        return _csnd.CsoundCallbackWrapper_StringChannelInputCallback(*args)
-
-    def StringChannelOutputCallback(*args):
-        """StringChannelOutputCallback(self, char chnName, char value)"""
-        return _csnd.CsoundCallbackWrapper_StringChannelOutputCallback(*args)
-
-    def SetMessageCallback(*args):
-        """SetMessageCallback(self)"""
-        return _csnd.CsoundCallbackWrapper_SetMessageCallback(*args)
-
-    def SetInputValueCallback(*args):
-        """SetInputValueCallback(self)"""
-        return _csnd.CsoundCallbackWrapper_SetInputValueCallback(*args)
-
-    def SetOutputValueCallback(*args):
-        """SetOutputValueCallback(self)"""
-        return _csnd.CsoundCallbackWrapper_SetOutputValueCallback(*args)
-
-    def SetYieldCallback(*args):
-        """SetYieldCallback(self)"""
-        return _csnd.CsoundCallbackWrapper_SetYieldCallback(*args)
-
-    def SetMidiInputCallback(*args):
-        """SetMidiInputCallback(self, CsoundArgVList argv)"""
-        return _csnd.CsoundCallbackWrapper_SetMidiInputCallback(*args)
-
-    def SetMidiOutputCallback(*args):
-        """SetMidiOutputCallback(self, CsoundArgVList argv)"""
-        return _csnd.CsoundCallbackWrapper_SetMidiOutputCallback(*args)
-
-    def SetChannelIOCallbacks(*args):
-        """SetChannelIOCallbacks(self)"""
-        return _csnd.CsoundCallbackWrapper_SetChannelIOCallbacks(*args)
-
-    def GetCsound(*args):
-        """GetCsound(self) -> CSOUND"""
-        return _csnd.CsoundCallbackWrapper_GetCsound(*args)
-
-    def CharPtrToString(*args):
-        """CharPtrToString(char s) -> char"""
-        return _csnd.CsoundCallbackWrapper_CharPtrToString(*args)
-
-    if _newclass:CharPtrToString = staticmethod(CharPtrToString)
-    __swig_getmethods__["CharPtrToString"] = lambda x: CharPtrToString
-    def __init__(self, *args): 
-        """
-        __init__(self, Csound csound) -> CsoundCallbackWrapper
-        __init__(self, CSOUND csound) -> CsoundCallbackWrapper
-        """
-        if self.__class__ == CsoundCallbackWrapper:
-            args = (None,) + args
-        else:
-            args = (self,) + args
-        this = _csnd.new_CsoundCallbackWrapper(*args)
-        try: self.this.append(this)
-        except: self.this = this
-    __swig_destroy__ = _csnd.delete_CsoundCallbackWrapper
-    __del__ = lambda self : None;
-    def __disown__(self):
-        self.this.disown()
-        _csnd.disown_CsoundCallbackWrapper(self)
-        return weakref_proxy(self)
-CsoundCallbackWrapper_swigregister = _csnd.CsoundCallbackWrapper_swigregister
-CsoundCallbackWrapper_swigregister(CsoundCallbackWrapper)
-
-def CsoundCallbackWrapper_CharPtrToString(*args):
-  """CsoundCallbackWrapper_CharPtrToString(char s) -> char"""
-  return _csnd.CsoundCallbackWrapper_CharPtrToString(*args)
-
-class CsoundMidiInputBuffer(_object):
-    """Proxy of C++ CsoundMidiInputBuffer class"""
-    __swig_setmethods__ = {}
-    __setattr__ = lambda self, name, value: _swig_setattr(self, CsoundMidiInputBuffer, name, value)
-    __swig_getmethods__ = {}
-    __getattr__ = lambda self, name: _swig_getattr(self, CsoundMidiInputBuffer, name)
-    __repr__ = _swig_repr
-    def __init__(self, *args): 
-        """__init__(self, unsigned char buf, int bufSize) -> CsoundMidiInputBuffer"""
-        this = _csnd.new_CsoundMidiInputBuffer(*args)
-        try: self.this.append(this)
-        except: self.this = this
-    __swig_destroy__ = _csnd.delete_CsoundMidiInputBuffer
-    __del__ = lambda self : None;
-    def SendMessage(*args):
-        """
-        SendMessage(self, int msg)
-        SendMessage(self, int status, int channel, int data1, int data2)
-        """
-        return _csnd.CsoundMidiInputBuffer_SendMessage(*args)
-
-    def SendNoteOn(*args):
-        """SendNoteOn(self, int channel, int key, int velocity)"""
-        return _csnd.CsoundMidiInputBuffer_SendNoteOn(*args)
-
-    def SendNoteOff(*args):
-        """
-        SendNoteOff(self, int channel, int key, int velocity)
-        SendNoteOff(self, int channel, int key)
-        """
-        return _csnd.CsoundMidiInputBuffer_SendNoteOff(*args)
-
-    def SendPolyphonicPressure(*args):
-        """SendPolyphonicPressure(self, int channel, int key, int value)"""
-        return _csnd.CsoundMidiInputBuffer_SendPolyphonicPressure(*args)
-
-    def SendControlChange(*args):
-        """SendControlChange(self, int channel, int ctl, int value)"""
-        return _csnd.CsoundMidiInputBuffer_SendControlChange(*args)
-
-    def SendProgramChange(*args):
-        """SendProgramChange(self, int channel, int pgm)"""
-        return _csnd.CsoundMidiInputBuffer_SendProgramChange(*args)
-
-    def SendChannelPressure(*args):
-        """SendChannelPressure(self, int channel, int value)"""
-        return _csnd.CsoundMidiInputBuffer_SendChannelPressure(*args)
-
-    def SendPitchBend(*args):
-        """SendPitchBend(self, int channel, int value)"""
-        return _csnd.CsoundMidiInputBuffer_SendPitchBend(*args)
-
-CsoundMidiInputBuffer_swigregister = _csnd.CsoundMidiInputBuffer_swigregister
-CsoundMidiInputBuffer_swigregister(CsoundMidiInputBuffer)
-
-class CsoundMidiInputStream(CsoundMidiInputBuffer):
-    """Proxy of C++ CsoundMidiInputStream class"""
-    __swig_setmethods__ = {}
-    for _s in [CsoundMidiInputBuffer]: __swig_setmethods__.update(_s.__swig_setmethods__)
-    __setattr__ = lambda self, name, value: _swig_setattr(self, CsoundMidiInputStream, name, value)
-    __swig_getmethods__ = {}
-    for _s in [CsoundMidiInputBuffer]: __swig_getmethods__.update(_s.__swig_getmethods__)
-    __getattr__ = lambda self, name: _swig_getattr(self, CsoundMidiInputStream, name)
-    __repr__ = _swig_repr
-    def __init__(self, *args): 
-        """
-        __init__(self, CSOUND csound) -> CsoundMidiInputStream
-        __init__(self, Csound csound) -> CsoundMidiInputStream
-        """
-        this = _csnd.new_CsoundMidiInputStream(*args)
-        try: self.this.append(this)
-        except: self.this = this
-    __swig_destroy__ = _csnd.delete_CsoundMidiInputStream
-    __del__ = lambda self : None;
-    def EnableMidiInput(*args):
-        """EnableMidiInput(self, CsoundArgVList argv)"""
-        return _csnd.CsoundMidiInputStream_EnableMidiInput(*args)
-
-CsoundMidiInputStream_swigregister = _csnd.CsoundMidiInputStream_swigregister
-CsoundMidiInputStream_swigregister(CsoundMidiInputStream)
-
-class CsoundMidiOutputBuffer(_object):
-    """Proxy of C++ CsoundMidiOutputBuffer class"""
-    __swig_setmethods__ = {}
-    __setattr__ = lambda self, name, value: _swig_setattr(self, CsoundMidiOutputBuffer, name, value)
-    __swig_getmethods__ = {}
-    __getattr__ = lambda self, name: _swig_getattr(self, CsoundMidiOutputBuffer, name)
-    __repr__ = _swig_repr
-    def __init__(self, *args): 
-        """__init__(self, unsigned char buf, int bufSize) -> CsoundMidiOutputBuffer"""
-        this = _csnd.new_CsoundMidiOutputBuffer(*args)
-        try: self.this.append(this)
-        except: self.this = this
-    __swig_destroy__ = _csnd.delete_CsoundMidiOutputBuffer
-    __del__ = lambda self : None;
-    def PopMessage(*args):
-        """PopMessage(self) -> int"""
-        return _csnd.CsoundMidiOutputBuffer_PopMessage(*args)
-
-    def GetStatus(*args):
-        """GetStatus(self) -> int"""
-        return _csnd.CsoundMidiOutputBuffer_GetStatus(*args)
-
-    def GetChannel(*args):
-        """GetChannel(self) -> int"""
-        return _csnd.CsoundMidiOutputBuffer_GetChannel(*args)
-
-    def GetData1(*args):
-        """GetData1(self) -> int"""
-        return _csnd.CsoundMidiOutputBuffer_GetData1(*args)
-
-    def GetData2(*args):
-        """GetData2(self) -> int"""
-        return _csnd.CsoundMidiOutputBuffer_GetData2(*args)
-
-CsoundMidiOutputBuffer_swigregister = _csnd.CsoundMidiOutputBuffer_swigregister
-CsoundMidiOutputBuffer_swigregister(CsoundMidiOutputBuffer)
-
-class CsoundMidiOutputStream(CsoundMidiOutputBuffer):
-    """Proxy of C++ CsoundMidiOutputStream class"""
-    __swig_setmethods__ = {}
-    for _s in [CsoundMidiOutputBuffer]: __swig_setmethods__.update(_s.__swig_setmethods__)
-    __setattr__ = lambda self, name, value: _swig_setattr(self, CsoundMidiOutputStream, name, value)
-    __swig_getmethods__ = {}
-    for _s in [CsoundMidiOutputBuffer]: __swig_getmethods__.update(_s.__swig_getmethods__)
-    __getattr__ = lambda self, name: _swig_getattr(self, CsoundMidiOutputStream, name)
-    __repr__ = _swig_repr
-    def __init__(self, *args): 
-        """
-        __init__(self, CSOUND csound) -> CsoundMidiOutputStream
-        __init__(self, Csound csound) -> CsoundMidiOutputStream
-        """
-        this = _csnd.new_CsoundMidiOutputStream(*args)
-        try: self.this.append(this)
-        except: self.this = this
-    __swig_destroy__ = _csnd.delete_CsoundMidiOutputStream
-    __del__ = lambda self : None;
-    def EnableMidiOutput(*args):
-        """EnableMidiOutput(self, CsoundArgVList argv)"""
-        return _csnd.CsoundMidiOutputStream_EnableMidiOutput(*args)
-
-CsoundMidiOutputStream_swigregister = _csnd.CsoundMidiOutputStream_swigregister
-CsoundMidiOutputStream_swigregister(CsoundMidiOutputStream)
-
-class CsoundPerformanceThread(_object):
-    """Proxy of C++ CsoundPerformanceThread class"""
-    __swig_setmethods__ = {}
-    __setattr__ = lambda self, name, value: _swig_setattr(self, CsoundPerformanceThread, name, value)
-    __swig_getmethods__ = {}
-    __getattr__ = lambda self, name: _swig_getattr(self, CsoundPerformanceThread, name)
-    __repr__ = _swig_repr
-    def GetCsound(*args):
-        """GetCsound(self) -> CSOUND"""
-        return _csnd.CsoundPerformanceThread_GetCsound(*args)
-
-    def GetStatus(*args):
-        """GetStatus(self) -> int"""
-        return _csnd.CsoundPerformanceThread_GetStatus(*args)
-
-    def Play(*args):
-        """Play(self)"""
-        return _csnd.CsoundPerformanceThread_Play(*args)
-
-    def Pause(*args):
-        """Pause(self)"""
-        return _csnd.CsoundPerformanceThread_Pause(*args)
-
-    def TogglePause(*args):
-        """TogglePause(self)"""
-        return _csnd.CsoundPerformanceThread_TogglePause(*args)
-
-    def Stop(*args):
-        """Stop(self)"""
-        return _csnd.CsoundPerformanceThread_Stop(*args)
-
-    def ScoreEvent(*args):
-        """ScoreEvent(self, int absp2mode, char opcod, int pcnt, float p)"""
-        return _csnd.CsoundPerformanceThread_ScoreEvent(*args)
-
-    def InputMessage(*args):
-        """InputMessage(self, char s)"""
-        return _csnd.CsoundPerformanceThread_InputMessage(*args)
-
-    def SetScoreOffsetSeconds(*args):
-        """SetScoreOffsetSeconds(self, double timeVal)"""
-        return _csnd.CsoundPerformanceThread_SetScoreOffsetSeconds(*args)
-
-    def Join(*args):
-        """Join(self) -> int"""
-        return _csnd.CsoundPerformanceThread_Join(*args)
-
-    def FlushMessageQueue(*args):
-        """FlushMessageQueue(self)"""
-        return _csnd.CsoundPerformanceThread_FlushMessageQueue(*args)
-
-    def __init__(self, *args): 
-        """
-        __init__(self, Csound ?) -> CsoundPerformanceThread
-        __init__(self, CSOUND ?) -> CsoundPerformanceThread
-        """
-        this = _csnd.new_CsoundPerformanceThread(*args)
-        try: self.this.append(this)
-        except: self.this = this
-    __swig_destroy__ = _csnd.delete_CsoundPerformanceThread
-    __del__ = lambda self : None;
-CsoundPerformanceThread_swigregister = _csnd.CsoundPerformanceThread_swigregister
-CsoundPerformanceThread_swigregister(CsoundPerformanceThread)
-
-
-def gatherArgs(*args):
-  """gatherArgs(int argc, char argv, string commandLine)"""
-  return _csnd.gatherArgs(*args)
-
-def scatterArgs(*args):
-  """
-    scatterArgs(string commandLine, std::vector<(std::string,std::allocator<(std::string)>)> args, 
-        std::vector<(p.char,std::allocator<(p.char)>)> argv)
-    """
-  return _csnd.scatterArgs(*args)
-
-def trim(*args):
-  """trim(string value) -> string"""
-  return _csnd.trim(*args)
-
-def trimQuotes(*args):
-  """trimQuotes(string value) -> string"""
-  return _csnd.trimQuotes(*args)
-
-def parseInstrument(*args):
-  """
-    parseInstrument(string definition, string preNumber, string id, string name, 
-        string postNumber) -> bool
-    """
-  return _csnd.parseInstrument(*args)
-class CsoundFile(_object):
-    """Proxy of C++ CsoundFile class"""
-    __swig_setmethods__ = {}
-    __setattr__ = lambda self, name, value: _swig_setattr(self, CsoundFile, name, value)
-    __swig_getmethods__ = {}
-    __getattr__ = lambda self, name: _swig_getattr(self, CsoundFile, name)
-    __repr__ = _swig_repr
-    __swig_setmethods__["libraryFilename"] = _csnd.CsoundFile_libraryFilename_set
-    __swig_getmethods__["libraryFilename"] = _csnd.CsoundFile_libraryFilename_get
-    if _newclass:libraryFilename = property(_csnd.CsoundFile_libraryFilename_get, _csnd.CsoundFile_libraryFilename_set)
-    __swig_setmethods__["arrangement"] = _csnd.CsoundFile_arrangement_set
-    __swig_getmethods__["arrangement"] = _csnd.CsoundFile_arrangement_get
-    if _newclass:arrangement = property(_csnd.CsoundFile_arrangement_get, _csnd.CsoundFile_arrangement_set)
-    def __init__(self, *args): 
-        """__init__(self) -> CsoundFile"""
-        this = _csnd.new_CsoundFile(*args)
-        try: self.this.append(this)
-        except: self.this = this
-    __swig_destroy__ = _csnd.delete_CsoundFile
-    __del__ = lambda self : None;
-    def generateFilename(*args):
-        """generateFilename(self) -> string"""
-        return _csnd.CsoundFile_generateFilename(*args)
-
-    def getFilename(*args):
-        """getFilename(self) -> string"""
-        return _csnd.CsoundFile_getFilename(*args)
-
-    def setFilename(*args):
-        """setFilename(self, string name)"""
-        return _csnd.CsoundFile_setFilename(*args)
-
-    def load(*args):
-        """
-        load(self, string filename) -> int
-        load(self, std::istream stream) -> int
-        """
-        return _csnd.CsoundFile_load(*args)
-
-    def save(*args):
-        """
-        save(self, string filename) -> int
-        save(self, std::ostream stream) -> int
-        """
-        return _csnd.CsoundFile_save(*args)
-
-    def importFile(*args):
-        """
-        importFile(self, string filename) -> int
-        importFile(self, std::istream stream) -> int
-        """
-        return _csnd.CsoundFile_importFile(*args)
-
-    def importCommand(*args):
-        """importCommand(self, std::istream stream) -> int"""
-        return _csnd.CsoundFile_importCommand(*args)
-
-    def exportCommand(*args):
-        """exportCommand(self, std::ostream stream) -> int"""
-        return _csnd.CsoundFile_exportCommand(*args)
-
-    def importOrchestra(*args):
-        """importOrchestra(self, std::istream stream) -> int"""
-        return _csnd.CsoundFile_importOrchestra(*args)
-
-    def exportOrchestra(*args):
-        """exportOrchestra(self, std::ostream stream) -> int"""
-        return _csnd.CsoundFile_exportOrchestra(*args)
-
-    def importScore(*args):
-        """importScore(self, std::istream stream) -> int"""
-        return _csnd.CsoundFile_importScore(*args)
-
-    def exportScore(*args):
-        """exportScore(self, std::ostream stream) -> int"""
-        return _csnd.CsoundFile_exportScore(*args)
-
-    def importArrangement(*args):
-        """importArrangement(self, std::istream stream) -> int"""
-        return _csnd.CsoundFile_importArrangement(*args)
-
-    def exportArrangement(*args):
-        """exportArrangement(self, std::ostream stream) -> int"""
-        return _csnd.CsoundFile_exportArrangement(*args)
-
-    def exportArrangementForPerformance(*args):
-        """
-        exportArrangementForPerformance(self, string filename) -> int
-        exportArrangementForPerformance(self, std::ostream stream) -> int
-        """
-        return _csnd.CsoundFile_exportArrangementForPerformance(*args)
-
-    def importMidifile(*args):
-        """importMidifile(self, std::istream stream) -> int"""
-        return _csnd.CsoundFile_importMidifile(*args)
-
-    def exportMidifile(*args):
-        """exportMidifile(self, std::ostream stream) -> int"""
-        return _csnd.CsoundFile_exportMidifile(*args)
-
-    def getCommand(*args):
-        """getCommand(self) -> string"""
-        return _csnd.CsoundFile_getCommand(*args)
-
-    def setCommand(*args):
-        """setCommand(self, string commandLine)"""
-        return _csnd.CsoundFile_setCommand(*args)
-
-    def getOrcFilename(*args):
-        """getOrcFilename(self) -> string"""
-        return _csnd.CsoundFile_getOrcFilename(*args)
-
-    def getScoFilename(*args):
-        """getScoFilename(self) -> string"""
-        return _csnd.CsoundFile_getScoFilename(*args)
-
-    def getMidiFilename(*args):
-        """getMidiFilename(self) -> string"""
-        return _csnd.CsoundFile_getMidiFilename(*args)
-
-    def getOutputSoundfileName(*args):
-        """getOutputSoundfileName(self) -> string"""
-        return _csnd.CsoundFile_getOutputSoundfileName(*args)
-
-    def getOrchestra(*args):
-        """getOrchestra(self) -> string"""
-        return _csnd.CsoundFile_getOrchestra(*args)
-
-    def setOrchestra(*args):
-        """setOrchestra(self, string orchestra)"""
-        return _csnd.CsoundFile_setOrchestra(*args)
-
-    def getInstrumentCount(*args):
-        """getInstrumentCount(self) -> int"""
-        return _csnd.CsoundFile_getInstrumentCount(*args)
-
-    def getOrchestraHeader(*args):
-        """getOrchestraHeader(self) -> string"""
-        return _csnd.CsoundFile_getOrchestraHeader(*args)
-
-    def getInstrument(*args):
-        """
-        getInstrument(self, int number, string definition) -> bool
-        getInstrument(self, string name, string definition) -> bool
-        """
-        return _csnd.CsoundFile_getInstrument(*args)
-
-    def getScore(*args):
-        """getScore(self) -> string"""
-        return _csnd.CsoundFile_getScore(*args)
-
-    def setScore(*args):
-        """setScore(self, string score)"""
-        return _csnd.CsoundFile_setScore(*args)
-
-    def getArrangementCount(*args):
-        """getArrangementCount(self) -> int"""
-        return _csnd.CsoundFile_getArrangementCount(*args)
-
-    def getArrangement(*args):
-        """getArrangement(self, int index) -> string"""
-        return _csnd.CsoundFile_getArrangement(*args)
-
-    def addArrangement(*args):
-        """addArrangement(self, string instrument)"""
-        return _csnd.CsoundFile_addArrangement(*args)
-
-    def setArrangement(*args):
-        """setArrangement(self, int index, string instrument)"""
-        return _csnd.CsoundFile_setArrangement(*args)
-
-    def insertArrangement(*args):
-        """insertArrangement(self, int index, string instrument)"""
-        return _csnd.CsoundFile_insertArrangement(*args)
-
-    def setCSD(*args):
-        """setCSD(self, string xml)"""
-        return _csnd.CsoundFile_setCSD(*args)
-
-    def getCSD(*args):
-        """getCSD(self) -> string"""
-        return _csnd.CsoundFile_getCSD(*args)
-
-    def addScoreLine(*args):
-        """addScoreLine(self, string line)"""
-        return _csnd.CsoundFile_addScoreLine(*args)
-
-    def addNote(*args):
-        """
-        addNote(self, double p1, double p2, double p3, double p4, double p5, 
-            double p6, double p7, double p8, double p9, 
-            double p10, double p11)
-        addNote(self, double p1, double p2, double p3, double p4, double p5, 
-            double p6, double p7, double p8, double p9, 
-            double p10)
-        addNote(self, double p1, double p2, double p3, double p4, double p5, 
-            double p6, double p7, double p8, double p9)
-        addNote(self, double p1, double p2, double p3, double p4, double p5, 
-            double p6, double p7, double p8)
-        addNote(self, double p1, double p2, double p3, double p4, double p5, 
-            double p6, double p7)
-        addNote(self, double p1, double p2, double p3, double p4, double p5, 
-            double p6)
-        addNote(self, double p1, double p2, double p3, double p4, double p5)
-        addNote(self, double p1, double p2, double p3, double p4)
-        addNote(self, double p1, double p2, double p3)
-        """
-        return _csnd.CsoundFile_addNote(*args)
-
-    def exportForPerformance(*args):
-        """exportForPerformance(self) -> bool"""
-        return _csnd.CsoundFile_exportForPerformance(*args)
-
-    def removeAll(*args):
-        """removeAll(self)"""
-        return _csnd.CsoundFile_removeAll(*args)
-
-    def removeCommand(*args):
-        """removeCommand(self)"""
-        return _csnd.CsoundFile_removeCommand(*args)
-
-    def removeOrchestra(*args):
-        """removeOrchestra(self)"""
-        return _csnd.CsoundFile_removeOrchestra(*args)
-
-    def removeScore(*args):
-        """removeScore(self)"""
-        return _csnd.CsoundFile_removeScore(*args)
-
-    def removeArrangement(*args):
-        """
-        removeArrangement(self, int index)
-        removeArrangement(self)
-        """
-        return _csnd.CsoundFile_removeArrangement(*args)
-
-    def removeMidifile(*args):
-        """removeMidifile(self)"""
-        return _csnd.CsoundFile_removeMidifile(*args)
-
-    def loadOrcLibrary(*args):
-        """
-        loadOrcLibrary(self, char filename=0) -> bool
-        loadOrcLibrary(self) -> bool
-        """
-        return _csnd.CsoundFile_loadOrcLibrary(*args)
-
-CsoundFile_swigregister = _csnd.CsoundFile_swigregister
-CsoundFile_swigregister(CsoundFile)
-
-class MyfltVector(_object):
-    """Proxy of C++ MyfltVector class"""
-    __swig_setmethods__ = {}
-    __setattr__ = lambda self, name, value: _swig_setattr(self, MyfltVector, name, value)
-    __swig_getmethods__ = {}
-    __getattr__ = lambda self, name: _swig_getattr(self, MyfltVector, name)
-    __repr__ = _swig_repr
-    def iterator(*args):
-        """iterator(self, PyObject PYTHON_SELF) -> PySwigIterator"""
-        return _csnd.MyfltVector_iterator(*args)
-
-    def __iter__(self): return self.iterator()
-    def __nonzero__(*args):
-        """__nonzero__(self) -> bool"""
-        return _csnd.MyfltVector___nonzero__(*args)
-
-    def __len__(*args):
-        """__len__(self) -> size_type"""
-        return _csnd.MyfltVector___len__(*args)
-
-    def pop(*args):
-        """pop(self) -> value_type"""
-        return _csnd.MyfltVector_pop(*args)
-
-    def __getslice__(*args):
-        """__getslice__(self, difference_type i, difference_type j) -> MyfltVector"""
-        return _csnd.MyfltVector___getslice__(*args)
-
-    def __setslice__(*args):
-        """__setslice__(self, difference_type i, difference_type j, MyfltVector v)"""
-        return _csnd.MyfltVector___setslice__(*args)
-
-    def __delslice__(*args):
-        """__delslice__(self, difference_type i, difference_type j)"""
-        return _csnd.MyfltVector___delslice__(*args)
-
-    def __delitem__(*args):
-        """__delitem__(self, difference_type i)"""
-        return _csnd.MyfltVector___delitem__(*args)
-
-    def __getitem__(*args):
-        """__getitem__(self, difference_type i) -> value_type"""
-        return _csnd.MyfltVector___getitem__(*args)
-
-    def __setitem__(*args):
-        """__setitem__(self, difference_type i, value_type x)"""
-        return _csnd.MyfltVector___setitem__(*args)
-
-    def append(*args):
-        """append(self, value_type x)"""
-        return _csnd.MyfltVector_append(*args)
-
-    def empty(*args):
-        """empty(self) -> bool"""
-        return _csnd.MyfltVector_empty(*args)
-
-    def size(*args):
-        """size(self) -> size_type"""
-        return _csnd.MyfltVector_size(*args)
-
-    def clear(*args):
-        """clear(self)"""
-        return _csnd.MyfltVector_clear(*args)
-
-    def swap(*args):
-        """swap(self, MyfltVector v)"""
-        return _csnd.MyfltVector_swap(*args)
-
-    def get_allocator(*args):
-        """get_allocator(self) -> allocator_type"""
-        return _csnd.MyfltVector_get_allocator(*args)
-
-    def begin(*args):
-        """
-        begin(self) -> iterator
-        begin(self) -> const_iterator
-        """
-        return _csnd.MyfltVector_begin(*args)
-
-    def end(*args):
-        """
-        end(self) -> iterator
-        end(self) -> const_iterator
-        """
-        return _csnd.MyfltVector_end(*args)
-
-    def rbegin(*args):
-        """
-        rbegin(self) -> reverse_iterator
-        rbegin(self) -> const_reverse_iterator
-        """
-        return _csnd.MyfltVector_rbegin(*args)
-
-    def rend(*args):
-        """
-        rend(self) -> reverse_iterator
-        rend(self) -> const_reverse_iterator
-        """
-        return _csnd.MyfltVector_rend(*args)
-
-    def pop_back(*args):
-        """pop_back(self)"""
-        return _csnd.MyfltVector_pop_back(*args)
-
-    def erase(*args):
-        """
-        erase(self, iterator pos) -> iterator
-        erase(self, iterator first, iterator last) -> iterator
-        """
-        return _csnd.MyfltVector_erase(*args)
-
-    def __init__(self, *args): 
-        """
-        __init__(self) -> MyfltVector
-        __init__(self, MyfltVector ?) -> MyfltVector
-        __init__(self, size_type size) -> MyfltVector
-        __init__(self, size_type size, value_type value) -> MyfltVector
-        """
-        this = _csnd.new_MyfltVector(*args)
-        try: self.this.append(this)
-        except: self.this = this
-    def push_back(*args):
-        """push_back(self, value_type x)"""
-        return _csnd.MyfltVector_push_back(*args)
-
-    def front(*args):
-        """front(self) -> value_type"""
-        return _csnd.MyfltVector_front(*args)
-
-    def back(*args):
-        """back(self) -> value_type"""
-        return _csnd.MyfltVector_back(*args)
-
-    def assign(*args):
-        """assign(self, size_type n, value_type x)"""
-        return _csnd.MyfltVector_assign(*args)
-
-    def resize(*args):
-        """
-        resize(self, size_type new_size)
-        resize(self, size_type new_size, value_type x)
-        """
-        return _csnd.MyfltVector_resize(*args)
-
-    def insert(*args):
-        """
-        insert(self, iterator pos, value_type x) -> iterator
-        insert(self, iterator pos, size_type n, value_type x)
-        """
-        return _csnd.MyfltVector_insert(*args)
-
-    def reserve(*args):
-        """reserve(self, size_type n)"""
-        return _csnd.MyfltVector_reserve(*args)
-
-    def capacity(*args):
-        """capacity(self) -> size_type"""
-        return _csnd.MyfltVector_capacity(*args)
-
-    __swig_destroy__ = _csnd.delete_MyfltVector
-    __del__ = lambda self : None;
-MyfltVector_swigregister = _csnd.MyfltVector_swigregister
-MyfltVector_swigregister(MyfltVector)
-
-class CppSound(Csound,CsoundFile):
-    """Proxy of C++ CppSound class"""
-    __swig_setmethods__ = {}
-    for _s in [Csound,CsoundFile]: __swig_setmethods__.update(_s.__swig_setmethods__)
-    __setattr__ = lambda self, name, value: _swig_setattr(self, CppSound, name, value)
-    __swig_getmethods__ = {}
-    for _s in [Csound,CsoundFile]: __swig_getmethods__.update(_s.__swig_getmethods__)
-    __getattr__ = lambda self, name: _swig_getattr(self, CppSound, name)
-    __repr__ = _swig_repr
-    def __init__(self, *args): 
-        """__init__(self) -> CppSound"""
-        this = _csnd.new_CppSound(*args)
-        try: self.this.append(this)
-        except: self.this = this
-    __swig_destroy__ = _csnd.delete_CppSound
-    __del__ = lambda self : None;
-    def getCsound(*args):
-        """getCsound(self) -> CSOUND"""
-        return _csnd.CppSound_getCsound(*args)
-
-    def getThis(*args):
-        """getThis(self) -> long"""
-        return _csnd.CppSound_getThis(*args)
-
-    def getCsoundFile(*args):
-        """getCsoundFile(self) -> CsoundFile"""
-        return _csnd.CppSound_getCsoundFile(*args)
-
-    def compile(*args):
-        """
-        compile(self, int argc, char argv) -> int
-        compile(self) -> int
-        """
-        return _csnd.CppSound_compile(*args)
-
-    def getSpoutSize(*args):
-        """getSpoutSize(self) -> size_t"""
-        return _csnd.CppSound_getSpoutSize(*args)
-
-    def getOutputSoundfileName(*args):
-        """getOutputSoundfileName(self) -> string"""
-        return _csnd.CppSound_getOutputSoundfileName(*args)
-
-    def perform(*args):
-        """
-        perform(self, int argc, char argv) -> int
-        perform(self) -> int
-        """
-        return _csnd.CppSound_perform(*args)
-
-    def performKsmps(*args):
-        """performKsmps(self, bool absolute) -> int"""
-        return _csnd.CppSound_performKsmps(*args)
-
-    def cleanup(*args):
-        """cleanup(self)"""
-        return _csnd.CppSound_cleanup(*args)
-
-    def inputMessage(*args):
-        """inputMessage(self, char istatement)"""
-        return _csnd.CppSound_inputMessage(*args)
-
-    def write(*args):
-        """write(self, char text)"""
-        return _csnd.CppSound_write(*args)
-
-    def getIsCompiled(*args):
-        """getIsCompiled(self) -> bool"""
-        return _csnd.CppSound_getIsCompiled(*args)
-
-    def setIsPerforming(*args):
-        """setIsPerforming(self, bool isPerforming)"""
-        return _csnd.CppSound_setIsPerforming(*args)
-
-    def getIsPerforming(*args):
-        """getIsPerforming(self) -> bool"""
-        return _csnd.CppSound_getIsPerforming(*args)
-
-    def getIsGo(*args):
-        """getIsGo(self) -> bool"""
-        return _csnd.CppSound_getIsGo(*args)
-
-    def stop(*args):
-        """stop(self)"""
-        return _csnd.CppSound_stop(*args)
-
-    def setPythonMessageCallback(*args):
-        """setPythonMessageCallback(self)"""
-        return _csnd.CppSound_setPythonMessageCallback(*args)
-
-CppSound_swigregister = _csnd.CppSound_swigregister
-CppSound_swigregister(CppSound)
-
-
-def csoundCsdCreate(*args):
-  """csoundCsdCreate(CSOUND csound)"""
-  return _csnd.csoundCsdCreate(*args)
-
-def csoundCsdSetOptions(*args):
-  """csoundCsdSetOptions(CSOUND csound, char options)"""
-  return _csnd.csoundCsdSetOptions(*args)
-
-def csoundCsdGetOptions(*args):
-  """csoundCsdGetOptions(CSOUND csound) -> char"""
-  return _csnd.csoundCsdGetOptions(*args)
-
-def csoundCsdSetOrchestra(*args):
-  """csoundCsdSetOrchestra(CSOUND csound, char orchestra)"""
-  return _csnd.csoundCsdSetOrchestra(*args)
-
-def csoundCsdGetOrchestra(*args):
-  """csoundCsdGetOrchestra(CSOUND csound) -> char"""
-  return _csnd.csoundCsdGetOrchestra(*args)
-
-def csoundCsdAddScoreLine(*args):
-  """csoundCsdAddScoreLine(CSOUND csound, char line)"""
-  return _csnd.csoundCsdAddScoreLine(*args)
-
-def csoundCsdAddEvent11(*args):
-  """
-    csoundCsdAddEvent11(CSOUND csound, double p1, double p2, double p3, double p4, 
-        double p5, double p6, double p7, double p8, 
-        double p9, double p10, double p11)
-    """
-  return _csnd.csoundCsdAddEvent11(*args)
-
-def csoundCsdAddEvent10(*args):
-  """
-    csoundCsdAddEvent10(CSOUND csound, double p1, double p2, double p3, double p4, 
-        double p5, double p6, double p7, double p8, 
-        double p9, double p10)
-    """
-  return _csnd.csoundCsdAddEvent10(*args)
-
-def csoundCsdAddEvent9(*args):
-  """
-    csoundCsdAddEvent9(CSOUND csound, double p1, double p2, double p3, double p4, 
-        double p5, double p6, double p7, double p8, 
-        double p9)
-    """
-  return _csnd.csoundCsdAddEvent9(*args)
-
-def csoundCsdAddEvent8(*args):
-  """
-    csoundCsdAddEvent8(CSOUND csound, double p1, double p2, double p3, double p4, 
-        double p5, double p6, double p7, double p8)
-    """
-  return _csnd.csoundCsdAddEvent8(*args)
-
-def csoundCsdAddEvent7(*args):
-  """
-    csoundCsdAddEvent7(CSOUND csound, double p1, double p2, double p3, double p4, 
-        double p5, double p6, double p7)
-    """
-  return _csnd.csoundCsdAddEvent7(*args)
-
-def csoundCsdAddEvent6(*args):
-  """
-    csoundCsdAddEvent6(CSOUND csound, double p1, double p2, double p3, double p4, 
-        double p5, double p6)
-    """
-  return _csnd.csoundCsdAddEvent6(*args)
-
-def csoundCsdAddEvent5(*args):
-  """
-    csoundCsdAddEvent5(CSOUND csound, double p1, double p2, double p3, double p4, 
-        double p5)
-    """
-  return _csnd.csoundCsdAddEvent5(*args)
-
-def csoundCsdAddEvent4(*args):
-  """csoundCsdAddEvent4(CSOUND csound, double p1, double p2, double p3, double p4)"""
-  return _csnd.csoundCsdAddEvent4(*args)
-
-def csoundCsdAddEvent3(*args):
-  """csoundCsdAddEvent3(CSOUND csound, double p1, double p2, double p3)"""
-  return _csnd.csoundCsdAddEvent3(*args)
-
-def csoundCsdSave(*args):
-  """csoundCsdSave(CSOUND csound, char filename) -> int"""
-  return _csnd.csoundCsdSave(*args)
-
-def csoundCsdCompile(*args):
-  """csoundCsdCompile(CSOUND csound, char filename) -> int"""
-  return _csnd.csoundCsdCompile(*args)
-
-def csoundCsdPerform(*args):
-  """csoundCsdPerform(CSOUND csound, char filename) -> int"""
-  return _csnd.csoundCsdPerform(*args)
-
-def csoundCompileCsd(*args):
-  """csoundCompileCsd(CSOUND ?, char csdFilename) -> int"""
-  return _csnd.csoundCompileCsd(*args)
-
-def csoundPerformCsd(*args):
-  """csoundPerformCsd(CSOUND ?, char csdFilename) -> int"""
-  return _csnd.csoundPerformCsd(*args)
-class Soundfile(_object):
-    """Proxy of C++ Soundfile class"""
-    __swig_setmethods__ = {}
-    __setattr__ = lambda self, name, value: _swig_setattr(self, Soundfile, name, value)
-    __swig_getmethods__ = {}
-    __getattr__ = lambda self, name: _swig_getattr(self, Soundfile, name)
-    __repr__ = _swig_repr
-    def __init__(self, *args): 
-        """__init__(self) -> Soundfile"""
-        this = _csnd.new_Soundfile(*args)
-        try: self.this.append(this)
-        except: self.this = this
-    __swig_destroy__ = _csnd.delete_Soundfile
-    __del__ = lambda self : None;
-    def getFramesPerSecond(*args):
-        """getFramesPerSecond(self) -> int"""
-        return _csnd.Soundfile_getFramesPerSecond(*args)
-
-    def setFramesPerSecond(*args):
-        """setFramesPerSecond(self, int framesPerSecond)"""
-        return _csnd.Soundfile_setFramesPerSecond(*args)
-
-    def getChannelsPerFrame(*args):
-        """getChannelsPerFrame(self) -> int"""
-        return _csnd.Soundfile_getChannelsPerFrame(*args)
-
-    def setChannelsPerFrame(*args):
-        """setChannelsPerFrame(self, int channelsPerFrame)"""
-        return _csnd.Soundfile_setChannelsPerFrame(*args)
-
-    def getFormat(*args):
-        """getFormat(self) -> int"""
-        return _csnd.Soundfile_getFormat(*args)
-
-    def setFormat(*args):
-        """setFormat(self, int format)"""
-        return _csnd.Soundfile_setFormat(*args)
-
-    def getFrames(*args):
-        """getFrames(self) -> int"""
-        return _csnd.Soundfile_getFrames(*args)
-
-    def open(*args):
-        """open(self, string filename) -> int"""
-        return _csnd.Soundfile_open(*args)
-
-    def create(*args):
-        """
-        create(self, string filename, int framesPerSecond=44100, int channelsPerFrame=2, 
-            int format=SF_FORMAT_WAV|SF_FORMAT_FLOAT) -> int
-        create(self, string filename, int framesPerSecond=44100, int channelsPerFrame=2) -> int
-        create(self, string filename, int framesPerSecond=44100) -> int
-        create(self, string filename) -> int
-        """
-        return _csnd.Soundfile_create(*args)
-
-    def seek(*args):
-        """
-        seek(self, int frames, int whence=0) -> int
-        seek(self, int frames) -> int
-        """
-        return _csnd.Soundfile_seek(*args)
-
-    def seekSeconds(*args):
-        """
-        seekSeconds(self, double seconds, int whence=0) -> double
-        seekSeconds(self, double seconds) -> double
-        """
-        return _csnd.Soundfile_seekSeconds(*args)
-
-    def readFrame(*args):
-        """readFrame(self, double outputFrame) -> int"""
-        return _csnd.Soundfile_readFrame(*args)
-
-    def writeFrame(*args):
-        """writeFrame(self, double inputFrame) -> int"""
-        return _csnd.Soundfile_writeFrame(*args)
-
-    def readFrames(*args):
-        """readFrames(self, double outputFrames) -> int"""
-        return _csnd.Soundfile_readFrames(*args)
-
-    def writeFrames(*args):
-        """writeFrames(self, double inputFrames) -> int"""
-        return _csnd.Soundfile_writeFrames(*args)
-
-    def mixFrames(*args):
-        """mixFrames(self, double inputFrames, double mixedFrames) -> int"""
-        return _csnd.Soundfile_mixFrames(*args)
-
-    def updateHeader(*args):
-        """updateHeader(self)"""
-        return _csnd.Soundfile_updateHeader(*args)
-
-    def close(*args):
-        """close(self) -> int"""
-        return _csnd.Soundfile_close(*args)
-
-    def error(*args):
-        """error(self)"""
-        return _csnd.Soundfile_error(*args)
-
-    def blank(*args):
-        """blank(self, double duration)"""
-        return _csnd.Soundfile_blank(*args)
-
-Soundfile_swigregister = _csnd.Soundfile_swigregister
-Soundfile_swigregister(Soundfile)
-
-
-
diff --git a/csserver/univorc.csd b/csserver/univorc.csd
index 8abcdd2..0080f8a 100755
--- a/csserver/univorc.csd
+++ b/csserver/univorc.csd
@@ -1,139 +1,446 @@
-<CsoundSynthesizer>

-<CsOptions>

--odac -+rtaudio=alsa -d  

-</CsOptions>

-

-<CsInstruments>

-sr=32000

-ksmps=100

-nchnls=2

-

-gaudp1  init 0

-gaudp2  init 0

-

-

-instr 102

-/* soundfile play control 

-   p4 : filename 

-   p5 : unique instance ID

-   p6 : output gain (0-1)

-   p7 : udp send gain (0-1)

-   p8 : offset in seconds

-

-   channels:

-   sfplay.<ID>.on  - instance control channel (1:on 0: off)

-   sfplay.<ID>.gain - soundfile play gain (0-1)

-   sfplay.<ID>.udpgain - udp send gain (0-1)

-   sfplay.<ID>.flen  - holds the channel length

-*/

-S1 strget p4

-inst = p5

-ich    filenchnls S1

-iln    filelen  S1

-ioffset = p8

-

-Slen  sprintf "sfplay.%d.flen", p5  ; file length channel

-chnset iln, Slen

-

-if ioffset >= iln then

-turnoff

-else 

-iln = iln - ioffset

-endif

-

-Splay sprintf "sfplay.%d.on", inst  ; instance control channel

-Sname sprintf "sfplay.%d.fname", inst  ; filename channel 

-Sgain sprintf "sfplay.%d.gain", inst ; gain channel

-Sudp  sprintf "sfplay.%d.udpgain", inst ; udp gain channel  

-

-chnset S1, Sname

-chnset 1,  Splay

-chnset p6, Sgain

-chnset p7, Sudp

-event_i "i",103,0,iln,inst,ich,ioffset

-turnoff 

-endin

-

-

-instr 103

-/* soundfile player 

-   This is the actual soundfile player. 

-   It never gets called directly

-*/

-ich = p5

-inst= p4

-ioffset = p6

-Splay sprintf "sfplay.%d.on", inst  ; instance control channel

-Sname sprintf "sfplay.%d.fname", inst  ; filename channel 

-Sgain sprintf "sfplay.%d.gain", inst ; gain channel

-Sudp  sprintf "sfplay.%d.udpgain", inst ; udp gain channel   

-kon chnget Splay

-kg1 chnget Sgain

-kg2 chnget Sudp

-S1  chnget Sname

-if kon == 0 then

-printf "sfplay:%d OFF\n", 1, inst

-turnoff

-endif

-if ich = 1 then

-a1 diskin2 S1,1,ioffset,1

-a2 = a1

-else

-a1,a2 diskin2 S1,1,ioffset,1

-endif

-      outs a1*kg1, a2*kg1

-gaudp1 = a1*kg2 + gaudp1

-gaudp2 = a2*kg2 + gaudp2

-printf_i "sfplay:%d\n", 1, inst

-endin 

-

-

-instr 254

-/* udp receive instrument 

-   p4 : unique instance ID

-

-   channels:

-   osc.<ID>.on  - instance control (1: on, 0: off)

-ion = 1

-inst = 0

-Son   sprintf  "udprecv.%d.on"  , inst  ; instance control channel

-chnset ion, Son

-kon   chnget  Son

-

-if kon == 0 then

-printf "udprecv:%d OFF\n", 1, inst

-turnoff

-endif

-

-asig sockrecv 40001, 32

-outs asig, asig */

-endin 

-

-

-instr 255

-/* udp send instrument 

-socksends gaudp1, gaudp2, "1.1.25.90", 40000, 256     */

-endin

-

-instr 256

-gaudp1 = 0

-gaudp2 = 0

-a1 = 0

-outs a1, a1

-endin 

-

-</CsInstruments>

-

-<CsScore>

-f1 0 1024 10 1

-i254 0 86400

-i255 0 86400

-i256 0 86400

-

-; tests

-; i 101 0 10 1 65 -16 -96

-; i102 0 0.1 "coltrane.wav" 1 0.5 0 2

-; i102 1 0.1 "jarrett.wav" 2  2 0 230

-

-</CsScore>

-</CsoundSynthesizer>

+<CsoundSynthesizer>
+<CsOptions>
+-+rtaudio=alsa -idevaudio -odevaudio -m0 -W -s -d -b256 -B1024
+</CsOptions>
+<CsInstruments>
+sr=44100
+ksmps=100
+nchnls=2
+
+gaudp1  init 0
+gaudp2  init 0
+gainrev init 0
+gaoutL init 0
+gaoutR init 0
+
+/*****************************************************************
+Reverb + master out
+*****************************************************************/
+instr 200
+
+koutGain chnget "masterVolume"
+koutGain = koutGain * 0.01
+
+ia	ftgen	89,	0, 64, -2, -1009, -1103, -1123, -1281, -1289, -1307, -1361, -1409, -1429, -1543, -1583, -1601, -1613, -1709, -1801, -1949, -2003, -2111, -2203, -2341, -2411, -2591, -2609, -2749, -2801, -2903, -3001, -3109, -3203, -3301, -3407, -3539, 0.82, 0.81,	0.8,	0.79, 0.78, 0.77, 0.76, 0.75, 0.74, 0.73, 0.72, 0.71, 0.7, 0.69, 0.68, 0.67, 0.66, 0.65, 0.64, 0.63, 0.62, 0.61, 0.6, 0.59, 0.58, 0.57, 0.56, 0.55, 0.54, 0.53, 0.52, 0.51
+
+ib	ftgen	90,	0, 16, -2, -179, -223, -233, -311, -347, -409, -433, -509, 0.76, 0.74, 0.72, 0.7, 0.68, 0.64, 0.62, 0.6
+
+ain		dcblock		gainrev*0.05	
+arev	nreverb		ain, 2.8, 0.7, 0, 32, 89, 8, 90
+arev	butterlp	arev, 5000
+arev	butterlp	arev, 5000
+
+		outs		(arev + gaoutL)*koutGain, (arev + gaoutR) * koutGain
+
+        gaoutL = 0
+        gaoutR = 0		
+		gainrev	=	0
+		
+endin
+
+/****************************************************************
+Audio input recording
+****************************************************************/
+instr 201
+
+ain inch 1
+itable = 300 + p4
+aindex line 0, p3, 1
+kenv   adsr     0.005, 0.05, .9, 0.01
+tabw  ain*kenv, aindex, itable, 1
+endin
+
+/****************************************************************
+Soundfile player with tied notes
+****************************************************************/
+instr 101
+
+ipit    =   p4
+irg     =   p5
+iamp = p6
+ipan    =   p7
+itab    =   p8
+iatt    =   p9
+idecay = p10
+ifiltType = p11 - 1
+icutoff = p12
+
+idurfadein     init    0.002
+idurfadeout     init    0.098
+iampe0    	init    1                    ; FADE IN           
+iampe1    	=  	iamp				     ; SUSTAIN
+iampe2    	init    1				     ; FADE OUT
+
+itie     	tival                        ; VERIFIE SI LA NOTE EST LIEE 
+if itie  ==  1     	igoto nofadein       ; SI NON "FADE IN"
+
+idurfadein  init iatt
+iampe0    	init     0                   ; FADE IN
+iskip   =   1 
+kpitch     	init  	ipit                 ; INIT FREQUENCE POUR LES NOTES NON-LIEES
+kamp   init    iamp
+kpan        init    ipan
+krg         init    irg
+
+nofadein:
+iskip   =   0
+igliss  =   0.005
+
+if p3   < 	0       igoto nofadeout       ; VERIFIE SI LA NOTE EST TENUE, SI NON "FADE OUT"
+
+idurfadeout     init    idecay
+iampe2      init    0                     ; FADE OUT
+
+nofadeout:
+
+idelta  =   idurfadein+idurfadeout
+if idelta > abs(p3) then
+idelta = abs(p3)
+endif
+
+iampe0      =       iampe0 * iamp
+iampe2      =       iampe2 * iamp
+kenv     	linseg  iampe0, idurfadein, iampe1, abs(p3)-idelta, iampe1, idurfadeout,  iampe2		; AMPLITUDE GLOBALE
+
+; SI LA NOTE EST LIEE, ON SAUTE LE RESTE DE L'INITIALISATION
+           	tigoto  tieskip
+
+kpitch     	portk  	ipit, igliss, ipit    	             ; GLISSANDO
+kpan        portk   ipan, igliss, ipan
+krg         portk   irg, igliss, irg
+kcutoff     portk   icutoff, igliss, icutoff
+
+a1	     flooper2	1, kpitch, .25, .5, .1, itab, 0, 0, 0, iskip
+
+if ifiltType != -1 then
+acomp   =  a1
+a1      bqrez   a1, kcutoff, 6, ifiltType 
+a1      balance     a1, acomp
+endif
+
+a1      =   a1*kenv
+
+gaoutL = a1*(1-kpan)+gaoutL
+gaoutR =  a1*kpan+gaoutR
+
+gainrev	=	        a1*krg+gainrev
+
+  tieskip:                                    
+endin
+
+/********************************************************************
+soundfile player for percussion - resonance notes
+********************************************************************/
+instr 102
+
+p3      =   p3
+ipit    =   p4
+irg     =   p5
+iamp = p6
+ipan    =   p7
+itab    =   p8
+iatt    =   p9
+idecay = p10
+ifiltType = p11 - 1
+icutoff = p12
+
+a1	 flooper2	1, ipit, .25, .750, .2, itab
+
+if ifiltType != -1 then
+acomp   =   a1
+a1      bqrez   a1, icutoff, 6, ifiltType 
+a1      balance     a1, acomp
+endif
+
+kenv    expseg  0.001, .003, .6, p3 - .003, 0.001
+klocalenv   adsr     iatt, 0.05, .8, idecay
+
+a1      =   a1*kenv*klocalenv
+
+gaoutL = a1*(1-ipan)+gaoutL
+gaoutR = a1*ipan+gaoutR
+
+gainrev	=	    a1*irg+gainrev
+
+endin 
+
+/***********************************************************************
+Simple soundfile player
+***********************************************************************/
+instr 103
+
+ipit    =   p4
+irg     =   p5
+iamp = p6
+ipan    =   p7
+itab    =   p8
+p3      =   nsamp(itab) * 0.00002268
+iatt    =   p9
+idecay = p10
+ifiltType = p11-1
+icutoff = p12
+
+a1      loscil  iamp, ipit, itab, 1
+
+if ifiltType != -1 then
+acomp = a1
+a1      bqrez   a1, icutoff, 6, ifiltType 
+a1      balance     a1, acomp
+endif
+
+kenv   adsr     iatt, 0.05, .8, idecay
+
+a1  =   a1*kenv
+
+gaoutL = a1*(1-ipan)+gaoutL
+gaoutR = a1*ipan+gaoutR
+
+gainrev =	    a1*irg+gainrev
+
+endin 
+
+/******************************************************************** 
+soundfile simple crossfade player 
+********************************************************************/
+instr 104
+
+ipit    =   p4
+irg     =   p5
+iamp = p6
+ipan    =   p7
+itab    =   p8
+iatt    =   p9
+idecay = p10
+
+a1	 flooper2    1, ipit, .25, .750, .2, itab
+a2      =   a1
+
+kenv   adsr     iatt, 0.05, .8, idecay
+
+gaoutL = a1*kenv*iamp*(1-ipan)+gaoutL
+gaoutR = a2*kenv*iamp*ipan+gaoutR
+
+gainrev	=       (a1+a2)*irg*kenv*.5*iamp+gainrev
+
+endin 
+
+
+/********************************************************************* 
+simple karplus-strong plucked string 
+*********************************************************************/
+instr 105
+
+p3      =   p3+1
+ipit    =   p4
+irg     =   p5
+iamp = p6
+ipan    =   p7
+itab    =   p8
+iatt    =   p9
+idecay = p10
+
+icps    = 261.626 * ipit
+
+a1      pluck   20000, icps, icps, 0, 5, .495, .495
+a1      butterlp a1, 4000
+a2      =   a1
+
+kenv   adsr     iatt, 0.05, .8, idecay
+
+gaoutL = a1*kenv*iamp*(1-ipan)+gaoutL
+gaoutR = a2*kenv*iamp*ipan+gaoutR
+
+gainrev =	    (a1+a2)*irg*kenv*.5*iamp+gainrev
+
+endin 
+
+/********************************************************************** 
+FM synth instrument 
+**********************************************************************/
+instr 106
+
+ipit    =   p4
+irg     =   p5
+iamp = p6
+ipan    =   p7
+itab    =   p8
+iatt    =   p9
+idecay = p10
+
+kModDev randomi 0.995, 1.005, .45
+kFondDev    randomi 0.9962, 1.0029, .93
+kvibrato    vibrato .5, 5, 0.08, 0.5, 3, 5, 3, 5, 1
+
+iImin   =   2
+iImax   =   4
+iamp    =   3000
+kfond   =   261.626 * ipit * kFondDev + kvibrato
+kformant    =   800
+kPortFreq   =   kfond * 3
+kModFreq    =   kfond * 2 * kModDev
+kModFreq2   =   kfond * 2.001 * kModDev
+kPortFreq2  =   int((kformant/kPortFreq) + 0.5) * kfond
+
+kenv1   expseg  0.001, .05, iamp, p3 - .15, iamp, .1, 0.001 
+kenv2   oscil1i  0, kModFreq*(iImax-iImin), p3, 44
+
+amod    oscili  iImin*kModFreq+kenv2, kModFreq, 1
+amod2   oscili  iImin*kModFreq2+kenv2, kModFreq2, 1 
+
+aport1  oscili  kenv1, kPortFreq+amod+amod2, 1
+aport2  oscili  kenv1*0.5, kPortFreq2+(amod*0.33), 1
+
+a1    =   aport1+aport2
+a2      =   a1
+
+kenv   adsr     iatt, 0.05, .8, idecay
+
+gaoutL = a1*kenv*iamp*(1-ipan)+gaoutL
+gaoutR = a2*kenv*iamp*ipan+gaoutR
+
+gainrev =	    (a1+a2)*irg*kenv*iamp+gainrev
+
+    endin
+
+/********************************************************************** 
+Waveshaping instrument 
+**********************************************************************/
+instr 107
+
+ipit    =   p4 * 261.626
+irg     =   p5
+iamp = p6
+ipan    =   p7
+itab    =   p8
+iatt    =   p9
+idecay = p10
+
+kvib	vibr	2, 5, 53
+kamp	line	.42, p3, .1
+kampdev	randi	.07, .5, .666
+
+asig	oscili	kamp+kampdev, ipit+kvib, 50
+
+a1	table	asig, 51, 1, .5
+a1  balance a1, asig
+a1 = a1*10000
+a2      delay   a1, .041
+
+kenv   adsr     iatt, 0.05, .8, idecay
+
+gaoutL = a1*kenv*iamp*(1-ipan)+gaoutL
+gaoutR = a2*kenv*iamp*ipan+gaoutR
+
+gainrev =	    (a1+a2)*irg*kenv*iamp+gainrev
+
+endin
+
+
+/**************************************************************************
+ General Soundfile Player - Used by Memosono
+**************************************************************************/
+
+
+instr 108
+/* soundfile play control
+  p4 : filename
+  p5 : unique instance ID
+  p6 : output gain (0-1)
+  p7 : udp send gain (0-1)
+  p8 : offset in seconds
+
+  channels:
+  sfplay.<ID>.on  - instance control channel (1:on 0: off)
+  sfplay.<ID>.gain - soundfile play gain (0-1)
+  sfplay.<ID>.udpgain - udp send gain (0-1)
+  sfplay.<ID>.flen  - holds the channel length
+*/
+S1 strget p4
+inst = p5
+ich    filenchnls S1
+iln    filelen  S1
+ioffset = p8
+
+Slen  sprintf "sfplay.%d.flen", p5  ; file length channel
+chnset iln, Slen
+
+if ioffset >= iln then
+turnoff
+else
+iln = iln - ioffset
+endif
+
+Splay sprintf "sfplay.%d.on", inst  ; instance control channel
+Sname sprintf "sfplay.%d.fname", inst  ; filename channel
+Sgain sprintf "sfplay.%d.gain", inst ; gain channel
+Sudp  sprintf "sfplay.%d.udpgain", inst ; udp gain channel  
+chnset S1, Sname
+chnset 1,  Splay
+chnset p6, Sgain
+chnset p7, Sudp
+event_i "i",109,0,iln,inst,ich,ioffset
+turnoff
+endin
+
+
+instr 109
+/* soundfile player
+  This is the actual soundfile player.
+  It never gets called directly
+*/
+ich = p5
+inst= p4
+ioffset = p6
+Splay sprintf "sfplay.%d.on", inst  ; instance control channel
+Sname sprintf "sfplay.%d.fname", inst  ; filename channel
+Sgain sprintf "sfplay.%d.gain", inst ; gain channel
+Sudp  sprintf "sfplay.%d.udpgain", inst ; udp gain channel   
+kon chnget Splay
+kg1 chnget Sgain
+kg2 chnget Sudp
+S1  chnget Sname
+if kon == 0 then
+printf "sfplay:%d OFF\n", 1, inst
+turnoff
+endif
+if ich = 1 then
+a1 diskin2 S1,1,ioffset,1
+a2 = a1
+else
+a1,a2 diskin2 S1,1,ioffset,1
+endif
+     outs a1*kg1, a2*kg1
+gaudp1 = a1*kg2 + gaudp1
+gaudp2 = a2*kg2 + gaudp2
+printf_i "sfplay:%d\n", 1, inst
+endin
+
+
+
+/**************************************************************************
+UDP receiver
+**************************************************************************/
+
+instr 256
+gaudp1 = 0
+gaudp2 = 0
+a1 = 0
+outs a1, a1
+endin 
+
+</CsInstruments>
+<CsScore>
+f1 0 8192 10 1
+f40 0 1024 10 1 0  .5 0 0 .3  0 0 .2 0 .1 0 0 0 0 .2 0 0 0 .05 0 0 0 0 .03 ; ADDITIVE SYNTHESIS WAVE
+f41 0 8193 19 .5 .5 270 .5 ; SIGMOID FUNCTION
+f44 0 8192 5 1 8192 0.001 ; EXPONENTIAL FUNCTION
+f50 0 8192 10 1 .1 .005 ; forme d'onde de l'index
+f51 0 8192 13 1 1 0 1 .7 .8 .3 .1 .3 .4 .3 .2 0 0 .2 .1 0 .6 0 0 .5 .4 .3 0 0 .6 .7 ; premiere fonction de Chebichev
+f52 0 4096 4 51 1 ; table de correction d'amplitude
+f53 0 512 10 1 ; VIBRATO WAVE
+
+i256 0 600000
+i200 0 600000
+
+</CsScore>
+</CsoundSynthesizer>