csound.h

Go to the documentation of this file.

/*
    csound.h:

    Copyright (C) 2003 2005 2008 2013 by John ffitch, Istvan Varga,
                                         Mike Gogins, Victor Lazzarini,
                                         Andres Cabrera, Steven Yi

    This file is part of Csound.

    The Csound Library is free software; you can redistribute it
    and/or modify it under the terms of the GNU Lesser General Public
    License as published by the Free Software Foundation; either
    version 2.1 of the License, or (at your option) any later version.

    Csound is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser General Public
    License along with Csound; if not, write to the Free Software
    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
    02110-1301 USA
*/

#ifndef CSOUND_H
#define CSOUND_H

/*
 * Platform-dependent definitions and declarations.
 */

#if (defined(WIN32) || defined(_WIN32)) && !defined(SWIG)
#  if defined(__BUILDING_LIBCSOUND)
#    define PUBLIC          __declspec(dllexport)
#    define PUBLIC_DATA     __declspec(dllexport)
#  else
#    define PUBLIC          __declspec(dllexport)
#    define PUBLIC_DATA     __declspec(dllimport)
#  endif
#elif defined(__GNUC__) && (__GNUC__ >= 4) /* && !defined(__MACH__) */
#  define PUBLIC            __attribute__ ( (visibility("default")) )
#  define PUBLIC_DATA       __attribute__ ( (visibility("default")) )
#else
#  define PUBLIC
#  define PUBLIC_DATA
#endif

#if defined(MSVC)
#  include <intrin.h> /* for _InterlockedExchange */
#endif

#if defined(__MACH__)
// on OSX 10.6 i386 does not have all builtins
#if defined(MAC_OS_X_VERSION_10_6)
#ifdef HAVE_ATOMIC_BUILTIN
#ifndef __x86_64__
#undef HAVE_ATOMIC_BUILTIN
#endif
#endif
#endif
#endif

#ifdef SWIG
#define CS_PRINTF2
#define CS_PRINTF3
#include "float-version.h"
#ifndef __MYFLT_DEF
#define __MYFLT_DEF
#ifndef USE_DOUBLE
#define MYFLT float
#else
#define MYFLT double
#endif
#endif
  %module csnd6
  %{
#  include "sysdep.h"
#  include "text.h"
#  include <stdarg.h>
      %}
#else
#  include "sysdep.h"
#  include "text.h"
#  include <stdarg.h>
#endif

#ifdef __cplusplus
extern "C" {
#endif

  typedef enum
    {
      /* Completed successfully. */
      CSOUND_SUCCESS = 0,
      /* Unspecified failure. */
      CSOUND_ERROR = -1,
      /* Failed during initialization. */
      CSOUND_INITIALIZATION = -2,
      /* Failed during performance. */
      CSOUND_PERFORMANCE = -3,
      /* Failed to allocate requested memory. */
      CSOUND_MEMORY = -4,
      /* Termination requested by SIGINT or SIGTERM. */
      CSOUND_SIGNAL = -5
    } CSOUND_STATUS;

  /* Compilation or performance aborted, but not as a result of an error
     (e.g. --help, or running an utility with -U). */
#define CSOUND_EXITJMP_SUCCESS  (256)

#define CSOUNDINIT_NO_SIGNAL_HANDLER  1
#define CSOUNDINIT_NO_ATEXIT          2

#define CSOUND_CALLBACK_KBD_EVENT   (0x00000001U)
#define CSOUND_CALLBACK_KBD_TEXT    (0x00000002U)

  typedef enum {
    CSFTYPE_UNIFIED_CSD = 1,   /* Unified Csound document */
    CSFTYPE_ORCHESTRA,         /* the primary orc file (may be temporary) */
    CSFTYPE_SCORE,             /* the primary sco file (may be temporary)
                                  or any additional score opened by Cscore */
    CSFTYPE_ORC_INCLUDE,       /* a file #included by the orchestra */
    CSFTYPE_SCO_INCLUDE,       /* a file #included by the score */
    CSFTYPE_SCORE_OUT,         /* used for score.srt, score.xtr, cscore.out */
    CSFTYPE_SCOT,              /* Scot score input format */
    CSFTYPE_OPTIONS,           /* for .csoundrc and -@ flag */
    CSFTYPE_EXTRACT_PARMS,     /* extraction file specified by -x */

    /* audio file types that Csound can write (10-19) or read */
    CSFTYPE_RAW_AUDIO,
    CSFTYPE_IRCAM,
    CSFTYPE_AIFF,
    CSFTYPE_AIFC,
    CSFTYPE_WAVE,
    CSFTYPE_AU,
    CSFTYPE_SD2,
    CSFTYPE_W64,
    CSFTYPE_WAVEX,
    CSFTYPE_FLAC,
    CSFTYPE_CAF,
    CSFTYPE_WVE,
    CSFTYPE_OGG,
    CSFTYPE_MPC2K,
    CSFTYPE_RF64,
    CSFTYPE_AVR,
    CSFTYPE_HTK,
    CSFTYPE_MAT4,
    CSFTYPE_MAT5,
    CSFTYPE_NIST,
    CSFTYPE_PAF,
    CSFTYPE_PVF,
    CSFTYPE_SDS,
    CSFTYPE_SVX,
    CSFTYPE_VOC,
    CSFTYPE_XI,
    CSFTYPE_UNKNOWN_AUDIO,     /* used when opening audio file for reading
                                  or temp file written with <CsSampleB> */

    /* miscellaneous music formats */
    CSFTYPE_SOUNDFONT,
    CSFTYPE_STD_MIDI,          /* Standard MIDI file */
    CSFTYPE_MIDI_SYSEX,        /* Raw MIDI codes, eg. SysEx dump */

    /* analysis formats */
    CSFTYPE_HETRO,
    CSFTYPE_HETROT,
    CSFTYPE_PVC,               /* original PVOC format */
    CSFTYPE_PVCEX,             /* PVOC-EX format */
    CSFTYPE_CVANAL,
    CSFTYPE_LPC,
    CSFTYPE_ATS,
    CSFTYPE_LORIS,
    CSFTYPE_SDIF,
    CSFTYPE_HRTF,

    /* Types for plugins and the files they read/write */
    CSFTYPE_UNUSED,
    CSFTYPE_LADSPA_PLUGIN,
    CSFTYPE_SNAPSHOT,

    /* Special formats for Csound ftables or scanned synthesis
       matrices with header info */
    CSFTYPE_FTABLES_TEXT,        /* for ftsave and ftload  */
    CSFTYPE_FTABLES_BINARY,      /* for ftsave and ftload  */
    CSFTYPE_XSCANU_MATRIX,       /* for xscanu opcode  */

    /* These are for raw lists of numbers without header info */
    CSFTYPE_FLOATS_TEXT,         /* used by GEN23, GEN28, dumpk, readk */
    CSFTYPE_FLOATS_BINARY,       /* used by dumpk, readk, etc. */
    CSFTYPE_INTEGER_TEXT,        /* used by dumpk, readk, etc. */
    CSFTYPE_INTEGER_BINARY,      /* used by dumpk, readk, etc. */

    /* image file formats */
    CSFTYPE_IMAGE_PNG,

    /* For files that don't match any of the above */
    CSFTYPE_POSTSCRIPT,          /* EPS format used by graphs */
    CSFTYPE_SCRIPT_TEXT,         /* executable script files (eg. Python) */
    CSFTYPE_OTHER_TEXT,
    CSFTYPE_OTHER_BINARY,

    /* This should only be used internally by the original FileOpen()
       API call or for temp files written with <CsFileB> */
    CSFTYPE_UNKNOWN = 0
  } CSOUND_FILETYPES;

  /*
   * TYPE DEFINITIONS
   */

  /*
   * Forward declarations.
   */

  typedef struct CSOUND_  CSOUND;
  typedef struct windat_  WINDAT;
  typedef struct xyindat_ XYINDAT;


  typedef struct {
    int     debug_mode;     /* debug mode, 0 or 1 */
    int     buffer_frames;  /* number of frames in in/out buffers */
    int     hardware_buffer_frames; /* ibid. hardware */
    int     displays;       /* graph displays, 0 or 1 */
    int     ascii_graphs;   /* use ASCII graphs, 0 or 1 */
    int     postscript_graphs; /* use postscript graphs, 0 or 1 */
    int     message_level;     /* message printout control */
    int     tempo;             /* tempo (sets Beatmode)  */
    int     ring_bell;         /* bell, 0 or 1 */
    int     use_cscore;        /* use cscore for processing */
    int     terminate_on_midi; /* terminate performance at the end
                                  of midifile, 0 or 1 */
    int     heartbeat;         /* print heart beat, 0 or 1 */
    int     defer_gen01_load ;  /* defer GEN01 load, 0 or 1 */
    int     midi_key;           /* pfield to map midi key no */
    int     midi_key_cps;       /* pfield to map midi key no as cps */
    int     midi_key_oct;       /* pfield to map midi key no as oct */
    int     midi_key_pch;       /* pfield to map midi key no as pch */
    int     midi_velocity;      /* pfield to map midi velocity */
    int     midi_velocity_amp;   /* pfield to map midi velocity as amplitude */
    int     no_default_paths;     /* disable relative paths from files, 0 or 1 */
    int     number_of_threads;   /* number of threads for multicore performance */
    int     syntax_check_only;   /* do not compile, only check syntax */
    int     csd_line_counts;     /* csd line error reporting */
    int     compute_weights;     /* deprecated, kept for backwards comp.  */
    int     realtime_mode;       /* use realtime priority mode, 0 or 1 */
    int     sample_accurate;     /* use sample-level score event accuracy */
    MYFLT   sample_rate_override; /* overriding sample rate */
    MYFLT   control_rate_override; /* overriding control rate */
    int     nchnls_override;  /* overriding number of out channels */
    int     nchnls_i_override;  /* overriding number of in channels */
    MYFLT   e0dbfs_override;   /* overriding 0dbfs */
    int     daemon;  /* daemon mode */
    int     ksmps_override; /* ksmps override */
    int     FFT_library;    /* fft_lib */
  } CSOUND_PARAMS;

  typedef struct {
    char device_name[64];
    char device_id[64];
    char rt_module[64];
    int max_nchnls;
    int isOutput;
  } CS_AUDIODEVICE;

  typedef struct {
    char device_name[64];
    char interface_name[64];
    char device_id[64];
    char midi_module[64];
    int isOutput;
  } CS_MIDIDEVICE;


  typedef struct {
    char    *devName;
    int     devNum;
    unsigned int     bufSamp_SW;
    int     bufSamp_HW;
    int     nChannels;
    int     sampleFormat;
    float   sampleRate;
  } csRtAudioParams;

  typedef struct RTCLOCK_S {
    int_least64_t   starttime_real;
    int_least64_t   starttime_CPU;
  } RTCLOCK;

  typedef struct {
    char        *opname;
    char        *outypes;
    char        *intypes;
    int         flags;
  } opcodeListEntry;

  typedef struct CsoundRandMTState_ {
    int         mti;
    uint32_t    mt[624];
  } CsoundRandMTState;

  /* PVSDATEXT is a variation on PVSDAT used in
     the pvs bus interface */
  typedef struct pvsdat_ext {
    int32           N;
    int             sliding; /* Flag to indicate sliding case */
    int32           NB;
    int32           overlap;
    int32           winsize;
    int             wintype;
    int32           format;
    uint32          framecount;
    float*          frame;
  } PVSDATEXT;

  typedef struct ORCTOKEN {
    int              type;
    char             *lexeme;
    int              value;
    double           fvalue;
    char             *optype;
    struct ORCTOKEN  *next;
  } ORCTOKEN;

  typedef struct TREE {
    int           type;
    ORCTOKEN      *value;
    int           rate;
    int           len;
    int           line;
    uint64_t      locn;
    struct TREE   *left;
    struct TREE   *right;
    struct TREE   *next;
    void          *markup;  // TEMPORARY - used by semantic checker to
    // markup node adds OENTRY or synthetic var
    // names to expression nodes should be moved
    // to TYPE_TABLE
  } TREE;


  typedef enum {
    CSOUND_CONTROL_CHANNEL =     1,
    CSOUND_AUDIO_CHANNEL  =      2,
    CSOUND_STRING_CHANNEL =      3,
    CSOUND_PVS_CHANNEL =      4,
    CSOUND_VAR_CHANNEL =      5,

    CSOUND_CHANNEL_TYPE_MASK =    15,

    CSOUND_INPUT_CHANNEL =       16,
    CSOUND_OUTPUT_CHANNEL =       32
  } controlChannelType;

  typedef enum {
    CSOUND_CONTROL_CHANNEL_NO_HINTS  = 0,
    CSOUND_CONTROL_CHANNEL_INT  = 1,
    CSOUND_CONTROL_CHANNEL_LIN  = 2,
    CSOUND_CONTROL_CHANNEL_EXP  = 3
  } controlChannelBehavior;

  typedef struct controlChannelHints_s {
    controlChannelBehavior    behav;

    MYFLT   dflt;
    MYFLT   min;
    MYFLT   max;
    int x;
    int y;
    int width;
    int height;
    char *attributes;
  } controlChannelHints_t;

  typedef struct controlChannelInfo_s {
    char  *name;
    int     type;
    controlChannelHints_t    hints;
  } controlChannelInfo_t;

  typedef void (*channelCallback_t)(CSOUND *csound,
                                    const char *channelName,
                                    void *channelValuePtr,
                                    const void *channelType);

#ifndef CSOUND_CSDL_H

  PUBLIC int csoundInitialize(int flags);

  PUBLIC void csoundSetOpcodedir(const char *s);

  PUBLIC CSOUND *csoundCreate(void *hostData);

  PUBLIC int csoundLoadPlugins(CSOUND *csound, const char *dir);

  PUBLIC void csoundDestroy(CSOUND *);

  PUBLIC int csoundGetVersion(void);

  PUBLIC int csoundGetAPIVersion(void);


  PUBLIC TREE *csoundParseOrc(CSOUND *csound, const char *str);

  PUBLIC int csoundCompileTree(CSOUND *csound, TREE *root);

  PUBLIC int csoundCompileTreeAsync(CSOUND *csound, TREE *root);


  PUBLIC void csoundDeleteTree(CSOUND *csound, TREE *tree);

  PUBLIC int csoundCompileOrc(CSOUND *csound, const char *str);

  PUBLIC int csoundCompileOrcAsync(CSOUND *csound, const char *str);

  PUBLIC MYFLT csoundEvalCode(CSOUND *csound, const char *str);

  PUBLIC int csoundInitializeCscore(CSOUND *, FILE *insco, FILE *outsco);

  PUBLIC int csoundCompileArgs(CSOUND *, int argc, const char **argv);

  PUBLIC int csoundStart(CSOUND *csound);

  PUBLIC int csoundCompile(CSOUND *, int argc, const char **argv);

  PUBLIC int csoundCompileCsd(CSOUND *csound, const char *csd_filename);

  PUBLIC int csoundCompileCsdText(CSOUND *csound, const char *csd_text);

  PUBLIC int csoundPerform(CSOUND *);

  PUBLIC int csoundPerformKsmps(CSOUND *);

  PUBLIC int csoundPerformBuffer(CSOUND *);

  PUBLIC void csoundStop(CSOUND *);

  PUBLIC int csoundCleanup(CSOUND *);

  PUBLIC void csoundReset(CSOUND *);

  PUBLIC int csoundUDPServerStart(CSOUND *csound, unsigned int port);

  PUBLIC int csoundUDPServerStatus(CSOUND *csound);

  PUBLIC int csoundUDPServerClose(CSOUND *csound);

  PUBLIC int csoundUDPConsole(CSOUND *csound, const char *addr,
                              int port, int mirror);

  PUBLIC void csoundStopUDPConsole(CSOUND *csound);

  PUBLIC MYFLT csoundGetSr(CSOUND *) ;

  PUBLIC MYFLT csoundGetKr(CSOUND *);

  PUBLIC uint32_t csoundGetKsmps(CSOUND *);

  PUBLIC uint32_t csoundGetNchnls(CSOUND *);

  PUBLIC uint32_t csoundGetNchnlsInput(CSOUND *csound);

  PUBLIC MYFLT csoundGet0dBFS(CSOUND *);

  PUBLIC MYFLT csoundGetA4(CSOUND *);

  PUBLIC int64_t csoundGetCurrentTimeSamples(CSOUND *csound);

  PUBLIC int csoundGetSizeOfMYFLT(void);

  PUBLIC void *csoundGetHostData(CSOUND *);

  PUBLIC void csoundSetHostData(CSOUND *, void *hostData);

  PUBLIC int csoundSetOption(CSOUND *csound, const char *option);

  PUBLIC void csoundSetParams(CSOUND *csound, CSOUND_PARAMS *p);

  PUBLIC void csoundGetParams(CSOUND *csound, CSOUND_PARAMS *p);

  PUBLIC int csoundGetDebug(CSOUND *);

  PUBLIC void csoundSetDebug(CSOUND *, int debug);

  PUBLIC MYFLT csoundSystemSr(CSOUND *csound, MYFLT val);


  PUBLIC const char *csoundGetOutputName(CSOUND *);

  PUBLIC const char *csoundGetInputName(CSOUND *);

  PUBLIC void csoundSetOutput(CSOUND *csound, const char *name,
                              const char *type, const char *format);

  PUBLIC void csoundGetOutputFormat(CSOUND *csound,char *type,
                                    char *format);

  PUBLIC void csoundSetInput(CSOUND *csound, const char *name);

  PUBLIC void csoundSetMIDIInput(CSOUND *csound, const char *name);

  PUBLIC void csoundSetMIDIFileInput(CSOUND *csound, const char *name);

  PUBLIC void csoundSetMIDIOutput(CSOUND *csound, const char *name);

  PUBLIC void csoundSetMIDIFileOutput(CSOUND *csound, const char *name);

#if !defined(SWIG)

  PUBLIC void csoundSetFileOpenCallback(CSOUND *p,
                                        void (*func)(CSOUND*, const char*,
                                                     int, int, int));
#endif

  PUBLIC void csoundSetRTAudioModule(CSOUND *csound, const char *module);

  PUBLIC int csoundGetModule(CSOUND *csound, int number,
                             char **name, char **type);

  PUBLIC long csoundGetInputBufferSize(CSOUND *);

  PUBLIC long csoundGetOutputBufferSize(CSOUND *);

  PUBLIC MYFLT *csoundGetInputBuffer(CSOUND *);

  PUBLIC MYFLT *csoundGetOutputBuffer(CSOUND *);

  PUBLIC MYFLT *csoundGetSpin(CSOUND *);

  PUBLIC void csoundClearSpin(CSOUND *);

  PUBLIC void csoundAddSpinSample(CSOUND *csound,
                                  int frame, int channel, MYFLT sample);

  PUBLIC void csoundSetSpinSample(CSOUND *csound,
                                  int frame, int channel, MYFLT sample);

  PUBLIC MYFLT *csoundGetSpout(CSOUND *csound);

  PUBLIC MYFLT csoundGetSpoutSample(CSOUND *csound, int frame, int channel);

  PUBLIC void **csoundGetRtRecordUserData(CSOUND *);

  PUBLIC void **csoundGetRtPlayUserData(CSOUND *);

  PUBLIC void csoundSetHostImplementedAudioIO(CSOUND *,
                                              int state, int bufSize);


  PUBLIC int csoundGetAudioDevList(CSOUND *csound,
                                   CS_AUDIODEVICE *list, int isOutput);

  PUBLIC void
  csoundSetPlayopenCallback(CSOUND *,
                            int (*playopen__)(CSOUND *,
                                              const csRtAudioParams *parm));

  PUBLIC void csoundSetRtplayCallback(CSOUND *,
                                      void (*rtplay__)(CSOUND *,
                                                       const MYFLT *outBuf,
                                                       int nbytes));

  PUBLIC void csoundSetRecopenCallback(CSOUND *,
                                     int (*recopen_)(CSOUND *,
                                                     const csRtAudioParams *parm));

  PUBLIC void csoundSetRtrecordCallback(CSOUND *,
                                        int (*rtrecord__)(CSOUND *,
                                                          MYFLT *inBuf,
                                                          int nbytes));

  PUBLIC void csoundSetRtcloseCallback(CSOUND *, void (*rtclose__)(CSOUND *));

  PUBLIC void csoundSetAudioDeviceListCallback(CSOUND *csound,
                                               int (*audiodevlist__)(CSOUND *,
                                                   CS_AUDIODEVICE *list,
                                                   int isOutput));

  PUBLIC void csoundSetMIDIModule(CSOUND *csound, const char *module);

  PUBLIC void csoundSetHostImplementedMIDIIO(CSOUND *csound,
                                             int state);

  PUBLIC int csoundGetMIDIDevList(CSOUND *csound,
                                  CS_MIDIDEVICE *list, int isOutput);

  PUBLIC void csoundSetExternalMidiInOpenCallback(CSOUND *,
                                                  int (*func)(CSOUND *,
                                                              void **userData,
                                                              const char *devName));

  PUBLIC void csoundSetExternalMidiReadCallback(CSOUND *,
                                                int (*func)(CSOUND *,
                                                            void *userData,
                                                            unsigned char *buf,
                                                            int nBytes));

  PUBLIC void csoundSetExternalMidiInCloseCallback(CSOUND *,
                                                   int (*func)(CSOUND *,
                                                               void *userData));

  PUBLIC void csoundSetExternalMidiOutOpenCallback(CSOUND *,
                                                   int (*func)(CSOUND *,
                                                               void **userData,
                                                               const char *devName));

  PUBLIC void csoundSetExternalMidiWriteCallback(CSOUND *,
                                              int (*func)(CSOUND *,
                                                          void *userData,
                                                          const unsigned char *buf,
                                                          int nBytes));

  PUBLIC void csoundSetExternalMidiOutCloseCallback(CSOUND *,
                                                    int (*func)(CSOUND *,
                                                                void *userData));

  PUBLIC void csoundSetExternalMidiErrorStringCallback(CSOUND *,
                                                       const char *(*func)(int));


  PUBLIC void csoundSetMIDIDeviceListCallback(CSOUND *csound,
                                              int (*mididevlist__)(CSOUND *,
                                                              CS_MIDIDEVICE *list,
                                                              int isOutput));

  PUBLIC int csoundReadScore(CSOUND *csound, const char *str);

  PUBLIC void csoundReadScoreAsync(CSOUND *csound, const char *str);

  PUBLIC double csoundGetScoreTime(CSOUND *);

  PUBLIC int csoundIsScorePending(CSOUND *);

  PUBLIC void csoundSetScorePending(CSOUND *, int pending);

  PUBLIC MYFLT csoundGetScoreOffsetSeconds(CSOUND *);

  PUBLIC void csoundSetScoreOffsetSeconds(CSOUND *, MYFLT time);

  PUBLIC void csoundRewindScore(CSOUND *);

  PUBLIC void csoundSetCscoreCallback(CSOUND *,
                                      void (*cscoreCallback_)(CSOUND *));

  PUBLIC int csoundScoreSort(CSOUND *, FILE *inFile, FILE *outFile);

  PUBLIC int csoundScoreExtract(CSOUND *,
                                FILE *inFile, FILE *outFile, FILE *extractFile);

  PUBLIC CS_PRINTF2 void csoundMessage(CSOUND *, const char *format, ...);

  PUBLIC CS_PRINTF3 void csoundMessageS(CSOUND *,
                                        int attr, const char *format, ...);

  PUBLIC void csoundMessageV(CSOUND *,
                             int attr, const char *format, va_list args);

  PUBLIC void csoundSetDefaultMessageCallback(void (*csoundMessageCallback_)(
                                           CSOUND *,
                                           int attr,
                                           const char *format,
                                           va_list valist));

  PUBLIC void csoundSetMessageCallback(CSOUND *,
                                   void (*csoundMessageCallback_)(CSOUND *,
                                                                  int attr,
                                                                  const char *format,
                                                                  va_list valist));

  PUBLIC void csoundSetMessageStringCallback(CSOUND *csound,
              void (*csoundMessageStrCallback)(CSOUND *csound,
                                               int attr,
                                               const char *str));

  PUBLIC int csoundGetMessageLevel(CSOUND *);

  PUBLIC void csoundSetMessageLevel(CSOUND *, int messageLevel);

  PUBLIC void csoundCreateMessageBuffer(CSOUND *csound, int toStdOut);

  PUBLIC const char*  csoundGetFirstMessage(CSOUND *csound);

  PUBLIC int csoundGetFirstMessageAttr(CSOUND *csound);

  PUBLIC void csoundPopFirstMessage(CSOUND *csound);

  PUBLIC int csoundGetMessageCnt(CSOUND *csound);

  void PUBLIC csoundDestroyMessageBuffer(CSOUND *csound);

  PUBLIC int csoundGetChannelPtr(CSOUND *,
                                 MYFLT **p, const char *name, int type);

  PUBLIC int csoundListChannels(CSOUND *, controlChannelInfo_t **lst);

  PUBLIC void csoundDeleteChannelList(CSOUND *, controlChannelInfo_t *lst);

  PUBLIC int csoundSetControlChannelHints(CSOUND *, const char *name,
                                          controlChannelHints_t hints);

  PUBLIC int csoundGetControlChannelHints(CSOUND *, const char *name,
                                          controlChannelHints_t *hints);

  PUBLIC int *csoundGetChannelLock(CSOUND *, const char *name);

  PUBLIC MYFLT csoundGetControlChannel(CSOUND *csound, const char *name,
                                       int *err);

  PUBLIC void csoundSetControlChannel(CSOUND *csound,
                                      const char *name, MYFLT val);

  PUBLIC void csoundGetAudioChannel(CSOUND *csound,
                                    const char *name, MYFLT *samples);

  PUBLIC void csoundSetAudioChannel(CSOUND *csound,
                                    const char *name, MYFLT *samples);

  PUBLIC void csoundGetStringChannel(CSOUND *csound,
                                     const char *name, char *string);

  PUBLIC  void csoundSetStringChannel(CSOUND *csound,
                                      const char *name, char *string);

  PUBLIC int csoundGetChannelDatasize(CSOUND *csound, const char *name);

  PUBLIC void
  csoundSetInputChannelCallback(CSOUND *csound,
                                channelCallback_t inputChannelCalback);

  PUBLIC void
  csoundSetOutputChannelCallback(CSOUND *csound,
                                 channelCallback_t outputChannelCalback);

  PUBLIC int csoundSetPvsChannel(CSOUND *, const PVSDATEXT *fin,
                                 const char *name);

  PUBLIC int csoundGetPvsChannel(CSOUND *csound, PVSDATEXT *fout,
                                 const char *name);

  PUBLIC int csoundScoreEvent(CSOUND *,
                              char type, const MYFLT *pFields, long numFields);

  PUBLIC void csoundScoreEventAsync(CSOUND *,
                              char type, const MYFLT *pFields, long numFields);

  PUBLIC int csoundScoreEventAbsolute(CSOUND *,
                 char type, const MYFLT *pfields, long numFields, double time_ofs);

  PUBLIC void csoundScoreEventAbsoluteAsync(CSOUND *,
                 char type, const MYFLT *pfields, long numFields, double time_ofs);
  PUBLIC void csoundInputMessage(CSOUND *, const char *message);

  PUBLIC void csoundInputMessageAsync(CSOUND *, const char *message);

  PUBLIC int csoundKillInstance(CSOUND *csound, MYFLT instr,
                                char *instrName, int mode, int allow_release);


  PUBLIC int csoundRegisterSenseEventCallback(CSOUND *,
                                              void (*func)(CSOUND *, void *),
                                              void *userData);

  PUBLIC void csoundKeyPress(CSOUND *, char c);

  PUBLIC int csoundRegisterKeyboardCallback(CSOUND *,
                                            int (*func)(void *userData, void *p,
                                                        unsigned int type),
                                            void *userData, unsigned int type);

  PUBLIC void csoundRemoveKeyboardCallback(CSOUND *csound,
                                  int (*func)(void *, void *, unsigned int));

  PUBLIC int csoundTableLength(CSOUND *, int table);

  PUBLIC MYFLT csoundTableGet(CSOUND *, int table, int index);

  PUBLIC void csoundTableSet(CSOUND *, int table, int index, MYFLT value);


  PUBLIC void csoundTableCopyOut(CSOUND *csound, int table, MYFLT *dest);

  PUBLIC void csoundTableCopyOutAsync(CSOUND *csound, int table, MYFLT *dest);
  PUBLIC void csoundTableCopyIn(CSOUND *csound, int table, MYFLT *src);

  PUBLIC void csoundTableCopyInAsync(CSOUND *csound, int table, MYFLT *src);

  PUBLIC int csoundGetTable(CSOUND *, MYFLT **tablePtr, int tableNum);

  PUBLIC int csoundGetTableArgs(CSOUND *csound, MYFLT **argsPtr, int tableNum);

  PUBLIC int csoundIsNamedGEN(CSOUND *csound, int num);

  PUBLIC void csoundGetNamedGEN(CSOUND *csound, int num, char *name, int len);

  PUBLIC int csoundSetIsGraphable(CSOUND *, int isGraphable);

  PUBLIC void csoundSetMakeGraphCallback(CSOUND *,
                           void (*makeGraphCallback_)(CSOUND *,
                                                      WINDAT *windat,
                                                      const char *name));

  PUBLIC void csoundSetDrawGraphCallback(CSOUND *,
                                         void (*drawGraphCallback_)(CSOUND *,
                                                                    WINDAT *windat));

  PUBLIC void csoundSetKillGraphCallback(CSOUND *,
                                         void (*killGraphCallback_)(CSOUND *,
                                                                    WINDAT *windat));

  PUBLIC void csoundSetExitGraphCallback(CSOUND *,
                                         int (*exitGraphCallback_)(CSOUND *));

  PUBLIC void *csoundGetNamedGens(CSOUND *);

  PUBLIC int csoundNewOpcodeList(CSOUND *, opcodeListEntry **opcodelist);

  PUBLIC void csoundDisposeOpcodeList(CSOUND *, opcodeListEntry *opcodelist);

  PUBLIC int csoundAppendOpcode(CSOUND *, const char *opname,
                                int dsblksiz, int flags, int thread,
                                const char *outypes, const char *intypes,
                                int (*iopadr)(CSOUND *, void *),
                                int (*kopadr)(CSOUND *, void *),
                                int (*aopadr)(CSOUND *, void *));

  PUBLIC void csoundSetYieldCallback(CSOUND *, int (*yieldCallback_)(CSOUND *));

  PUBLIC void *csoundCreateThread(uintptr_t (*threadRoutine)(void *),
                                  void *userdata);

  PUBLIC void *csoundGetCurrentThreadId(void);

  PUBLIC uintptr_t csoundJoinThread(void *thread);
  PUBLIC void *csoundCreateThreadLock(void);

  PUBLIC int csoundWaitThreadLock(void *lock, size_t milliseconds);

  PUBLIC void csoundWaitThreadLockNoTimeout(void *lock);

  PUBLIC void csoundNotifyThreadLock(void *lock);

  PUBLIC void csoundDestroyThreadLock(void *lock);

  PUBLIC void *csoundCreateMutex(int isRecursive);

  PUBLIC void csoundLockMutex(void *mutex_);

  PUBLIC int csoundLockMutexNoWait(void *mutex_);

  PUBLIC void csoundUnlockMutex(void *mutex_);

  PUBLIC void csoundDestroyMutex(void *mutex_);


  PUBLIC void *csoundCreateBarrier(unsigned int max);

  PUBLIC int csoundDestroyBarrier(void *barrier);

  PUBLIC int csoundWaitBarrier(void *barrier);


  PUBLIC void* csoundCreateCondVar();

  PUBLIC void csoundCondWait(void* condVar, void* mutex);

  PUBLIC void csoundCondSignal(void* condVar);

  PUBLIC void csoundDestroyCondVar(void* condVar);

  PUBLIC void csoundSleep(size_t milliseconds);

  PUBLIC int csoundSpinLockInit(spin_lock_t *spinlock);

  PUBLIC void csoundSpinLock(spin_lock_t *spinlock);

  PUBLIC int csoundSpinTryLock(spin_lock_t *spinlock);

  PUBLIC void csoundSpinUnLock(spin_lock_t *spinlock);


  PUBLIC long csoundRunCommand(const char * const *argv, int noWait);

  PUBLIC void csoundInitTimerStruct(RTCLOCK *);

  PUBLIC double csoundGetRealTime(RTCLOCK *);

  PUBLIC double csoundGetCPUTime(RTCLOCK *);

  PUBLIC uint32_t csoundGetRandomSeedFromTime(void);

  PUBLIC void csoundSetLanguage(cslanguage_t lang_code);

  PUBLIC const char *csoundGetEnv(CSOUND *csound, const char *name);

  PUBLIC int csoundSetGlobalEnv(const char *name, const char *value);

  PUBLIC int csoundCreateGlobalVariable(CSOUND *,
                                        const char *name, size_t nbytes);

  PUBLIC void *csoundQueryGlobalVariable(CSOUND *, const char *name);

  PUBLIC void *csoundQueryGlobalVariableNoCheck(CSOUND *, const char *name);

  PUBLIC int csoundDestroyGlobalVariable(CSOUND *, const char *name);

  PUBLIC int csoundRunUtility(CSOUND *, const char *name,
                              int argc, char **argv);

  PUBLIC char **csoundListUtilities(CSOUND *);

  PUBLIC void csoundDeleteUtilityList(CSOUND *, char **lst);

  PUBLIC const char *csoundGetUtilityDescription(CSOUND *,
                                                 const char *utilName);

  PUBLIC int csoundRand31(int *seedVal);

  PUBLIC void csoundSeedRandMT(CsoundRandMTState *p,
                               const uint32_t *initKey, uint32_t keyLength);

  PUBLIC uint32_t csoundRandMT(CsoundRandMTState *p);

#endif  /* !CSOUND_CSDL_H */

  /* typedefs, macros, and interface functions for configuration variables */
#include "cfgvar.h"
  /* message attribute definitions for csoundMessageS() and csoundMessageV() */
#include "msg_attr.h"
  /* macro definitions for Csound release, and API version */
#include "version.h"

  PUBLIC void *csoundCreateCircularBuffer(CSOUND *csound,
                                          int numelem, int elemsize);

  PUBLIC int csoundReadCircularBuffer(CSOUND *csound, void *circular_buffer,
                                      void *out, int items);

  PUBLIC int csoundPeekCircularBuffer(CSOUND *csound, void *circular_buffer,
                                      void *out, int items);

  PUBLIC int csoundWriteCircularBuffer(CSOUND *csound, void *p,
                                       const void *inp, int items);
  PUBLIC void csoundFlushCircularBuffer(CSOUND *csound, void *p);

  PUBLIC void csoundDestroyCircularBuffer(CSOUND *csound, void *circularbuffer);

  PUBLIC int csoundOpenLibrary(void **library, const char *libraryPath);

  PUBLIC int csoundCloseLibrary(void *library);

  PUBLIC void *csoundGetLibrarySymbol(void *library, const char *symbolName);


#ifdef SWIGPYTHON

  PUBLIC CSOUND *csoundGetInstance(int64_t obj){ return (CSOUND *)obj; }

#endif


#ifdef SOME_FINE_DAY /* these functions are now deprecated */

  PUBLIC int csoundQueryInterface(const char *name,
                                  void **iface, int *version);


  PUBLIC void csoundSetInputValueCallback(CSOUND *,
                                          void (*inputValueCalback_)(CSOUND *,
                                                         const char *channelName,
                                                         MYFLT *value));

  PUBLIC void csoundSetOutputValueCallback(CSOUND *,
                                           void (*outputValueCalback_)(CSOUND *,
                                                           const char *channelName,
                                                           MYFLT value));

  PUBLIC void csoundSetChannelIOCallback(CSOUND *,
                                         CsoundChannelIOCallback_t func);

  PUBLIC int csoundPerformKsmpsAbsolute(CSOUND *);
#endif


#ifdef __cplusplus
}
#endif

#endif  /* CSOUND_H */