CsoundUnityBridge.cs

Go to the documentation of this file.

/*
Copyright (C) 2015 Rory Walsh. 
 
This file is part of CsoundUnity: https://github.com/rorywalsh/CsoundUnity
 
This interface would not have been possible without Richard Henninger's .NET interface to the Csound API.
 
Contributors:
 
Bernt Isak Wærstad
Charles Berman
Giovanni Bedetti
Hector Centeno
NPatch
 
Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), 
to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense,
and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
 
The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
 
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR 
ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH 
THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
 
using UnityEngine;
using System;
using System.Runtime.InteropServices;
using csoundcsharp;
using System.Collections.Generic;
#if UNITY_EDITOR || UNITY_STANDALONE
using MYFLT = System.Double;
#elif UNITY_ANDROID || UNITY_IOS
using MYFLT = System.Single;
#endif
 
/*
 * CsoundUnityBridge class
 */
public class CsoundUnityBridge
{
    public IntPtr csound;
    bool compiledOk = false;
    Action onCsoundCreated;
 
    private void SetEnvironmentSettings(List<EnvironmentSettings> environmentSettings)
    {
        if (environmentSettings == null || environmentSettings.Count == 0) return;
        foreach (var env in environmentSettings)
        {
            if (env == null) continue;
            var path = env.GetPath();
            if (string.IsNullOrWhiteSpace(path)) continue;
 
            switch (Application.platform)
            {
                case RuntimePlatform.OSXEditor:
                case RuntimePlatform.OSXPlayer:
                    if (env.platform.Equals(SupportedPlatform.MacOS))
                    {
                        Debug.Log($"Setting {env.GetTypeString()} for MacOS to: {path}");
                        Csound6.NativeMethods.csoundSetGlobalEnv(env.GetTypeString(), path);
                    }
                    break;
                case RuntimePlatform.WindowsPlayer:
                case RuntimePlatform.WindowsEditor:
                    if (env.platform.Equals(SupportedPlatform.Windows))
                    {
                        Debug.Log($"Setting {env.GetTypeString()} for Windows to: {path}");
                        Csound6.NativeMethods.csoundSetGlobalEnv(env.GetTypeString(), path);
                    }
                    break;
                case RuntimePlatform.Android:
                    if (env.platform.Equals(SupportedPlatform.Android))
                    {
                        Debug.Log($"Setting {env.GetTypeString()} for Android to: {path}");
                        Csound6.NativeMethods.csoundSetGlobalEnv(env.GetTypeString(), path);
                        //Debug.Log($"baseFolder: {env.baseFolder}");
                        if (env.baseFolder.Equals(EnvironmentPathOrigin.Plugins))
                        {
                            if (onCsoundCreated == null || onCsoundCreated.GetInvocationList().Length == 0)
                            {
                                onCsoundCreated += () =>
                                {
                                    Debug.Log("Csound Force Loading Plugins!");
                                    var loaded = Csound6.NativeMethods.csoundLoadPlugins(csound, path);
                                    Debug.Log($"PLUGINS LOADED? {loaded}");
                                };
                            }
                        }
                    }
                    break;
                case RuntimePlatform.IPhonePlayer:
                    if (env.platform.Equals(SupportedPlatform.iOS))
                    {
                        Debug.Log($"Setting {env.GetTypeString()} for iOS to: {path}");
                        Csound6.NativeMethods.csoundSetGlobalEnv(env.GetTypeString(), path);
                    }
                    break;
                default:
                    break;
            }
        }
    }
 
    public CsoundUnityBridge(string csdFile, List<EnvironmentSettings> environmentSettings)
    {
        SetEnvironmentSettings(environmentSettings);
 
        // KEEP THIS FOR REFERENCE ;)
        //#if (UNITY_EDITOR_WIN || UNITY_STANDALONE_WIN)
        //        Csound6.NativeMethods.csoundSetGlobalEnv("OPCODE6DIR64", csoundDir);
        //#elif UNITY_EDITOR_OSX || UNITY_STANDALONE_OSX
        //        var opcodePath = Path.GetFullPath(Path.Combine(csoundDir, "CsoundLib64.bundle/Contents/MacOS"));
        //        //Debug.Log($"opcodePath {opcodePath} exists? " + Directory.Exists(opcodePath));
        //        Csound6.NativeMethods.csoundSetGlobalEnv("OPCODE6DIR64", opcodePath);
        //#elif UNITY_ANDROID
        //        Csound6.NativeMethods.csoundSetGlobalEnv("OPCODE6DIR64", csoundDir);
        //#endif
 
        Csound6.NativeMethods.csoundInitialize(1);
        csound = Csound6.NativeMethods.csoundCreate(System.IntPtr.Zero);
        if (csound == null)
        {
            Debug.LogError("Couldn't create Csound!");
            return;
        }
 
        Csound6.NativeMethods.csoundSetHostImplementedAudioIO(csound, 1, 0);
        Csound6.NativeMethods.csoundCreateMessageBuffer(csound, 0);
 
        Csound6.NativeMethods.csoundSetOption(csound, "-n");
        Csound6.NativeMethods.csoundSetOption(csound, "-d");
 
        var parms = GetParams();
        parms.control_rate_override = AudioSettings.outputSampleRate;
        parms.sample_rate_override = AudioSettings.outputSampleRate;
        SetParams(parms);
 
        onCsoundCreated?.Invoke();
        onCsoundCreated = null;
 
        int ret = Csound6.NativeMethods.csoundCompileCsdText(csound, csdFile);
        Csound6.NativeMethods.csoundStart(csound);
        //var res = PerformKsmps();
        //Debug.Log($"PerformKsmps: {res}");
        compiledOk = ret == 0 ? true : false;
        //Debug.Log($"CsoundCompile: {compiledOk}");
    }
 
    #region Instantiation
    
    public int LoadPlugins(string dir)
    {
        return Csound6.NativeMethods.csoundLoadPlugins(csound, dir);
    }
 
    #endregion
    public int GetVersion()
    {
        return Csound6.NativeMethods.csoundGetVersion();
    }
 
    public int GetAPIVersion()
    {
        return Csound6.NativeMethods.csoundGetAPIVersion();
    }
 
    public void StopCsound()
    {
        Csound6.NativeMethods.csoundStop(csound);
    }
 
    public void OnApplicationQuit()
    {
        StopCsound();
        //Csound6.NativeMethods.csoundCleanup(csound);
        Csound6.NativeMethods.csoundDestroyMessageBuffer(csound);
        Csound6.NativeMethods.csoundDestroy(csound);
    }
 
    public void Cleanup()
    {
        Csound6.NativeMethods.csoundCleanup(csound);
    }
 
    public void Reset()
    {
        Csound6.NativeMethods.csoundReset(csound);
    }
 
    public bool CompiledWithoutError()
    {
        return compiledOk;
    }
 
    public int CompileOrc(string orchStr)
    {
        return Csound6.NativeMethods.csoundCompileOrc(csound, orchStr);
    }
 
    public int PerformKsmps()
    {
        return Csound6.NativeMethods.csoundPerformKsmps(csound);
    }
 
    public MYFLT Get0dbfs()
    {
        return Csound6.NativeMethods.csoundGet0dBFS(csound);
    }
 
    public long GetCurrentTimeSamples()
    {
        return Csound6.NativeMethods.csoundGetCurrentTimeSamples(csound);
    }
 
    public void SendScoreEvent(string scoreEvent)
    {
        Csound6.NativeMethods.csoundInputMessage(csound, scoreEvent);
    }
 
    public void RewindScore()
    {
        Csound6.NativeMethods.csoundRewindScore(csound);
    }
 
    public void CsoundSetScoreOffsetSeconds(MYFLT value)
    {
        Csound6.NativeMethods.csoundSetScoreOffsetSeconds(csound, value);
    }
 
    public void SetChannel(string channel, MYFLT value)
    {
        Csound6.NativeMethods.csoundSetControlChannel(csound, channel, value);
    }
 
    public void SetStringChannel(string channel, string value)
    {
        Csound6.NativeMethods.csoundSetStringChannel(csound, channel, value);
    }
 
    public void SetAudioChannel(string name, MYFLT[] audio)
    {
        var bufsiz = GetKsmps();
        var buffer = Marshal.AllocHGlobal(sizeof(MYFLT) * (int)bufsiz);
        Marshal.Copy(audio, 0, buffer, (int)Math.Min(audio.Length, bufsiz));
        Csound6.NativeMethods.csoundSetAudioChannel(csound, name, buffer);
        Marshal.FreeHGlobal(buffer);
    }
 
    public MYFLT[] GetAudioChannel(string name)
    {
        var bufsiz = GetKsmps();
        var buffer = Marshal.AllocHGlobal(sizeof(MYFLT) * (int)bufsiz);
        MYFLT[] dest = new MYFLT[bufsiz];//include nchnls/nchnlss_i? no, not an output channel: just a single ksmps-sized buffer
        Csound6.NativeMethods.csoundGetAudioChannel(csound, name, buffer);
        Marshal.Copy(buffer, dest, 0, dest.Length);
        Marshal.FreeHGlobal(buffer);
        return dest;
    }
 
    public int TableLength(int table)
    {
        return Csound6.NativeMethods.csoundTableLength(csound, table);
    }
 
    public MYFLT GetTable(int table, int index)
    {
        return Csound6.NativeMethods.csoundTableGet(csound, table, index);
    }
 
    public void SetTable(int table, int index, MYFLT value)
    {
        Csound6.NativeMethods.csoundTableSet(csound, table, index, value);
    }
 
    public void TableCopyOut(int table, out MYFLT[] dest)
    {
        int len = Csound6.NativeMethods.csoundTableLength(csound, table);
        if (len < 1)
        {
            dest = null;
            return;
        }
 
        dest = new MYFLT[len];
        IntPtr des = Marshal.AllocHGlobal(sizeof(MYFLT) * dest.Length);
        Csound6.NativeMethods.csoundTableCopyOut(csound, table, des);
        Marshal.Copy(des, dest, 0, len);
        Marshal.FreeHGlobal(des);
    }
 
    public void TableCopyOutAsync(int table, out MYFLT[] dest)
    {
        int len = Csound6.NativeMethods.csoundTableLength(csound, table);
        if (len < 1)
        {
            dest = null;
            return;
        }
 
        dest = new MYFLT[len];
        IntPtr des = Marshal.AllocHGlobal(sizeof(MYFLT) * dest.Length);
        Csound6.NativeMethods.csoundTableCopyOutAsync(csound, table, des);
        Marshal.Copy(des, dest, 0, len);
        Marshal.FreeHGlobal(des);
    }
 
    public void TableCopyIn(int table, MYFLT[] source)
    {
        var len = Csound6.NativeMethods.csoundTableLength(csound, table);
        if (len < 1 || len < source.Length) return;
        IntPtr src = Marshal.AllocHGlobal(sizeof(MYFLT) * source.Length);
        Marshal.Copy(source, 0, src, source.Length);
        Csound6.NativeMethods.csoundTableCopyIn(csound, table, src);
        Marshal.FreeHGlobal(src);
    }
 
    public void TableCopyInAsync(int table, MYFLT[] source)
    {
        var len = Csound6.NativeMethods.csoundTableLength(csound, table);
        if (len < 1 || len < source.Length) return;
        IntPtr src = Marshal.AllocHGlobal(sizeof(MYFLT) * source.Length);
        Marshal.Copy(source, 0, src, source.Length);
        Csound6.NativeMethods.csoundTableCopyInAsync(csound, table, src);
        Marshal.FreeHGlobal(src);
    }
 
    public int GetTable(out MYFLT[] tableValues, int numTable)
    {
        int len = Csound6.NativeMethods.csoundTableLength(csound, numTable);
        if (len < 1)
        {
            tableValues = null;
            return -1;
        }
 
        IntPtr tablePtr = new IntPtr();
        tableValues = new MYFLT[len];
        int res = Csound6.NativeMethods.csoundGetTable(csound, out tablePtr, numTable);
        if (res != -1)
            Marshal.Copy(tablePtr, tableValues, 0, len);
        else tableValues = null;
        GCHandle gc = GCHandle.FromIntPtr(tablePtr);
        gc.Free();
        return res;
    }
 
    public int GetTableArgs(out MYFLT[] args, int index)
    {
        IntPtr addr = new IntPtr();
        int len = Csound6.NativeMethods.csoundGetTableArgs(csound, out addr, index);
        args = new MYFLT[len];
        if (len != -1)
            Marshal.Copy(addr, args, 0, len);
        else args = null;
        Marshal.FreeHGlobal(addr);
        return len;
    }
 
    public int IsNamedGEN(int num)
    {
        return Csound6.NativeMethods.csoundIsNamedGEN(csound, num);
    }
 
    public void GetNamedGEN(int num, out string name, int len)
    {
        Csound6.NativeMethods.csoundGetNamedGEN(csound, num, out name, len);
    }
 
    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)]
    private class NamedGenProxy
    {
        public IntPtr name;
        public int genum;
        public IntPtr next; //NAMEDGEN pointer used by csound as linked list, but not sure if we care
    }
 
    public IDictionary<string, int> GetNamedGens()
    {
        IDictionary<string, int> gens = new Dictionary<string, int>();
        IntPtr pNAMEDGEN = Csound6.NativeMethods.csoundGetNamedGens(csound);
        while (pNAMEDGEN != IntPtr.Zero)
        {
            NamedGenProxy namedGen = (NamedGenProxy)Marshal.PtrToStructure(pNAMEDGEN, typeof(NamedGenProxy));
            gens.Add(Marshal.PtrToStringAnsi(namedGen.name), namedGen.genum);
            pNAMEDGEN = namedGen.next;
        }
        return gens;
    }
 
    public MYFLT GetSr()
    {
        return Csound6.NativeMethods.csoundGetSr(csound);
    }
 
    public MYFLT GetKr()
    {
        return Csound6.NativeMethods.csoundGetKr(csound);
    }
 
    public uint GetKsmps()
    {
        return Csound6.NativeMethods.csoundGetKsmps(csound);
    }
 
    public MYFLT GetSpoutSample(int frame, int channel)
    {
        return Csound6.NativeMethods.csoundGetSpoutSample(csound, frame, channel);
    }
 
    public void AddSpinSample(int frame, int channel, MYFLT sample)
    {
        Csound6.NativeMethods.csoundAddSpinSample(csound, frame, channel, sample);
    }
 
    public void SetSpinSample(int frame, int channel, MYFLT sample)
    {
        Csound6.NativeMethods.csoundSetSpinSample(csound, frame, channel, sample);
    }
 
    public void ClearSpin()
    {
        Csound6.NativeMethods.csoundClearSpin(csound);
    }
 
    public MYFLT[] GetSpin()
    {
        var size = (Int32)Csound6.NativeMethods.csoundGetKsmps(csound) * (int)GetNchnlsInput();
        var spin = new MYFLT[size];
        var addr = Csound6.NativeMethods.csoundGetSpin(csound);
        Marshal.Copy(addr, spin, 0, size);
        return spin;
    }
 
    public MYFLT[] GetSpout()
    {
        var size = (Int32)Csound6.NativeMethods.csoundGetKsmps(csound) * (int)GetNchnls();
        var spout = new MYFLT[size];
        var addr = Csound6.NativeMethods.csoundGetSpout(csound);
        Marshal.Copy(addr, spout, 0, size);
        return spout;
    }
 
    public MYFLT GetChannel(string channel)
    {
        return Csound6.NativeMethods.csoundGetControlChannel(csound, channel, IntPtr.Zero);
    }
 
    public uint GetNchnlsInput()
    {
        return Csound6.NativeMethods.csoundGetNchnlsInput(csound);
    }
 
    public uint GetNchnls()
    {
        return Csound6.NativeMethods.csoundGetNchnlsInput(csound);
    }
 
    public int GetCsoundMessageCount()
    {
        return Csound6.NativeMethods.csoundGetMessageCnt(csound);
    }
 
    public string GetCsoundMessage()
    {
        string message = GetMessageText(Csound6.NativeMethods.csoundGetFirstMessage(csound));
        Csound6.NativeMethods.csoundPopFirstMessage(csound);
        return message;
    }
 
    public static string GetMessageText(IntPtr message)
    {
        return CharPtr2String(message);
    }
 
    public IDictionary<string, IList<OpcodeArgumentTypes>> GetOpcodeList()
    {
        var opcodes = new SortedDictionary<string, IList<OpcodeArgumentTypes>>();
        IntPtr ppOpcodeList = IntPtr.Zero;
        int size = Csound6.NativeMethods.csoundNewOpcodeList(csound, out ppOpcodeList);
        if ((ppOpcodeList != IntPtr.Zero) && (size >= 0))
        {
            int proxySize = Marshal.SizeOf(typeof(OpcodeListProxy));
            for (int i = 0; i < size; i++)
            {
                OpcodeListProxy proxy = Marshal.PtrToStructure(ppOpcodeList + (i * proxySize), typeof(OpcodeListProxy)) as OpcodeListProxy;
                string opname = Marshal.PtrToStringAnsi(proxy.opname);
                OpcodeArgumentTypes opcode = new OpcodeArgumentTypes
                {
                    outypes = Marshal.PtrToStringAnsi(proxy.outtypes),
                    intypes = Marshal.PtrToStringAnsi(proxy.intypes),
                    flags = proxy.flags
                };
                if (!opcodes.ContainsKey(opname))
                {
                    IList<OpcodeArgumentTypes> types = new List<OpcodeArgumentTypes>();
                    types.Add(opcode);
                    opcodes.Add(opname, types);
                }
                else
                {
                    opcodes[opname].Add(opcode);
                }
            }
            Csound6.NativeMethods.csoundDisposeOpcodeList(csound, ppOpcodeList);
        }
        return opcodes;
    }
 
    public IDictionary<string, ChannelInfo> GetChannelList()
    {
        IDictionary<string, ChannelInfo> channels = new SortedDictionary<string, ChannelInfo>();
 
        IntPtr ppChannels = IntPtr.Zero;
        int size = Csound6.NativeMethods.csoundListChannels(csound, out ppChannels);
        if ((size > 0) && (ppChannels != IntPtr.Zero))
        {
            int proxySize = Marshal.SizeOf(typeof(ChannelInfoProxy));
            for (int i = 0; i < size; i++)
            {
                var proxy = Marshal.PtrToStructure(ppChannels + (i * proxySize), typeof(ChannelInfoProxy)) as ChannelInfoProxy;
                string chanName = CharPtr2String(proxy.name);
 
                ChannelInfo info = new ChannelInfo(chanName, (ChannelType)(proxy.type & 15), (ChannelDirection)(proxy.type >> 4));
                var hintProxy = proxy.hints;
                var hints = new ChannelHints((ChannelBehavior)hintProxy.behav, hintProxy.dflt, hintProxy.min, hintProxy.max)
                {
                    x = hintProxy.x,
                    y = hintProxy.y,
                    height = hintProxy.height,
                    width = hintProxy.width,
                    attributes = CharPtr2String(proxy.name)
                };
                info.Hints = hints;
                channels.Add(chanName, info);
            }
            Csound6.NativeMethods.csoundDeleteChannelList(csound, ppChannels);
        }
        return channels;
    }
 
    public CSOUND_PARAMS GetParams()
    {
        CSOUND_PARAMS oparms = new CSOUND_PARAMS();
        Csound6.NativeMethods.csoundGetParams(csound, oparms);
        return oparms;
    }
 
    public void SetParams(CSOUND_PARAMS parms)
    {
        Csound6.NativeMethods.csoundSetParams(csound, parms);
    }
 
    public class OpcodeArgumentTypes
    {
        public string outypes;
        public string intypes;
        public int flags;
    }
 
    [StructLayout(LayoutKind.Sequential)]
    private class OpcodeListProxy
    {
        public IntPtr opname;
        public IntPtr outtypes;
        public IntPtr intypes;
        public int flags;
    }
 
    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)]
    private class ChannelInfoProxy
    {
        [MarshalAs(UnmanagedType.AnsiBStr)]
        public IntPtr name;
        public int type;
        [MarshalAs(UnmanagedType.Struct)]
        public ChannelHintsProxy hints;
    }
 
    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)]
    private struct ChannelHintsProxy
    {
        public ChannelHintsProxy(ChannelHints hints)
        {
            behav = (int)hints.behav;
            dflt = hints.dflt; min = hints.min; max = hints.max;
            x = hints.x; y = hints.y; height = hints.height; width = hints.width;
            attributes = IntPtr.Zero;
        }
 
        public int behav;
        public MYFLT dflt;
        public MYFLT min;
        public MYFLT max;
        public int x;
        public int y;
        public int width;
        public int height;
        [MarshalAs(UnmanagedType.AnsiBStr)]
        public IntPtr attributes;
    }
 
    public class ChannelInfo
    {
        public ChannelInfo(string _name, ChannelType _type, ChannelDirection _direction)
        {
            Name = _name;
            Type = _type;
            Direction = _direction;
        }
        public string Name;
        public ChannelType Type;
        public ChannelDirection Direction;
        public ChannelHints Hints;
    };
 
    public class ChannelHints
    {
        public ChannelHints() : this(ChannelBehavior.None, 0, 0, 0)
        {
        }
 
        public ChannelHints(ChannelBehavior ibehav, MYFLT idflt, MYFLT imin, MYFLT imax)
        {
            behav = ibehav;
            dflt = idflt;
            min = imin;
            max = imax;
            x = 0;
            y = 0;
            width = 0;
            height = 0;
            attributes = null;
        }
 
        public ChannelBehavior behav;
        public MYFLT dflt;
        public MYFLT min;
        public MYFLT max;
        public int x;
        public int y;
        public int width;
        public int height;
        public string attributes;
    }
 
    public enum ChannelBehavior
    {
        None = 0,
        Integer = 1,
        Linear = 2,
        Exponential = 3
    }
 
    public enum ChannelType
    {
        None = 0, //error return type only, meaningless in input
        Control = 1,
        Audio = 2,
        String = 3,
        Pvs = 4,
        Var = 5,
    }
 
    [Flags]
    public enum ChannelDirection
    {
        Input = 1,
        Output = 2
    }
 
    [StructLayout(LayoutKind.Sequential)]
    public class CSOUND_PARAMS
    {
        public int debug_mode;     /* debug mode, 0 or 1 */
        public int buffer_frames;  /* number of frames in in/out buffers */
        public int hardware_buffer_frames; /* ibid. hardware */
        public int displays;       /* graph displays, 0 or 1 */
        public int ascii_graphs;   /* use ASCII graphs, 0 or 1 */
        public int postscript_graphs; /* use postscript graphs, 0 or 1 */
        public int message_level;     /* message printout control */
        public int tempo;             /* tempo (sets Beatmode)  */
        public int ring_bell;         /* bell, 0 or 1 */
        public int use_cscore;        /* use cscore for processing */
        public int terminate_on_midi; /* terminate performance at the end
                                        of midifile, 0 or 1 */
        public int heartbeat;         /* print heart beat, 0 or 1 */
        public int defer_gen01_load;  /* defer GEN01 load, 0 or 1 */
        public int midi_key;           /* pfield to map midi key no */
        public int midi_key_cps;       /* pfield to map midi key no as cps */
        public int midi_key_oct;       /* pfield to map midi key no as oct */
        public int midi_key_pch;       /* pfield to map midi key no as pch */
        public int midi_velocity;      /* pfield to map midi velocity */
        public int midi_velocity_amp;   /* pfield to map midi velocity as amplitude */
        public int no_default_paths;     /* disable relative paths from files, 0 or 1 */
        public int number_of_threads;   /* number of threads for multicore performance */
        public int syntax_check_only;   /* do not compile, only check syntax */
        public int csd_line_counts;     /* csd line error reporting */
        public int compute_weights;     /* use calculated opcode weights for
                                          multicore, 0 or 1  */
        public int realtime_mode;       /* use realtime priority mode, 0 or 1 */
        public int sample_accurate;     /* use sample-level score event accuracy */
        public double sample_rate_override; /* overriding sample rate */
        public double control_rate_override; /* overriding control rate */
        public int nchnls_override;     /* overriding number of out channels */
        public int nchnls_i_override;   /* overriding number of in channels */
        public double e0dbfs_override;  /* overriding 0dbfs */
        public int daemon;              /* daemon mode*/
        public int ksmps_override;      /* ksmps override */
        public int FFT_library;         /* fft_lib */
    }
 
 
    public string GetEnv(string key)
    {
        return CharPtr2String(Csound6.NativeMethods.csoundGetEnv(csound, key));
    }
 
    public int SetGlobalEnv(string name, string value)
    {
        return Csound6.NativeMethods.csoundSetGlobalEnv(name, value);
    }
 
    internal static String CharPtr2String(IntPtr pString)
    {
        return ((pString != null) && (pString != IntPtr.Zero)) ? Marshal.PtrToStringAnsi(pString) : string.Empty;
    }
}