path: root/csserver/csnd.py

# 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)