CsoundUnity.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.IO;
using System.Collections.Generic;
using System.Collections;
using System;
using System.Globalization;
using UnityEngine.Networking;
#if UNITY_EDITOR
using UnityEditor;
#endif
#if UNITY_EDITOR || UNITY_STANDALONE
using MYFLT = System.Double;
#elif UNITY_ANDROID || UNITY_IOS
using MYFLT = System.Single;
#endif
 
#region PUBLIC_CLASSES
 
[Serializable]
public class CsoundChannelController
{
    [SerializeField] public string type = "";
    [SerializeField] public string channel = "";
    [SerializeField] public string text = "";
    [SerializeField] public string caption = "";
    [SerializeField] public float min;
    [SerializeField] public float max;
    [SerializeField] public float value;
    [SerializeField] public float skew;
    [SerializeField] public float increment;
    [SerializeField] public string[] options;
 
    public void SetRange(float uMin, float uMax, float uValue = 0f, float uSkew = 1f, float uIncrement = 0.01f)
    {
        min = uMin;
        max = uMax;
        value = uValue;
        skew = uSkew;
        increment = uIncrement;
    }
 
    public CsoundChannelController Clone()
    {
        return this.MemberwiseClone() as CsoundChannelController;
    }
 
    //public static explicit operator UnityEngine.Object(CsoundChannelController v)
    //{
    //    return (UnityEngine.Object)v;
    //}
}
 
[Serializable]
public class EnvironmentSettings
{
    [SerializeField] public SupportedPlatform platform;
    [SerializeField] public CsoundUnity.EnvType type;
    [SerializeField] public EnvironmentPathOrigin baseFolder;
    [SerializeField] public string suffix;
    [Tooltip("Utility bool to store if the drawn property is foldout or not")]
    [SerializeField] public bool foldout;
 
    public string GetPath(bool runtime = false)
    {
        var path = string.Empty;
        //Debug.Log($"EnvironmentSettings GetPath from {baseFolder}");
        switch (baseFolder)
        {
            case EnvironmentPathOrigin.PersistentDataPath:
                path = GetPersistentDataPath(platform, runtime);
                break;
            case EnvironmentPathOrigin.StreamingAssets:
                path = GetStreamingAssetsPath(platform, runtime);
                break;
            case EnvironmentPathOrigin.Plugins:
                path = GetPluginsPath(platform, runtime);
                break;
            case EnvironmentPathOrigin.Absolute:
            default:
                break;
        }
        path = Path.Combine(path, suffix);
        return path;
    }
 
    private string GetPersistentDataPath(SupportedPlatform supportedPlatform, bool runtime)
    {
        var res = Application.persistentDataPath;
        switch (supportedPlatform)
        {
            case SupportedPlatform.MacOS:
                res = runtime ?
                    $"~/Library/Application Support/{Application.companyName}/{Application.productName}" :
                    Application.persistentDataPath;
                break;
            case SupportedPlatform.Windows:
                res = runtime ?
                    $"%userprofile%\\AppData\\LocalLow\\{Application.companyName}\\{Application.productName}" :
                    Application.persistentDataPath;
                break;
            case SupportedPlatform.Android:
                res = runtime ?
                    $"/storage/emulated/0/Android/data/{Application.identifier}/files" : Application.persistentDataPath;
                break;
            case SupportedPlatform.iOS:
                res = runtime ? $"/var/mobile/Containers/Data/Application/{Application.identifier}/Documents" : Application.persistentDataPath;
                break;
        }
        return res;
    }
 
    private string GetStreamingAssetsPath(SupportedPlatform supportedPlatform, bool runtime)
    {
        var res = Application.streamingAssetsPath;
        switch (supportedPlatform)
        {
            case SupportedPlatform.MacOS:
                res = runtime ? $"<path to player app bundle>/Contents/Resources/Data/StreamingAssets" : Application.streamingAssetsPath;
                break;
            case SupportedPlatform.Windows:
                res = runtime ? $"<path to executablename_Data folder>" : Application.streamingAssetsPath;
                break;
            case SupportedPlatform.Android:
                res = runtime ? $"jar:file://storage/emulated/0/Android/data/{Application.identifier}/!/assets" : Application.streamingAssetsPath;
                break;
            case SupportedPlatform.iOS:
                res = runtime ? $"/var/mobile/Containers/Data/Application/{Application.identifier}/Raw/" : Application.streamingAssetsPath;
                break;
        }
        return res;
    }
 
    private string GetPluginsPath(SupportedPlatform supportedPlatform, bool runtime)
    {
        //Debug.Log($"GetPluginsPath for platform: {supportedPlatform}");
        var res = Path.Combine(Application.dataPath, "Plugins");
        switch (supportedPlatform)
        {
            case SupportedPlatform.MacOS:
                res = runtime ? $"<path to player app bundle>/Contents/Resources/Data/Plugins" : res;
                break;
            case SupportedPlatform.Windows:
                res = runtime ? $"<path to executablename_Data folder>/Managed" : Path.Combine(Application.dataPath, "Managed");
                break;
            case SupportedPlatform.Android:
#if UNITY_ANDROID && !UNITY_EDITOR
                //Debug.Log("1 - GET ANDROID NATIVE LIBRARY DIR");
                res = GetAndroidNativeLibraryDir();
#else
                res = runtime ? $"/data/app/<random chars>/{Application.identifier}-<random chars>/lib/arm64-v8a" : res;
#endif
                break;
            case SupportedPlatform.iOS:
                res = runtime ? $"/var/mobile/Containers/Data/Application/{Application.identifier}/Plugins" : res;
                break;
        }
        return res;
    }
 
 
#if UNITY_ANDROID && !UNITY_EDITOR
    public static AndroidJavaObject GetUnityActivity()
    {
        using (var unityPlayer = new AndroidJavaClass("com.unity3d.player.UnityPlayer"))
        {
            return unityPlayer.GetStatic<AndroidJavaObject>("currentActivity");
        }
    }
 
    public static AndroidJavaObject GetUnityContext()
    {
        var activity = GetUnityActivity();
        //Debug.Log($"2 - GetUnityContext, activity null? {activity == null}");
        return activity.Call<AndroidJavaObject>("getApplicationContext");
    }
 
    public static AndroidJavaObject GetApplicationInfo()
    {
        var context = GetUnityContext();
        //Debug.Log($"3 - GetApplicationInfo, context null? {context == null}");
        return GetUnityContext().Call<AndroidJavaObject>("getApplicationInfo");
    }
 
    public static string GetAndroidNativeLibraryDir()
    {
        var info = GetApplicationInfo();
        //Debug.Log($"4 - GetAndroidNativeLibraryDir, info null? {info == null}");
        return info.Get<string>("nativeLibraryDir");
    }
#endif
 
    public string GetTypeString()
    {
        return type.ToString();
    }
 
    public string GetPlatformString()
    {
        return platform.ToString();
    }
 
    public string GetPathDescriptor(bool runtime)
    {
        return $"[{GetPlatformString()}]:[{GetTypeString()}]: {GetPath(runtime)}";
    }
}
 
[Serializable]
public enum SupportedPlatform { MacOS, Windows, Android, iOS }
 
[Serializable]
public enum EnvironmentPathOrigin { PersistentDataPath, StreamingAssets, Absolute, Plugins }
 
#endregion PUBLIC_CLASSES
 
[AddComponentMenu("Audio/CsoundUnity")]
[Serializable]
[RequireComponent(typeof(AudioSource))]
public class CsoundUnity : MonoBehaviour
{
    #region PUBLIC_FIELDS
 
    public const string packageName = "com.csound.csoundunity";
 
    public const string packageVersion = "3.4.0";
 
    public string csoundFileGUID { get => _csoundFileGUID; }
 
    public string csoundFileName { get => _csoundFileName; }
 
    public string csoundString { get => _csoundString; }
 
#if UNITY_EDITOR
    //[SerializeField]
    public DefaultAsset csoundAsset { get => _csoundAsset; }
#endif
 
    [HideInInspector] public bool logCsoundOutput = false;
 
    [HideInInspector] public bool mute = false;
 
    [HideInInspector] public bool processClipAudio;
 
    [HideInInspector] public bool loudVolumeWarning = true;
 
    [HideInInspector] public float loudWarningThreshold = 10f;
 
    public List<CsoundChannelController> channels { get => _channels; }
 
    public List<string> availableAudioChannels { get => _availableAudioChannels; }
 
    public readonly Dictionary<string, MYFLT[]> namedAudioChannelDataDict = new Dictionary<string, MYFLT[]>();
 
    public bool IsInitialized { get => initialized; }
 
    public delegate void CsoundInitialized();
    public event CsoundInitialized OnCsoundInitialized;
 
    public bool PerformanceFinished { get => performanceFinished; }
    [HideInInspector] public string csoundScore;
 
    [SerializeField]
    [HideInInspector]
    public List<EnvironmentSettings> environmentSettings = new List<EnvironmentSettings>();
 
    public string CurrentPreset => _currentPreset;
    
    #endregion PUBLIC_FIELDS
 
    #region PRIVATE_FIELDS
 
    private CsoundUnityBridge csound;
    [HideInInspector] [SerializeField] private string _csoundFileGUID;
    [HideInInspector] [SerializeField] private string _csoundString;
    [HideInInspector] [SerializeField] private string _csoundFileName;
#if UNITY_EDITOR
    [HideInInspector] [SerializeField] private DefaultAsset _csoundAsset;
#endif
    [HideInInspector] [SerializeField] private List<CsoundChannelController> _channels = new List<CsoundChannelController>();
    private Dictionary<string, int> _channelsIndexDict = new Dictionary<string, int>();
    [HideInInspector] [SerializeField] private List<string> _availableAudioChannels = new List<string>();
#pragma warning disable 414
    [HideInInspector] [SerializeField] private bool _drawCsoundString = false;
    [HideInInspector] [SerializeField] private bool _drawTestScore = false;
    [HideInInspector] [SerializeField] private bool _drawSettings = false;
    [HideInInspector] [SerializeField] private bool _drawChannels = false;
    [HideInInspector] [SerializeField] private bool _drawAudioChannels = false;
    [HideInInspector] [SerializeField] private bool _drawPresets = false;
    [HideInInspector] [SerializeField] private bool _drawPresetsLoad = false;
    [HideInInspector] [SerializeField] private bool _drawPresetsSave = false;
    [HideInInspector] [SerializeField] private bool _drawPresetsImport = false;
    [HideInInspector] [SerializeField] private bool _showRuntimeEnvironmentPath = false;
    [HideInInspector] [SerializeField] private string _currentPreset;
    [HideInInspector] [SerializeField] private string _currentPresetSaveFolder;
    [HideInInspector] [SerializeField] private string _currentPresetLoadFolder;
 
    
 
#pragma warning restore 414
 
    private bool initialized = false;
    private uint ksmps = 32;
    private uint ksmpsIndex = 0;
    private float zerdbfs = 1;
    private bool compiledOk = false;
    private bool performanceFinished;
    private AudioSource audioSource;
    private Coroutine LoggingCoroutine;
    int bufferSize, numBuffers;
 
    private const string GLOBAL_TAG = "(GLOBAL)";
 
    private Dictionary<string, MYFLT[]> namedAudioChannelTempBufferDict = new Dictionary<string, MYFLT[]>();
 
    #endregion
 
    void Awake()
    {
        initialized = false;
 
        AudioSettings.GetDSPBufferSize(out bufferSize, out numBuffers);
 
        audioSource = GetComponent<AudioSource>();
        audioSource.spatializePostEffects = true;
 
        // FIX SPATIALIZATION ISSUES
        if (audioSource.clip == null && !processClipAudio)
        {
            var ac = AudioClip.Create("CsoundUnitySpatializerClip", 32, 1, AudioSettings.outputSampleRate, false);
            var data = new float[32];
            for (var i = 0; i < data.Length; i++) data[i] = 1;
            ac.SetData(data, 0);
 
            audioSource.clip = ac;
            audioSource.loop = true;
            audioSource.Play();
        }
 
        csound = new CsoundUnityBridge(_csoundString, environmentSettings);
        if (csound != null)
        {
            if (channels != null)
                // initialise channels if found in xml descriptor..
                for (int i = 0; i < channels.Count; i++)
                {
                    if (channels[i].type.Contains("combobox"))
                        csound.SetChannel(channels[i].channel, channels[i].value + 1);
                    else
                        csound.SetChannel(channels[i].channel, channels[i].value);
                    // update channels index dictionary
                    if (!_channelsIndexDict.ContainsKey(channels[i].channel))
                        _channelsIndexDict.Add(channels[i].channel, i);
                }
 
            foreach (var name in availableAudioChannels)
            {
                if (!namedAudioChannelDataDict.ContainsKey(name))
                {
                    namedAudioChannelDataDict.Add(name, new MYFLT[bufferSize]);
                    namedAudioChannelTempBufferDict.Add(name, new MYFLT[ksmps]);
                }
            }
 
            LoggingCoroutine = StartCoroutine(Logging(.01f));
 
            compiledOk = csound.CompiledWithoutError();
 
            if (compiledOk)
            {
                zerdbfs = (float)csound.Get0dbfs();
 
                Debug.Log($"Csound zerdbfs: {zerdbfs}");
 
                initialized = true;
                OnCsoundInitialized?.Invoke();
            }
        }
        else
        {
            Debug.Log("Error creating Csound object");
            compiledOk = false;
        }
 
        Debug.Log($"CsoundUnity done init, compiledOk? {compiledOk}");
    }
 
    #region PUBLIC_METHODS
 
    #region INSTANTIATION
 
    public int GetVersion()
    {
        return csound.GetVersion();
    }
 
    public int GetAPIVersion()
    {
        return csound.GetAPIVersion();
    }
 
    public int LoadPlugins(string dir)
    {
        return csound.LoadPlugins(dir);
    }
 
    public bool CompiledWithoutError()
    {
        return compiledOk;
    }
 
    #endregion INSTANTIATION
 
    #region PERFORMANCE
 
    public void SetCsd(string guid)
    {
#if UNITY_EDITOR //for now setting csd is permitted from editor only, via asset guid
 
        // Debug.Log($"SET CSD guid: {guid}");
        if (string.IsNullOrWhiteSpace(guid) || !Guid.TryParse(guid, out Guid guidResult))
        {
            Debug.LogWarning($"GUID NOT VALID, Resetting fields");
            ResetFields();
            return;
        }
 
        var fileName = AssetDatabase.GUIDToAssetPath(guid);
 
        if (string.IsNullOrWhiteSpace(fileName) ||
            fileName.Length < 4 ||
            Path.GetFileName(fileName).Length < 4 ||
            !Path.GetFileName(fileName).EndsWith(".csd"))
        {
            Debug.LogWarning("FILENAME not valid, Resetting fields");
            ResetFields();
            return;
        }
 
        this._csoundFileGUID = guid;
        this._csoundFileName = Path.GetFileName(fileName);
        var csoundFilePath = Path.GetFullPath(fileName);
        this._csoundAsset = (DefaultAsset)(AssetDatabase.LoadAssetAtPath(fileName, typeof(DefaultAsset)));
        this._csoundString = File.ReadAllText(csoundFilePath);
        this._channels = ParseCsdFile(fileName);
        var count = 0;
        foreach (var chan in this._channels)
            if (!_channelsIndexDict.ContainsKey(chan.channel))
                _channelsIndexDict.Add(chan.channel, count++);
        this._availableAudioChannels = ParseCsdFileForAudioChannels(fileName);
 
        foreach (var name in availableAudioChannels)
        {
            if (string.IsNullOrWhiteSpace(name)) continue;
 
            if (!namedAudioChannelDataDict.ContainsKey(name))
            {
                namedAudioChannelDataDict.Add(name, new MYFLT[bufferSize]);
                namedAudioChannelTempBufferDict.Add(name, new MYFLT[ksmps]);
            }
        }
 
#endif
    }
 
    public int CompileOrc(string orcStr)
    {
        return csound.CompileOrc(orcStr);
    }
 
    public void SendScoreEvent(string scoreEvent)
    {
        //print(scoreEvent);
        csound.SendScoreEvent(scoreEvent);
    }
 
    public void RewindScore()
    {
        csound.RewindScore();
    }
 
    public void SetScoreOffsetSeconds(MYFLT value)
    {
        csound.CsoundSetScoreOffsetSeconds(value);
    }
 
    public MYFLT GetSr()
    {
        return csound.GetSr();
    }
 
    public MYFLT GetKr()
    {
        return csound.GetKr();
    }
 
    public int PerformKsmps()
    {
        return csound.PerformKsmps();
    }
 
    public uint GetKsmps()
    {
        return csound.GetKsmps();
    }
 
    #endregion PERFORMANCE
 
    #region CSD_PARSE
 
    public static List<string> ParseCsdFileForAudioChannels(string filename)
    {
        if (!File.Exists(filename)) return null;
 
        string[] fullCsdText = File.ReadAllLines(filename);
        if (fullCsdText.Length < 1) return null;
 
        List<string> locaAudioChannels = new List<string>();
 
        foreach (string line in fullCsdText)
        {
            var trimmd = line.TrimStart();
            if (!trimmd.Contains("chnset")) continue;
            if (trimmd.StartsWith(";")) continue;
            var lndx = trimmd.IndexOf("chnset");
            var chnsetEnd = lndx + "chnset".Length + 1;
            var prms = trimmd.Substring(chnsetEnd, trimmd.Length - chnsetEnd);
            var split = prms.Split(',');
            if (!split[0].StartsWith("a") && !split[0].StartsWith("ga"))
                continue; //discard non audio variables
            // Debug.Log("found audio channel");
            var ach = split[1].Replace('\\', ' ').Replace('\"', ' ').Trim();
            if (!locaAudioChannels.Contains(ach))
                locaAudioChannels.Add(ach);
        }
        return locaAudioChannels;
    }
 
    public static List<CsoundChannelController> ParseCsdFile(string filename)
    {
        if (!File.Exists(filename)) return null;
 
        string[] fullCsdText = File.ReadAllLines(filename);
        if (fullCsdText.Length < 1) return null;
 
        List<CsoundChannelController> locaChannelControllers;
        locaChannelControllers = new List<CsoundChannelController>();
 
        foreach (string line in fullCsdText)
        {
 
            if (line.Contains("</"))
                break;
 
            var trimmd = line.TrimStart();
            //discard csound comments in cabbage widgets
            if (trimmd.StartsWith(";"))
            {
                //Debug.Log("discarding "+line);
                continue;
            }
            var control = trimmd.Substring(0, trimmd.IndexOf(" ") > -1 ? trimmd.IndexOf(" ") : 0);
            if (control.Contains("slider") || control.Contains("button") || control.Contains("checkbox")
                || control.Contains("groupbox") || control.Contains("form") || control.Contains("combobox"))
            {
                CsoundChannelController controller = new CsoundChannelController();
                controller.type = control;
                if (trimmd.IndexOf("caption(") > -1)
                {
                    string infoText = trimmd.Substring(trimmd.IndexOf("caption(") + 9);
                    infoText = infoText.Substring(0, infoText.IndexOf(")") - 1);
                    controller.caption = infoText;
                }
 
                if (trimmd.IndexOf("text(") > -1)
                {
                    string text = trimmd.Substring(trimmd.IndexOf("text(") + 6);
                    text = text.Substring(0, text.IndexOf(")") - 1);
                    text = text.Replace("\"", "");
                    text = text.Replace('"', new char());
                    controller.text = text;
                    if (controller.type == "combobox") //if combobox, create a range
                    {
                        char[] delimiterChars = { ',' };
                        string[] tokens = text.Split(delimiterChars);
                        controller.SetRange(1, tokens.Length, 0);
 
                        for (var o = 0; o < tokens.Length; o++)
                        {
                            tokens[o] = string.Join("", tokens[o].Split(default(string[]), System.StringSplitOptions.RemoveEmptyEntries));
                        }
                        controller.options = tokens;
                    }
                }
 
                if (trimmd.IndexOf("items(") > -1)
                {
                    string text = trimmd.Substring(trimmd.IndexOf("items(") + 7);
                    text = text.Substring(0, text.IndexOf(")") - 1);
                    //TODO THIS OVERRIDES TEXT!
                    text = text.Replace("\"", "");
                    text = text.Replace('"', new char());
                    if (controller.type == "combobox")
                    {
                        char[] delimiterChars = { ',' };
                        string[] tokens = text.Split(delimiterChars);
                        controller.SetRange(1, tokens.Length, 0);
 
                        for (var o = 0; o < tokens.Length; o++)
                        {
                            tokens[o] = string.Join("", tokens[o].Split(default(string[]), System.StringSplitOptions.RemoveEmptyEntries));
                        }
                        controller.options = tokens;
                    }
                }
 
                if (trimmd.IndexOf("channel(") > -1)
                {
                    string channel = trimmd.Substring(trimmd.IndexOf("channel(") + 9);
                    channel = channel.Substring(0, channel.IndexOf(")") - 1);
                    controller.channel = channel;
                }
 
                if (trimmd.IndexOf("range(") > -1)
                {
                    int rangeAt = trimmd.IndexOf("range(");
                    if (rangeAt != -1)
                    {
                        string range = trimmd.Substring(rangeAt + 6);
                        range = range.Substring(0, range.IndexOf(")"));
                        char[] delimiterChars = { ',' };
                        string[] tokens = range.Split(delimiterChars);
                        for (var i = 0; i < tokens.Length; i++)
                        {
                            tokens[i] = string.Join("", tokens[i].Split(default(string[]), StringSplitOptions.RemoveEmptyEntries));
                            if (tokens[i].StartsWith("."))
                            {
                                tokens[i] = "0" + tokens[i];
                            }
                            if (tokens[i].StartsWith("-."))
                            {
                                tokens[i] = "-0" + tokens[i].Substring(2, tokens[i].Length - 2);
                            }
                        }
                        var min = float.Parse(tokens[0], CultureInfo.InvariantCulture);
                        var max = float.Parse(tokens[1], CultureInfo.InvariantCulture);
                        var val = 0f;
                        var skew = 1f;
                        var increment = 1f;
 
                        if (tokens.Length > 2)
                        {
                            val = float.Parse(tokens[2], CultureInfo.InvariantCulture);
                        }
                        if (tokens.Length > 3)
                        {
                            skew = float.Parse(tokens[3], CultureInfo.InvariantCulture);
                        }
                        if (tokens.Length > 4)
                        {
                            increment = float.Parse(tokens[4], CultureInfo.InvariantCulture);
                        }
                        // Debug.Log($"{tokens.Length}");
                        controller.SetRange(min, max, val, skew, increment);
                    }
                }
 
                if (line.IndexOf("value(") > -1)
                {
                    string value = trimmd.Substring(trimmd.IndexOf("value(") + 6);
                    value = value.Substring(0, value.IndexOf(")"));
                    value = value.Replace("\"", "");
                    controller.value = value.Length > 0 ? float.Parse(value, CultureInfo.InvariantCulture) : 0;
                    if (control.Contains("combobox"))
                    {
                        //Cabbage combobox index starts from 1
                        controller.value = controller.value - 1;
                        // Debug.Log("combobox value in parse: " + controller.value);
                    }
                }
                locaChannelControllers.Add(controller);
            }
        }
        return locaChannelControllers;
    }
 
    #endregion CSD_PARSE
 
    #region IO_BUFFERS
 
    public void SetInputSample(int frame, int channel, MYFLT sample)
    {
        csound.SetSpinSample(frame, channel, sample);
    }
 
    public void AddInputSample(int frame, int channel, MYFLT sample)
    {
        csound.AddSpinSample(frame, channel, sample);
    }
 
    public void ClearSpin()
    {
        if (csound != null)
        {
            Debug.Log("clear spin");
            csound.ClearSpin();
        }
    }
 
    public MYFLT GetOutputSample(int frame, int channel)
    {
        return csound.GetSpoutSample(frame, channel);
    }
 
    public MYFLT[] GetSpin()
    {
        return csound.GetSpin();
    }
 
    public MYFLT[] GetSpout()
    {
        return csound.GetSpout();
    }
 
    #endregion IO_BUFFERS
 
    #region CONTROL_CHANNELS
    public void SetChannel(string channel, MYFLT val)
    {
        csound.SetChannel(channel, val);
 
        // The dictionary below is used to update the serialized channels on the editor
        // Please note that on Cabbage comboboxes values go from 1-n, since 0 refers to no current selection,
        // instead on the Unity Editor their values start from 0
        // so the value on the serialized channel will be decreased by one 
        if (_channelsIndexDict.ContainsKey(channel))
        {
            if (channels[_channelsIndexDict[channel]].type.Contains("combobox"))
            {
                val--;
            }
            channels[_channelsIndexDict[channel]].value = (float)val;
        }
    }
 
    public void SetChannel(CsoundChannelController channelController)
    {
        if (_channelsIndexDict.ContainsKey(channelController.channel))
            channels[_channelsIndexDict[channelController.channel]] = channelController;
        if (csound == null) return;
        csound.SetChannel(channelController.channel, channelController.value);
    }
 
    public void SetChannels(List<CsoundChannelController> channelControllers, bool excludeButtons = true)
    {
        for (var i = 0; i < channelControllers.Count; i++)
        {
            if (excludeButtons && channelControllers[i].type.Contains("button")) continue;
 
            SetChannel(channelControllers[i]);
        }
    }
 
    public void SetStringChannel(string channel, string val)
    {
        csound.SetStringChannel(channel, val);
    }
 
    public MYFLT GetChannel(string channel)
    {
        return csound.GetChannel(channel);
    }
 
    public CsoundChannelController GetChannelController(string channel)
    {
        if (!_channelsIndexDict.ContainsKey(channel)) return null;
        var indx = _channelsIndexDict[channel];
        return this._channels[indx];
    }
    public IDictionary<string, CsoundUnityBridge.ChannelInfo> GetChannelList()
    {
        return csound.GetChannelList();
    }
 
    #endregion CONTROL_CHANNELS
 
    #region AUDIO_CHANNELS
 
    public MYFLT[] GetAudioChannel(string channel)
    {
        return csound.GetAudioChannel(channel);
    }
 
    #endregion AUDIO_CHANNELS
 
    #region TABLES
 
    public int CreateFloatTable(int tableNumber, float[] samples)
    {
        var myFlts = ConvertToMYFLT(samples);
        return CreateTable(tableNumber, myFlts);
    }
 
    public int CreateTable(int tableNumber, MYFLT[] samples)
    {
        if (samples.Length < 1) return -1;
        var resTable = CreateTableInstrument(tableNumber, samples.Length);
        if (resTable != 0)
            return -1;
        // copy samples to the newly created table
        CopyTableIn(tableNumber, samples);
 
        return resTable;
    }
 
    public int CreateTableInstrument(int tableNumber, int tableLength)
    {
        string createTableInstrument = String.Format(@"gisampletable{0} ftgen {0}, 0, {1}, -7, 0, 0", tableNumber, -tableLength );
        // Debug.Log("orc to create table: \n" + createTableInstrument);
        return CompileOrc(createTableInstrument);
    }
 
    public int GetTableLength(int table)
    {
        return csound.TableLength(table);
    }
 
    public MYFLT GetTableSample(int tableNumber, int index)
    {
        return csound.GetTable(tableNumber, index);
    }
 
    public int GetTable(out MYFLT[] tableValues, int numTable)
    {
        return csound.GetTable(out tableValues, numTable);
    }
 
    public int GetTableArgs(out MYFLT[] args, int index)
    {
        return csound.GetTableArgs(out args, index);
    }
 
    public void SetTable(int table, int index, MYFLT value)
    {
        csound.SetTable(table, index, value);
    }
 
    public void CopyTableOut(int table, out MYFLT[] dest)
    {
        csound.TableCopyOut(table, out dest);
    }
 
    public void CopyTableOutAsync(int table, out MYFLT[] dest)
    {
        csound.TableCopyOutAsync(table, out dest);
    }
 
    public void CopyFloatTableIn(int table, float[] source)
    {
        var myFlts = ConvertToMYFLT(source);
        CopyTableIn(table, myFlts);
    }
 
    public void CopyTableIn(int table, MYFLT[] source)
    {
        csound.TableCopyIn(table, source);
    }
 
    public void CopyTableInAsync(int table, MYFLT[] source)
    {
        csound.TableCopyInAsync(table, source);
    }
 
    public int IsNamedGEN(int num)
    {
        return csound.IsNamedGEN(num);
    }
 
    public void GetNamedGEN(int num, out string name, int len)
    {
        csound.GetNamedGEN(num, out name, len);
    }
 
    public IDictionary<string, int> GetNamedGens()
    {
        return csound.GetNamedGens();
    }
 
    #endregion TABLES
 
    #region UTILITIES
 
#if UNITY_EDITOR
    public string GetFilePath()
    {
        return Path.Combine(Application.dataPath.Substring(0, Application.dataPath.Length - "Assets".Length), AssetDatabase.GUIDToAssetPath(csoundFileGUID));
    }
#endif
 
    public CsoundUnityBridge.CSOUND_PARAMS GetParams()
    {
        return csound.GetParams();
    }
 
    public void SetParams(CsoundUnityBridge.CSOUND_PARAMS parms)
    {
        csound.SetParams(parms);
    }
 
    public string GetEnv(EnvType envType)
    {
        return csound.GetEnv(envType.ToString());
    }
 
    public int SetGlobalEnv(string name, string value)
    {
        return csound.SetGlobalEnv(name, value);
    }
 
    public IDictionary<string, IList<CsoundUnityBridge.OpcodeArgumentTypes>> GetOpcodeList()
    {
        return csound.GetOpcodeList();
    }
 
    public uint GetNchnlsInputs()
    {
        return csound.GetNchnlsInput();
    }
 
    public uint GetNchnls()
    {
        return csound.GetNchnls();
    }
 
    public MYFLT Get0dbfs()
    {
        return csound.Get0dbfs();
    }
 
    public long GetCurrentTimeSamples()
    {
        return csound.GetCurrentTimeSamples();
    }
 
    public static float Remap(float value, float from1, float to1, float from2, float to2, bool clamp = false)
    {
        float retValue = (value - from1) / (to1 - from1) * (to2 - from2) + from2;
        if (float.IsNaN(retValue)) return from2;
        if (float.IsPositiveInfinity(retValue)) return to2;
        if (float.IsNegativeInfinity(retValue)) return from2;
        return clamp ? Mathf.Clamp(retValue, from2, to2) : retValue;
    }
 
    public static float RemapTo0to1(float value, float from, float to, float skew = 1f)
    {
        if ((to - from) == 0) return 0;
 
        var proportion = Mathf.Clamp01((value - from) / (to - from));
 
        if (skew == 1)
            return proportion;
 
        return Mathf.Pow(proportion, skew);
    }
 
 
    public static float RemapFrom0to1(float value, float from, float to, float skew = 1f)
    {
        if (skew == 0) return to;
 
        var proportion = Mathf.Clamp01(value);
 
        if (skew != 1 && proportion > 0)
            proportion = Mathf.Exp(Mathf.Log(proportion) / skew);
 
        return from + (to - from) * proportion;
    }
 
    public static MYFLT[] ConvertToMYFLT(float[] samples)
    {
        if (samples == null || samples.Length == 0) return new MYFLT[0];
        var myFLT = new MYFLT[samples.Length];
        for (var i = 0; i < myFLT.Length; i++)
        {
            myFLT[i] = (MYFLT)samples[i];
        }
        return myFLT;
    }
 
    public static float[] ConvertToFloat(MYFLT[] samples)
    {
        if (samples == null || samples.Length == 0) return new float[0];
        var flt = new float[samples.Length];
        for (var i = 0; i < flt.Length; i++)
        {
            flt[i] = (float)samples[i];
        }
        return flt;
    }
 
    public static MYFLT[] GetStereoSamples(string source)
    {
        return GetSamples(source, 0, true);
    }
 
    public static float[] GetStereoFloatSamples(string source)
    {
        return ConvertToFloat(GetSamples(source, 0, true));
    }
 
    public static MYFLT[] GetMonoSamples(string source, int channelNumber)
    {
        return GetSamples(source, channelNumber, false);
    }
 
    public static float[] GetMonoFloatSamples(string source, int channelNumber)
    {
        return ConvertToFloat(GetSamples(source, channelNumber, false));
    }
 
    public static MYFLT[] GetSamples(string source, int channelNumber = 1, bool writeChannelData = false)
    {
        MYFLT[] res = new MYFLT[0];
 
        var src = Resources.Load<AudioClip>(source);
        if (src == null)
        {
            Debug.LogError($"Couldn't load samples from AudioClip {source}");
            return res;
        }
 
        var data = new float[src.samples * src.channels];
        src.GetData(data, 0);
 
        if (writeChannelData)
        {
            res = new MYFLT[src.samples * src.channels + 1];
            res[0] = src.channels;
            var s = 1;
            for (var i = 0; i < data.Length; i++)
            {
                res[s] = data[i];
                s++;
            }
        }
        else
        {
            var s = 0;
            res = new MYFLT[src.samples];
 
            for (var i = 0; i < data.Length; i += src.channels, s++)
            {
                res[s] = data[i + (channelNumber - 1)];
            }
        }
 
        return res;
    }
 
    public static float[] GetFloatSamples(string source, int channelNumber = 1, bool writeChannelData = false)
    {
        return ConvertToFloat(GetSamples(source, channelNumber, writeChannelData));
    }
 
    public static IEnumerator GetSamples(string source, SamplesOrigin origin, Action<MYFLT[]> onSamplesLoaded)
    {
        switch (origin)
        {
            case SamplesOrigin.Resources:
                var req = Resources.LoadAsync<AudioClip>(source);
 
                while (!req.isDone)
                {
                    yield return null;
                }
                var samples = ((AudioClip)req.asset).samples;
                if (samples == 0)
                {
                    onSamplesLoaded?.Invoke(null);
                    yield break;
                }
                onSamplesLoaded?.Invoke(GetSamples((AudioClip)req.asset));
                break;
            case SamplesOrigin.StreamingAssets:
                var path = Path.Combine(Application.streamingAssetsPath, source);
                yield return LoadingClip(path, (clip) =>
                {
                    onSamplesLoaded?.Invoke(GetSamples(clip));
                });
                break;
            case SamplesOrigin.Absolute:
                yield return LoadingClip(source, (clip) =>
                {
                    onSamplesLoaded?.Invoke(GetSamples(clip));
                });
                break;
        }
    }
 
    public static MYFLT[] GetSamples(AudioClip audioClip)
    {
        var data = new float[audioClip.samples * audioClip.channels];
        audioClip.GetData(data, 0);
        MYFLT[] res = new MYFLT[data.Length];
        var s = 0;
        foreach (var d in data)
        {
            res[s] = (MYFLT)d;
            s++;
        }
        return res;
    }
 
    static IEnumerator LoadingClip(string path, Action<AudioClip> onEnd)
    {
        var ext = Path.GetExtension(path);
        AudioType type;
 
        switch (ext)
        {
            case "mp3":
            case "MP3": type = AudioType.MPEG; break;
            case "ogg":
            case "OGG": type = AudioType.OGGVORBIS; break;
            case "wav":
            case "WAV":
            default: type = AudioType.WAV; break;
        }
 
#if UNITY_ANDROID
        path = "file://" + path;
#elif UNITY_IPHONE
        path = "file:///" + path;
#endif
 
        using (var req = UnityWebRequestMultimedia.GetAudioClip(path, type))
        {
            yield return req.SendWebRequest();
 
#if UNITY_2020_1_OR_NEWER
            if (req.result == UnityWebRequest.Result.ConnectionError ||
                req.result == UnityWebRequest.Result.DataProcessingError ||
                req.result == UnityWebRequest.Result.ProtocolError)
            {
                Debug.LogError($"Couldn't load file at path: {path} \n{req.error}");
                onEnd?.Invoke(null);
                yield break;
            }
#else
            if (req.isHttpError || req.isNetworkError)
            {
                Debug.LogError($"Couldn't load file at path: {path} \n{req.error}");
                onEnd?.Invoke(null);
                yield break;
            }
#endif
            var clip = DownloadHandlerAudioClip.GetContent(req);
 
            if (clip == null)
            {
                Debug.LogError("The loaded clip is null!");
                yield break;
            }
 
            clip.name = Path.GetFileName(path);
            onEnd?.Invoke(clip);
        }
    }
 
    public void CsoundReset()
    {
        csound.Reset();
    }
 
    public void Cleanup()
    {
        csound.Cleanup();
    }
 
    #region PRESETS
 
    public static CsoundUnityPreset CreatePreset(string presetName, string csoundFileName, List<CsoundChannelController> channels)
    {
        var preset = ScriptableObject.CreateInstance<CsoundUnityPreset>();
        preset.name = preset.presetName = string.IsNullOrWhiteSpace(presetName) ? "CsoundUnityPreset" : presetName;
        preset.csoundFileName = csoundFileName;
        preset.channels = new List<CsoundChannelController>();
        foreach (var chan in channels)
        {
            var newChan = chan.Clone();
            preset.channels.Add(newChan);
        }
        return preset;
    }
 
    public static CsoundUnityPreset CreatePreset(string presetName, string presetData)
    {
        var preset = ScriptableObject.CreateInstance<CsoundUnityPreset>();
 
        // try and create a CsoundUnityPreset from presetData
        try
        {
            JsonUtility.FromJsonOverwrite(presetData, preset);
        }
        catch (ArgumentException ex)
        {
            Debug.LogError($"Couldn't set Preset {presetName}, {ex.Message}");
            return null;
        }
        preset.name = preset.presetName = string.IsNullOrWhiteSpace(presetName) ?
            string.IsNullOrWhiteSpace(preset.presetName) ?
                "CsoundUnityPreset" : preset.presetName : presetName;
 
        return preset;
    }
 
    public static void WritePreset(CsoundUnityPreset preset, string path)
    {
#if UNITY_EDITOR
        // create target directory if it doesn't exist, defaulting to "Assets"
        if (string.IsNullOrWhiteSpace(path) || !path.Contains("Assets"))
        {
            Debug.LogWarning("CsoundUnityPreset scriptable object cannot be created outside of the project folder, " +
                "defaulting to 'Assets'. Use the JSON format to save it outside of the Application.dataPath folder.");
            path = Application.dataPath;
        }
 
        // convert to a path inside the project
        var assetsIndex = path.IndexOf("Assets");
 
        if (assetsIndex < "Assets".Length)
        {
            Debug.LogError("Error, couldn't find the Assets folder!");
            return;
        }
 
        path = path.Substring(assetsIndex, path.Length - assetsIndex);
 
        if (!File.Exists(path))
        {
            Directory.CreateDirectory(path);
        }
 
        var fullPath = Path.Combine(path, $"{preset.presetName}.asset");//path + $"{preset.presetName}.asset";//
        if (AssetDatabase.LoadAssetAtPath<CsoundUnityPreset>(fullPath) != null)
        {
            var assetLength = ".asset".Length;
            var basePath = $"{fullPath.Substring(0, fullPath.Length - assetLength)}";
            var baseName = preset.presetName;
            var overwriteAction = new Action(() =>
            {
                AssetDatabase.DeleteAsset(fullPath);
                AssetDatabase.CreateAsset(preset, fullPath);
                Debug.Log($"Overwriting CsoundUnityPreset at path {fullPath}");
            });
            var renameAction = new Action(() =>
            {
                var count = 0;
                while (AssetDatabase.LoadAssetAtPath<CsoundUnityPreset>(fullPath) != null)
                {
                    preset.presetName = $"{baseName}_{count}";
                    fullPath = $"{basePath}_{count}.asset";
                    count++;
                }
 
                Debug.Log($"Saving CsoundUnityPreset at path {fullPath}");
                AssetDatabase.CreateAsset(preset, fullPath);
            });
 
            var message = $"CsoundUnityPreset at {fullPath} already exists, overwrite or rename?";
            var res = EditorUtility.DisplayDialogComplex("Overwrite?", message, "Overwrite", "Cancel", "Rename");
            switch (res)
            {
                case 0:
                    overwriteAction.Invoke();
                    break;
                case 1:
                    // do nothing if cancel
                    break;
                case 2:
                    renameAction.Invoke();
                    break;
            }
        }
        else
        {
            Debug.Log($"Creating new CsoundUnityPreset at {fullPath}");
            AssetDatabase.CreateAsset(preset, fullPath);
        }
        AssetDatabase.SaveAssets();
        AssetDatabase.Refresh();
#endif
    }
 
    public void SavePresetAsScriptableObject(string presetName, string path = null)
    {
#if UNITY_EDITOR
        var preset = CreatePreset(presetName, this.csoundFileName, this.channels);
        WritePreset(preset, path);
#endif
    }
 
    public static void SavePresetAsJSON(CsoundUnityPreset preset, string path = null, bool overwriteIfExisting = false)
    {
        var fullPath = CheckPathForExistence(path, preset.presetName, overwriteIfExisting);
        var presetData = JsonUtility.ToJson(preset, true);
        try
        {
            Debug.Log($"Saving JSON preset at {fullPath}");
            File.WriteAllText($"{fullPath}", presetData);
        }
        catch (IOException ex)
        {
            Debug.Log(ex.Message);
        }
#if UNITY_EDITOR
        AssetDatabase.Refresh();
#endif
    }
 
    public static void SavePresetAsJSON(List<CsoundChannelController> channels, string csoundFileName, string presetName, string path = null, bool overwriteIfExisting = false)
    {
        var preset = ScriptableObject.CreateInstance<CsoundUnityPreset>();
        preset.channels = channels;
        presetName = string.IsNullOrWhiteSpace(presetName) ? "CsoundUnityPreset" : presetName;
        preset.presetName = presetName;
        preset.csoundFileName = csoundFileName;
        SavePresetAsJSON(preset, path, overwriteIfExisting);
    }
 
    public void SavePresetAsJSON(string presetName, string path = null, bool overwriteIfExisting = false)
    {
        var preset = ScriptableObject.CreateInstance<CsoundUnityPreset>();
        preset.channels = this.channels;
        presetName = string.IsNullOrWhiteSpace(presetName) ? "CsoundUnityPreset" : presetName;
        preset.presetName = presetName;
        preset.csoundFileName = this.csoundFileName;
        SavePresetAsJSON(preset, path, overwriteIfExisting);
    }
 
    public void SaveGlobalPreset(string presetName, string path = null, bool overwriteIfExisting = false)
    {
        var presetData = JsonUtility.ToJson(this, true);
        try
        {
            var name = $"{presetName} {GLOBAL_TAG}";
            var fullPath = CheckPathForExistence(path, name, overwriteIfExisting);
            Debug.Log($"Saving global preset at {fullPath}");
            File.WriteAllText(fullPath, presetData);
        }
        catch (IOException ex)
        {
            Debug.Log(ex.Message);
        }
#if UNITY_EDITOR
        AssetDatabase.Refresh();
#endif
    }
 
    public void ConvertPresetToScriptableObject(string path, string destination)
    {
#if UNITY_EDITOR
        //Debug.Log($"ConvertPresetToScriptableObject at path: {path}, to dest: {destination}");
        LoadPreset(path, (preset) =>
        {
            //Debug.Log($"Loaded Preset Name: {preset.presetName}");
            WritePreset(preset, destination);
        });
#endif
    }
 
    public CsoundUnityPreset SetPreset(string presetName, string presetData)
    {
        var preset = CreatePreset(presetName, presetData);
        SetPreset(preset);
        return preset;
    }
 
    public CsoundUnityPreset SetPreset(string presetData)
    {
        return SetPreset("", presetData);
    }
 
    public void SetPreset(CsoundUnityPreset preset)
    {
        if (this.csoundFileName != preset.csoundFileName)
        {
            Debug.LogError($"Couldn't set preset {preset.presetName} to this CsoundUnity instance {this.name}, " +
                $"this instance uses csd: {this.csoundFileName}, the preset was saved with csd: {preset.csoundFileName} instead");
            return;
        }
        if (preset == null)
        {
            Debug.LogError("Couldn't load a null CsoundUnityPreset!");
        }
 
        _currentPreset = preset.presetName;
        SetChannels(preset.channels, true);
    }
 
    public CsoundUnity SetGlobalPreset(string presetName, string presetData)
    {
        JsonUtility.FromJsonOverwrite(presetData, this);
        // update the serialized channels 
        SetChannels(this.channels, true);
        var current = string.IsNullOrWhiteSpace(presetName) ? this._currentPreset : presetName;
        _currentPreset = $"{current} {GLOBAL_TAG}";
        return this;
    }
 
    public void LoadPreset(string path, Action<CsoundUnityPreset> onPresetLoaded = null)
    {
        var presetName = Path.ChangeExtension(Path.GetFileName(path), null);
 
#if (UNITY_ANDROID || UNITY_IOS) && !UNITY_EDITOR
        StartCoroutine(LoadingData(path, (d) =>
        {
            if (d == null)
            {
                onPresetLoaded?.Invoke(null);
            }
            var preset = CreatePreset(presetName, d);
            onPresetLoaded?.Invoke(preset);
        }));
#else
        if (!File.Exists(path))
        {
            Debug.LogError($"Preset JSON not found at path {path}");
            return;
        }
        var data = File.ReadAllText(path);
        var preset = CreatePreset(presetName, data);
        if (preset == null)
        {
            Debug.LogError("Couldn't create preset from path: {path}");
            onPresetLoaded?.Invoke(null);
            return;
        }
        onPresetLoaded?.Invoke(preset);
#endif
    }
 
    public void LoadGlobalPreset(string path)
    {
        var presetName = Path.GetFileName(path);
 
#if UNITY_ANDROID || UNITY_IOS
        StartCoroutine(LoadingData(path, (d) =>
        {
            SetGlobalPreset(presetName, d);
        }));
#else
        if (!File.Exists(path))
        {
            Debug.LogError($"Global Preset JSON not found at path {path}");
            return;
        }
        var data = File.ReadAllText(path);
        SetGlobalPreset(presetName, data);
#endif
    }
 
    public static List<CsoundUnityPreset> ParseSnap(string csdPath, string snapPath)
    {
        //Debug.Log($"Parse snap: csdPath: {csdPath}, snapPath: {snapPath}");
 
        var snap = File.ReadAllText(snapPath);
        var snapStart = snap.IndexOf("{");
        var snapEnd = snap.LastIndexOf("}");
        var presets = snap.Substring(snapStart + 1, snapEnd - snapStart - 2);
        var csdName = Path.GetFileName(csdPath);
 
        //Debug.Log($"presets: {presets}");
        var parsedPresets = ParsePresets(csdName, presets);
        var originalChannels = ParseCsdFile(csdPath);
        if (originalChannels == null || originalChannels.Count == 0)
        {
            if (originalChannels == null || originalChannels.Count == 0)
            {
                Debug.LogWarning($"Couldn't fix preset channels for snap {snapPath}, csd path: {csdPath}, preset channels will not be visible on Editor, " +
                    $"but you should still be able to use them. Be aware that Comboboxes will be broken. " +
                    $"Please ensure that a '.csd' file with the same name of the '.snaps' file is present at the same location.");
                return parsedPresets;
            }
        }
        foreach (var preset in parsedPresets)
        {
            FixPresetChannels(originalChannels, preset.channels);
        }
        Debug.Log($"originalChannels: {originalChannels.Count}");
        return parsedPresets;
    }
 
    private static List<CsoundUnityPreset> ParsePresets(string snapName, string presets)
    {
        var parsedPresets = new List<CsoundUnityPreset>();
        var splitPresets = presets.Split(new string[] { "}," }, StringSplitOptions.None);
 
        foreach (var preset in splitPresets)
        {
            //Debug.Log($"--> preset: {preset}");
            parsedPresets.Add(ParsePreset(snapName, preset));
        }
 
        //foreach (var preset in parsedPresets)
        //{
        //    Debug.Log($"<color=green>Preset: {preset.presetName}, csd: {preset.csoundFileName}, num channels: {preset.channels.Count}</color>");
        //    foreach (var channel in preset.channels)
        //    {
        //        Debug.Log($"<color=orange>Channel: {channel.channel} = {channel.value}</color>");
        //    }
        //}
        return parsedPresets;
    }
 
    private static CsoundUnityPreset ParsePreset(string snapName, string preset)
    {
        var presetNameStart = preset.IndexOf("\"");
        var subPreset = preset.Substring(presetNameStart + 1, preset.Length - presetNameStart - 1);
        //Debug.Log($"SubPreset: {subPreset}");
        var presetNameEnd = subPreset.IndexOf("\"");
        var presetName = subPreset.Substring(0, presetNameEnd);
        //Debug.Log($"--> presetName: {presetName}");
        var presetContentStart = preset.IndexOf("{");
        var presetContent = preset.Substring(presetContentStart + 1, preset.Length - presetContentStart - 1);
        //Debug.Log($"presetContent: {presetContent}");
        var splitPresetContent = presetContent.Split(new string[] { "," }, StringSplitOptions.None);
        var presetChannels = new List<CsoundChannelController>();
        foreach (var chan in splitPresetContent)
        {
            //Debug.Log($"chan: {chan}");
            presetChannels.Add(ParseChannel(chan).Clone());
        }
 
        return CreatePreset(presetName, snapName, presetChannels);
    }
 
    private static CsoundChannelController ParseChannel(string chan)
    {
        var split = chan.Split(new string[] { ":" }, StringSplitOptions.None);
        var chanName = split[0];//.Replace('"', new char());
        var chanValue = split[1];
        //Debug.Log($"Channel Name: {chanName}, Value: {chanValue}");
        var cleanChanName = chanName.Replace("\"", "").Trim(); //Trim(new char[] { '"' });
        float.TryParse(chanValue, out float chanValueFloat);
        //Debug.Log($"Clean chan name: {cleanChanName}, float value: {chanValueFloat}");
        var cc = new CsoundChannelController()
        {
            channel = cleanChanName,
            value = chanValueFloat
        };
        //Debug.Log($"Created channel controller: {cc.channel}, value: {cc.value}");
        return cc;
    }
 
    private static void FixPresetChannels(List<CsoundChannelController> originalChannels, List<CsoundChannelController> channelsToFix)
    {
        if (originalChannels == null || originalChannels.Count == 0)
        {
            Debug.LogError("Couldn't fix preset channels, aborting");
            return;
        }
 
        foreach (var chanToFix in channelsToFix)
        {
            foreach (var chan in originalChannels)
            {
                if (chan.channel == chanToFix.channel)
                {
                    // channel and value come from the Cabbage snap
                    // but not all the other fields
                    // set all the missing fields
                    chanToFix.caption = chan.caption;
                    chanToFix.increment = chan.increment;
                    chanToFix.max = chan.max;
                    chanToFix.min = chan.min;
                    chanToFix.options = chan.options;
                    chanToFix.skew = chan.skew;
                    chanToFix.text = chan.text;
                    chanToFix.type = chan.type;
 
                    // also fix the combobox index?
                    if (chanToFix.type.Equals("combobox"))
                    {
                        chanToFix.value -= 1;
                    }
                }
            }
        }
    }
 
    static IEnumerator LoadingData(string path, Action<string> onDataLoaded)
    {
        Debug.Log($"Loading JSON data from path: {path}");
        using (var request = UnityWebRequest.Get(path))
        {
            request.downloadHandler = new DownloadHandlerBuffer();
            yield return request.SendWebRequest();
            if (request.isNetworkError || request.isHttpError)
            {
                Debug.Log($"Couldn't load data at path: {path}: {request.error}");
                onDataLoaded?.Invoke(null);
                yield break;
            }
            var data = request.downloadHandler.text;
            onDataLoaded?.Invoke(data);
        }
    }
 
    private static string CheckPathForExistence(string path, string presetName, bool overwriteIfExisting)
    {
        path = string.IsNullOrWhiteSpace(path) ?
            Application.persistentDataPath
            : path;
        if (!char.IsSeparator(path[path.Length - 1]))
        {
            path = $"{path}/";
        }
 
        if (!Directory.Exists(path))
        {
            try
            {
                Directory.CreateDirectory(path);
            }
            catch (IOException ex)
            {
                Debug.LogError($"Couldn't create folder at: {path}, defaulting to {Application.persistentDataPath} {ex.Message}");
                path = Application.persistentDataPath;
            }
        }
 
        var fullPath = Path.Combine(path, presetName + ".json");
 
        var count = 0;
        while (File.Exists(fullPath) && !overwriteIfExisting)
        {
            fullPath = Path.Combine(path, $"{presetName}_{count++}.json");
        }
        return fullPath;
    }
 
    #endregion PRESETS
 
    #endregion UTILITIES
 
    #endregion PUBLIC_METHODS
 
 
    #region ENUMS
 
    public enum EnvType
    {
        SFDIR,
 
        SSDIR,
 
        SADIR,
 
        SFOUTYP,
 
        INCDIR,
 
        OPCODE6DIR,
 
        OPCODE6DIR64,
 
        SNAPDIR,
 
        CSOUNDRC,
        CSSTRNGS,
 
        CS_LANG,
 
        RAWWAVE_PATH,
 
        CSNOSTOP,
 
        MFDIR,
 
        CS_OMIT_LIBS
    }
 
    public enum SamplesOrigin { Resources, StreamingAssets, Absolute } // TODO Add PersistentDataPath and URL
 
    #endregion ENUMS
 
 
    #region PRIVATE_METHODS
 
    void OnAudioFilterRead(float[] data, int channels)
    {
        if (csound != null)
        {
            ProcessBlock(data, channels);
        }
    }
 
    private void ProcessBlock(float[] samples, int numChannels)
    {
        if (compiledOk && initialized && !_quitting)
        {
            for (int i = 0; i < samples.Length; i += numChannels, ksmpsIndex++)
            {
                for (uint channel = 0; channel < numChannels; channel++)
                {
                    // necessary to avoid calling csound functions when quitting while reading this block of samples
                    // always remember OnAudioFilterRead runs on a different thread
                    if (_quitting) return;
 
                    if (mute == true)
                        samples[i + channel] = 0.0f;
                    else
                    {
                        if ((ksmpsIndex >= GetKsmps()) && (GetKsmps() > 0))
                        {
                            var res = PerformKsmps();
                            performanceFinished = res == 1;
                            ksmpsIndex = 0;
 
                            foreach (var chanName in availableAudioChannels)
                            {
                                if (!namedAudioChannelTempBufferDict.ContainsKey(chanName)) continue;
                                namedAudioChannelTempBufferDict[chanName] = GetAudioChannel(chanName);
                            }
                        }
 
                        if (processClipAudio)
                        {
                            SetInputSample((int)ksmpsIndex, (int)channel, samples[i + channel] * zerdbfs);
                        }
 
                        //if csound nChnls are more than the current channel, set the last csound channel available on the sample (assumes GetNchnls above 0)
                        var outputSampleChannel = channel < GetNchnls() ? channel : GetNchnls() - 1;
                        var output = (float)GetOutputSample((int)ksmpsIndex, (int)outputSampleChannel) / zerdbfs;
                        // multiply Csound output by the sample value to maintain spatialization set by Unity. 
                        // don't multiply if reading from a clip: this should maintain the spatialization of the clip anyway
                        samples[i + channel] = processClipAudio ? output : samples[i + channel] * output;
 
                        if (loudVolumeWarning && (samples[i + channel] > loudWarningThreshold))
                        {
                            samples[i + channel] = 0.0f;
                            Debug.LogWarning("Volume is too high! Clearing output");
                        }
                    }
                }
 
                // update the audioChannels just when this instance is not muted
                if (!mute)
                    foreach (var chanName in availableAudioChannels)
                    {
                        if (!namedAudioChannelDataDict.ContainsKey(chanName) || !namedAudioChannelTempBufferDict.ContainsKey(chanName)) continue;
                        namedAudioChannelDataDict[chanName][i / numChannels] = namedAudioChannelTempBufferDict[chanName][ksmpsIndex];
                    }
            }
        }
    }
 
    void LogCsoundMessages()
    {
        //print Csound message to Unity console....
        for (int i = 0; i < csound.GetCsoundMessageCount(); i++)
            print(csound.GetCsoundMessage());
    }
 
    IEnumerator Logging(float interval)
    {
        while (true)
        {
            while (this.logCsoundOutput)
            {
                for (int i = 0; i < csound.GetCsoundMessageCount(); i++)
                {
                    if (this.logCsoundOutput)    // exiting when csound messages are very high in number 
                    {
                        print(csound.GetCsoundMessage());
                        yield return null;          //avoids Unity stuck on performance end
                    }
                }
                yield return new WaitForSeconds(interval);
            }
            yield return null; //wait one frame
        }
    }
 
 
    private void ResetFields()
    {
#if UNITY_EDITOR
        this._csoundAsset = null;
#endif
 
        this._csoundFileName = null;
        this._csoundString = null;
        this._csoundFileGUID = string.Empty;
 
        this._channels.Clear();
        this._availableAudioChannels.Clear();
 
        this.namedAudioChannelDataDict.Clear();
        this.namedAudioChannelTempBufferDict.Clear();
    }
 
    private bool _quitting = false;
    void OnApplicationQuit()
    {
        _quitting = true;
        if (LoggingCoroutine != null)
            StopCoroutine(LoggingCoroutine);
 
        if (csound != null)
        {
            csound.OnApplicationQuit();
        }
    }
 
    #endregion PRIVATE_METHODS
}