Nota — a free DAW for macOS, Windows and Linux. No subscription, no account — just open it and make music.
C# audioaudio-unitavaloniacpp20cross-platformdawdigital-audio-workstationdspjucelinux-audiomcp-servermidimusicmusic-productionpiano-rollplugin-hostsequencersynthesizervstvst3
// SPDX-License-Identifier: AGPL-3.0-only
// Copyright (c) 2026 Egor Khindikaynen (Nota). See LICENSES/ for license terms.
using System.Runtime.InteropServices;
using Nota.Application;
namespace Nota.Infrastructure;
public sealed partial class NotaEngine
{
// --- Instrument Rack ----------------------------------------------------
// Parallel chains (instrument + insert devices), per-chain controls and 8
// macros with parameter mappings. Addressed by (trackId, chain, dev, param).
public int AddInstrumentRackTrack()
{
ThrowIfDisposed();
int id = NativeMethods.AddInstrumentRackTrack(_handle);
if (id <= 0) throw new NotaEngineException("Failed to create an Instrument Rack track.");
return id;
}
public int AddDrumRackTrack()
{
ThrowIfDisposed();
int id = NativeMethods.AddDrumRackTrack(_handle);
if (id <= 0) throw new NotaEngineException("Failed to create a Drum Rack track.");
return id;
}
public int RackAddSamplerChain(int trackId, string path, int rootNote, bool loop)
{
ThrowIfDisposed();
int c = NativeMethods.RackAddSamplerChain(_handle, trackId, path, rootNote, loop ? 1 : 0);
if (c >= 0 && RackChainSamplerInfo(trackId, c, out var si)) RememberSampleName(si.SampleId, path);
return c;
}
public bool RackSetChainSamplerSample(int trackId, int chain, string path, int rootNote)
{
ThrowIfDisposed();
bool ok = NativeMethods.RackSetChainSamplerSample(_handle, trackId, chain, path, rootNote) != 0;
if (ok && RackChainSamplerInfo(trackId, chain, out var si)) RememberSampleName(si.SampleId, path);
return ok;
}
public void RackOpenChainInstrumentEditor(int trackId, int chain)
{ ThrowIfDisposed(); NativeMethods.RackOpenChainInstrumentEditor(_handle, trackId, chain); }
public void RackOpenChainDeviceEditor(int trackId, int chain, int dev)
{ ThrowIfDisposed(); NativeMethods.RackOpenChainDeviceEditor(_handle, trackId, chain, dev); }
public string RackChainInstrumentPluginId(int trackId, int chain)
{ ThrowIfDisposed(); return Marshal.PtrToStringUTF8(NativeMethods.RackChainInstrumentPluginId(_handle, trackId, chain)) ?? ""; }
public byte[] RackGetChainInstrumentState(int trackId, int chain)
{
ThrowIfDisposed();
int size = NativeMethods.RackChainInstrumentGetState(_handle, trackId, chain, null, 0);
if (size <= 0) return System.Array.Empty<byte>();
var buf = new byte[size];
NativeMethods.RackChainInstrumentGetState(_handle, trackId, chain, buf, size);
return buf;
}
public int RackAddPluginInstrumentChain(int trackId, int catalogIndex)
{ ThrowIfDisposed(); return NativeMethods.RackAddPluginInstrumentChain(_handle, trackId, catalogIndex); }
public int RackAddPluginChainDevice(int trackId, int chain, int catalogIndex)
{ ThrowIfDisposed(); return NativeMethods.RackAddPluginChainDevice(_handle, trackId, chain, catalogIndex); }
public int RackChainTriggerNote(int trackId, int chain)
{ ThrowIfDisposed(); return NativeMethods.RackChainTriggerNote(_handle, trackId, chain); }
public void RackSetChainTriggerNote(int trackId, int chain, int note)
{ ThrowIfDisposed(); NativeMethods.RackSetChainTriggerNote(_handle, trackId, chain, note); }
public string RackChainName(int trackId, int chain)
{ ThrowIfDisposed(); return Marshal.PtrToStringUTF8(NativeMethods.RackChainName(_handle, trackId, chain)) ?? ""; }
public void RackSetChainName(int trackId, int chain, string name)
{ ThrowIfDisposed(); NativeMethods.RackSetChainName(_handle, trackId, chain, name ?? ""); }
public int RackChainCount(int trackId)
{ ThrowIfDisposed(); return NativeMethods.RackChainCount(_handle, trackId); }
public int RackAddChain(int trackId, int instKind)
{ ThrowIfDisposed(); return NativeMethods.RackAddChain(_handle, trackId, instKind); }
public bool RackRemoveChain(int trackId, int chain)
{ ThrowIfDisposed(); return NativeMethods.RackRemoveChain(_handle, trackId, chain) != 0; }
public bool RackSetChainInstrument(int trackId, int chain, int instKind)
{ ThrowIfDisposed(); return NativeMethods.RackSetChainInstrument(_handle, trackId, chain, instKind) != 0; }
public int RackChainInstrumentKind(int trackId, int chain)
{ ThrowIfDisposed(); return NativeMethods.RackChainInstrumentKind(_handle, trackId, chain); }
public string RackChainInstrumentName(int trackId, int chain)
{ ThrowIfDisposed(); return Marshal.PtrToStringUTF8(NativeMethods.RackChainInstrumentName(_handle, trackId, chain)) ?? ""; }
public int RackChainInstrumentParamCount(int trackId, int chain)
{ ThrowIfDisposed(); return NativeMethods.RackChainInstrumentParamCount(_handle, trackId, chain); }
public string RackChainInstrumentParamName(int trackId, int chain, int param)
{ ThrowIfDisposed(); return Marshal.PtrToStringUTF8(NativeMethods.RackChainInstrumentParamName(_handle, trackId, chain, param)) ?? ""; }
public string RackChainInstrumentParamId(int trackId, int chain, int param)
{ ThrowIfDisposed(); return Marshal.PtrToStringUTF8(NativeMethods.RackChainInstrumentParamId(_handle, trackId, chain, param)) ?? ""; }
public float RackChainInstrumentParamGet(int trackId, int chain, int param)
{ ThrowIfDisposed(); return NativeMethods.RackChainInstrumentParamGet(_handle, trackId, chain, param); }
public void RackChainInstrumentParamSet(int trackId, int chain, int param, float normalized)
{ ThrowIfDisposed(); NativeMethods.RackChainInstrumentParamSet(_handle, trackId, chain, param, normalized); }
public float RackChainInstrumentParamDefault(int trackId, int chain, int param)
{ ThrowIfDisposed(); return NativeMethods.RackChainInstrumentParamDefault(_handle, trackId, chain, param); }
public int RackChainInstrumentScope(int trackId, int chain, float[] outv)
{ ThrowIfDisposed(); return NativeMethods.RackChainInstrumentScope(_handle, trackId, chain, outv, outv.Length); }
public int RackChainInstrumentVoiceCount(int trackId, int chain)
{ ThrowIfDisposed(); return NativeMethods.RackChainInstrumentVoiceCount(_handle, trackId, chain); }
public int RackChainInstrumentHeldNotes(int trackId, int chain, int[] outNotes)
{ ThrowIfDisposed(); return NativeMethods.RackChainInstrumentHeldNotes(_handle, trackId, chain, outNotes, outNotes.Length); }
public void RackChainInstrumentAction(int trackId, int chain, int id, int iarg, float farg)
{ ThrowIfDisposed(); NativeMethods.RackChainInstrumentAction(_handle, trackId, chain, id, iarg, farg); }
public bool RackSetChainInstrumentStateUndoable(int trackId, int chain, byte[] data)
{ ThrowIfDisposed(); return NativeMethods.RackChainInstrumentSetStateUndoable(_handle, trackId, chain, data, data.Length) != 0; }
public bool RackChainInstrumentRecordStateUndo(int trackId, int chain, byte[] before)
{ ThrowIfDisposed(); return NativeMethods.RackChainInstrumentRecordStateUndo(_handle, trackId, chain, before, before.Length) != 0; }
public bool RackDevChainInstrumentRecordStateUndo(int trackId, int deviceIndex, int chain, byte[] before)
{ ThrowIfDisposed(); return NativeMethods.RackDevChainInstrumentRecordStateUndo(_handle, trackId, deviceIndex, chain, before, before.Length) != 0; }
public bool RackChainSamplerInfo(int trackId, int chain, out NotaSamplerInfo info)
{ ThrowIfDisposed(); return NativeMethods.RackChainSamplerInfo(_handle, trackId, chain, out info) != 0; }
public bool RackSetChainSamplerRoot(int trackId, int chain, int rootNote)
{ ThrowIfDisposed(); return NativeMethods.RackSetChainSamplerRoot(_handle, trackId, chain, rootNote) != 0; }
public float RackChainSamplerPlayPosition(int trackId, int chain)
{ ThrowIfDisposed(); return NativeMethods.RackChainSamplerPlayPosition(_handle, trackId, chain); }
public int RackChainDeviceCount(int trackId, int chain)
{ ThrowIfDisposed(); return NativeMethods.RackChainDeviceCount(_handle, trackId, chain); }
public int RackAddChainDevice(int trackId, int chain, int deviceKind)
{ ThrowIfDisposed(); return NativeMethods.RackAddChainDevice(_handle, trackId, chain, deviceKind); }
public bool RackRemoveChainDevice(int trackId, int chain, int dev)
{ ThrowIfDisposed(); return NativeMethods.RackRemoveChainDevice(_handle, trackId, chain, dev) != 0; }
public bool RackMoveChainDevice(int trackId, int chain, int fromIndex, int toIndex)
{ ThrowIfDisposed(); return NativeMethods.RackMoveChainDevice(_handle, trackId, chain, fromIndex, toIndex) != 0; }
public string RackChainDeviceName(int trackId, int chain, int dev)
{ ThrowIfDisposed(); return Marshal.PtrToStringUTF8(NativeMethods.RackChainDeviceName(_handle, trackId, chain, dev)) ?? ""; }
public int RackChainDeviceBuiltinKind(int trackId, int chain, int dev)
{ ThrowIfDisposed(); return NativeMethods.RackChainDeviceBuiltinKind(_handle, trackId, chain, dev); }
public int RackChainDeviceParamCount(int trackId, int chain, int dev)
{ ThrowIfDisposed(); return NativeMethods.RackChainDeviceParamCount(_handle, trackId, chain, dev); }
public string RackChainDeviceParamName(int trackId, int chain, int dev, int param)
{ ThrowIfDisposed(); return Marshal.PtrToStringUTF8(NativeMethods.RackChainDeviceParamName(_handle, trackId, chain, dev, param)) ?? ""; }
public float RackChainDeviceParamMin(int trackId, int chain, int dev, int param)
{ ThrowIfDisposed(); return NativeMethods.RackChainDeviceParamMin(_handle, trackId, chain, dev, param); }
public float RackChainDeviceParamMax(int trackId, int chain, int dev, int param)
{ ThrowIfDisposed(); return NativeMethods.RackChainDeviceParamMax(_handle, trackId, chain, dev, param); }
public float RackChainDeviceParamGet(int trackId, int chain, int dev, int param)
{ ThrowIfDisposed(); return NativeMethods.RackChainDeviceParamGet(_handle, trackId, chain, dev, param); }
public void RackChainDeviceParamSet(int trackId, int chain, int dev, int param, float value)
{ ThrowIfDisposed(); NativeMethods.RackChainDeviceParamSet(_handle, trackId, chain, dev, param, value); }
public void RackSetChainDeviceBypassed(int trackId, int chain, int dev, bool bypassed)
{ ThrowIfDisposed(); NativeMethods.RackSetChainDeviceBypassed(_handle, trackId, chain, dev, bypassed ? 1 : 0); }
public bool RackChainDeviceBypassed(int trackId, int chain, int dev)
{ ThrowIfDisposed(); return NativeMethods.RackChainDeviceBypassed(_handle, trackId, chain, dev) != 0; }
public void RackSetChainGain(int trackId, int chain, float v)
{ ThrowIfDisposed(); NativeMethods.RackSetChainGain(_handle, trackId, chain, v); }
public void RackSetChainPan(int trackId, int chain, float v)
{ ThrowIfDisposed(); NativeMethods.RackSetChainPan(_handle, trackId, chain, v); }
public void RackSetChainMute(int trackId, int chain, bool mute)
{ ThrowIfDisposed(); NativeMethods.RackSetChainMute(_handle, trackId, chain, mute ? 1 : 0); }
public void RackSetChainSolo(int trackId, int chain, bool solo)
{ ThrowIfDisposed(); NativeMethods.RackSetChainSolo(_handle, trackId, chain, solo ? 1 : 0); }
public float RackChainGain(int trackId, int chain)
{ ThrowIfDisposed(); return NativeMethods.RackChainGain(_handle, trackId, chain); }
public float RackChainPan(int trackId, int chain)
{ ThrowIfDisposed(); return NativeMethods.RackChainPan(_handle, trackId, chain); }
public bool RackChainMute(int trackId, int chain)
{ ThrowIfDisposed(); return NativeMethods.RackChainMute(_handle, trackId, chain) != 0; }
public bool RackChainSolo(int trackId, int chain)
{ ThrowIfDisposed(); return NativeMethods.RackChainSolo(_handle, trackId, chain) != 0; }
public float RackMacroGet(int trackId, int macro)
{ ThrowIfDisposed(); return NativeMethods.RackMacroGet(_handle, trackId, macro); }
public void RackMacroSet(int trackId, int macro, float v)
{ ThrowIfDisposed(); NativeMethods.RackMacroSet(_handle, trackId, macro, v); }
public int RackAddMacroMapping(int trackId, int macro, int chain, int deviceIndex, int paramIndex, float rangeMin, float rangeMax)
{ ThrowIfDisposed(); return NativeMethods.RackAddMacroMapping(_handle, trackId, macro, chain, deviceIndex, paramIndex, rangeMin, rangeMax); }
public int RackMappingCount(int trackId)
{ ThrowIfDisposed(); return NativeMethods.RackMappingCount(_handle, trackId); }
public bool RackTryGetMapping(int trackId, int index, out RackMacroMapping mapping)
{
ThrowIfDisposed();
int ok = NativeMethods.RackMappingInfo(_handle, trackId, index,
out int macro, out int chain, out int dev, out int param, out float lo, out float hi);
mapping = new RackMacroMapping(macro, chain, dev, param, lo, hi);
return ok != 0;
}
public bool RackRemoveMapping(int trackId, int index)
{ ThrowIfDisposed(); return NativeMethods.RackRemoveMapping(_handle, trackId, index) != 0; }
public void RackChainZone(int trackId, int chain, out int keyLo, out int keyHi, out int velLo, out int velHi)
{ ThrowIfDisposed(); NativeMethods.RackChainZone(_handle, trackId, chain, out keyLo, out keyHi, out velLo, out velHi); }
public void RackSetChainZone(int trackId, int chain, int keyLo, int keyHi, int velLo, int velHi)
{ ThrowIfDisposed(); NativeMethods.RackSetChainZone(_handle, trackId, chain, keyLo, keyHi, velLo, velHi); }
public float RackChainMeter(int trackId, int chain)
{ ThrowIfDisposed(); return NativeMethods.RackChainMeter(_handle, trackId, chain); }
public string RackMacroName(int trackId, int macro)
{ ThrowIfDisposed(); return Marshal.PtrToStringUTF8(NativeMethods.RackMacroName(_handle, trackId, macro)) ?? ""; }
public void RackSetMacroName(int trackId, int macro, string name)
{ ThrowIfDisposed(); NativeMethods.RackSetMacroName(_handle, trackId, macro, name ?? ""); }
public float RackVolume(int trackId)
{ ThrowIfDisposed(); return NativeMethods.RackVolume(_handle, trackId); }
public void RackSetVolume(int trackId, float v)
{ ThrowIfDisposed(); NativeMethods.RackSetVolume(_handle, trackId, v); }
/// <summary>Copies a chain after itself (children, controls, its mappings); the new index or <0. One undo step.</summary>
public int RackDuplicateChain(int trackId, int chain)
{ ThrowIfDisposed(); return NativeMethods.RackDuplicateChain(_handle, trackId, chain); }
/// <summary>Instrument Rack mono: one note at a time, last-note priority; glide bends between notes.</summary>
public bool RackMono(int trackId)
{ ThrowIfDisposed(); return NativeMethods.RackMono(_handle, trackId) != 0; }
public void RackSetMono(int trackId, bool on)
{ ThrowIfDisposed(); NativeMethods.RackSetMono(_handle, trackId, on ? 1 : 0); }
public float RackGlide(int trackId)
{ ThrowIfDisposed(); return NativeMethods.RackGlide(_handle, trackId); }
public void RackSetGlide(int trackId, float v)
{ ThrowIfDisposed(); NativeMethods.RackSetGlide(_handle, trackId, v); }
public bool RackSetMappingRange(int trackId, int index, float rangeMin, float rangeMax)
{ ThrowIfDisposed(); return NativeMethods.RackSetMappingRange(_handle, trackId, index, rangeMin, rangeMax) != 0; }
public int RackMappingCurve(int trackId, int index)
{ ThrowIfDisposed(); return NativeMethods.RackMappingCurve(_handle, trackId, index); }
public bool RackSetMappingCurve(int trackId, int index, int curve)
{ ThrowIfDisposed(); return NativeMethods.RackSetMappingCurve(_handle, trackId, index, curve) != 0; }
// ---- Drum Rack per-pad shaping + kit-level swing/humanize ----
public void RackSetChainChoke(int trackId, int chain, int group)
{ ThrowIfDisposed(); NativeMethods.RackSetChainChoke(_handle, trackId, chain, group); }
public int RackChainChoke(int trackId, int chain)
{ ThrowIfDisposed(); return NativeMethods.RackChainChoke(_handle, trackId, chain); }
public void RackSetChainTune(int trackId, int chain, int semitones)
{ ThrowIfDisposed(); NativeMethods.RackSetChainTune(_handle, trackId, chain, semitones); }
public int RackChainTune(int trackId, int chain)
{ ThrowIfDisposed(); return NativeMethods.RackChainTune(_handle, trackId, chain); }
public void RackSetChainDecay(int trackId, int chain, float v)
{ ThrowIfDisposed(); NativeMethods.RackSetChainDecay(_handle, trackId, chain, v); }
public float RackChainDecay(int trackId, int chain)
{ ThrowIfDisposed(); return NativeMethods.RackChainDecay(_handle, trackId, chain); }
public void RackSetSwing(int trackId, float v)
{ ThrowIfDisposed(); NativeMethods.RackSetSwing(_handle, trackId, v); }
public float RackSwing(int trackId)
{ ThrowIfDisposed(); return NativeMethods.RackSwing(_handle, trackId); }
public void RackSetHumanize(int trackId, float v)
{ ThrowIfDisposed(); NativeMethods.RackSetHumanize(_handle, trackId, v); }
public float RackHumanize(int trackId)
{ ThrowIfDisposed(); return NativeMethods.RackHumanize(_handle, trackId); }
// specs/041: the Drum Rack card's Rack* surface for any rack address (a nested Drum Rack too).
public int RackDevAddSamplerChain(int trackId, int deviceIndex, string path, int rootNote, bool loop)
{
ThrowIfDisposed();
int c = NativeMethods.RackDevAddSamplerChain(_handle, trackId, deviceIndex, path, rootNote, loop ? 1 : 0);
if (c >= 0 && RackDevChainSamplerInfo(trackId, deviceIndex, c, out var si)) RememberSampleName(si.SampleId, path);
return c;
}
public bool RackDevSetChainSamplerSample(int trackId, int deviceIndex, int chain, string path, int rootNote)
{
ThrowIfDisposed();
bool ok = NativeMethods.RackDevSetChainSamplerSample(_handle, trackId, deviceIndex, chain, path, rootNote) != 0;
if (ok && RackDevChainSamplerInfo(trackId, deviceIndex, chain, out var si)) RememberSampleName(si.SampleId, path);
return ok;
}
public int RackDevAddPluginInstrumentChain(int trackId, int deviceIndex, int catalogIndex)
{ ThrowIfDisposed(); return NativeMethods.RackDevAddPluginInstrumentChain(_handle, trackId, deviceIndex, catalogIndex); }
public string RackDevChainName(int trackId, int deviceIndex, int chain)
{ ThrowIfDisposed(); return Marshal.PtrToStringUTF8(NativeMethods.RackDevChainName(_handle, trackId, deviceIndex, chain)) ?? ""; }
public void RackDevSetChainName(int trackId, int deviceIndex, int chain, string name)
{ ThrowIfDisposed(); NativeMethods.RackDevSetChainName(_handle, trackId, deviceIndex, chain, name ?? ""); }
public int RackDevChainChoke(int trackId, int deviceIndex, int chain)
{ ThrowIfDisposed(); return NativeMethods.RackDevChainChoke(_handle, trackId, deviceIndex, chain); }
public void RackDevSetChainChoke(int trackId, int deviceIndex, int chain, int group)
{ ThrowIfDisposed(); NativeMethods.RackDevSetChainChoke(_handle, trackId, deviceIndex, chain, group); }
public int RackDevChainTune(int trackId, int deviceIndex, int chain)
{ ThrowIfDisposed(); return NativeMethods.RackDevChainTune(_handle, trackId, deviceIndex, chain); }
public void RackDevSetChainTune(int trackId, int deviceIndex, int chain, int semitones)
{ ThrowIfDisposed(); NativeMethods.RackDevSetChainTune(_handle, trackId, deviceIndex, chain, semitones); }
public float RackDevChainDecay(int trackId, int deviceIndex, int chain)
{ ThrowIfDisposed(); return NativeMethods.RackDevChainDecay(_handle, trackId, deviceIndex, chain); }
public void RackDevSetChainDecay(int trackId, int deviceIndex, int chain, float v)
{ ThrowIfDisposed(); NativeMethods.RackDevSetChainDecay(_handle, trackId, deviceIndex, chain, v); }
public float RackDevSwing(int trackId, int deviceIndex)
{ ThrowIfDisposed(); return NativeMethods.RackDevSwing(_handle, trackId, deviceIndex); }
public void RackDevSetSwing(int trackId, int deviceIndex, float v)
{ ThrowIfDisposed(); NativeMethods.RackDevSetSwing(_handle, trackId, deviceIndex, v); }
public float RackDevHumanize(int trackId, int deviceIndex)
{ ThrowIfDisposed(); return NativeMethods.RackDevHumanize(_handle, trackId, deviceIndex); }
public void RackDevSetHumanize(int trackId, int deviceIndex, float v)
{ ThrowIfDisposed(); NativeMethods.RackDevSetHumanize(_handle, trackId, deviceIndex, v); }
public bool RackDevChainSamplerInfo(int trackId, int deviceIndex, int chain, out NotaSamplerInfo info)
{ ThrowIfDisposed(); return NativeMethods.RackDevChainSamplerInfo(_handle, trackId, deviceIndex, chain, out info) != 0; }
public bool RackDevSetChainSamplerRoot(int trackId, int deviceIndex, int chain, int rootNote)
{ ThrowIfDisposed(); return NativeMethods.RackDevSetChainSamplerRoot(_handle, trackId, deviceIndex, chain, rootNote) != 0; }
public float RackDevChainSamplerPlayPosition(int trackId, int deviceIndex, int chain)
{ ThrowIfDisposed(); return NativeMethods.RackDevChainSamplerPlayPosition(_handle, trackId, deviceIndex, chain); }
public string RackDevChainInstrumentParamId(int trackId, int deviceIndex, int chain, int param)
{ ThrowIfDisposed(); return Marshal.PtrToStringUTF8(NativeMethods.RackDevChainInstrumentParamId(_handle, trackId, deviceIndex, chain, param)) ?? ""; }
public float RackDevChainInstrumentParamDefault(int trackId, int deviceIndex, int chain, int param)
{ ThrowIfDisposed(); return NativeMethods.RackDevChainInstrumentParamDefault(_handle, trackId, deviceIndex, chain, param); }
public int RackDevChainInstrumentScope(int trackId, int deviceIndex, int chain, float[] outv)
{ ThrowIfDisposed(); return NativeMethods.RackDevChainInstrumentScope(_handle, trackId, deviceIndex, chain, outv, outv.Length); }
public int RackDevChainInstrumentVoiceCount(int trackId, int deviceIndex, int chain)
{ ThrowIfDisposed(); return NativeMethods.RackDevChainInstrumentVoiceCount(_handle, trackId, deviceIndex, chain); }
public int RackDevChainInstrumentHeldNotes(int trackId, int deviceIndex, int chain, int[] outNotes)
{ ThrowIfDisposed(); return NativeMethods.RackDevChainInstrumentHeldNotes(_handle, trackId, deviceIndex, chain, outNotes, outNotes.Length); }
public void RackDevChainInstrumentAction(int trackId, int deviceIndex, int chain, int id, int iarg, float farg)
{ ThrowIfDisposed(); NativeMethods.RackDevChainInstrumentAction(_handle, trackId, deviceIndex, chain, id, iarg, farg); }
public bool RackDevSetChainInstrumentStateUndoable(int trackId, int deviceIndex, int chain, byte[] data)
{
ThrowIfDisposed();
return NativeMethods.RackDevChainInstrumentSetStateUndoable(_handle, trackId, deviceIndex, chain, data, data.Length) != 0;
}
public void RackDevOpenChainInstrumentEditor(int trackId, int deviceIndex, int chain)
{ ThrowIfDisposed(); NativeMethods.RackDevOpenChainInstrumentEditor(_handle, trackId, deviceIndex, chain); }
public string RackDevChainInstrumentPluginId(int trackId, int deviceIndex, int chain)
{ ThrowIfDisposed(); return Marshal.PtrToStringUTF8(NativeMethods.RackDevChainInstrumentPluginId(_handle, trackId, deviceIndex, chain)) ?? ""; }
public byte[] RackDevGetChainInstrumentState(int trackId, int deviceIndex, int chain)
{
ThrowIfDisposed();
int size = NativeMethods.RackDevChainInstrumentGetState(_handle, trackId, deviceIndex, chain, null, 0);
if (size <= 0) return System.Array.Empty<byte>();
var buf = new byte[size];
NativeMethods.RackDevChainInstrumentGetState(_handle, trackId, deviceIndex, chain, buf, size);
return buf;
}
// Nota Mosaic as a chain instrument (specs/041), as MosaicSetProgram & co. for a track.
public bool RackDevChainMosaicSetProgram(int trackId, int deviceIndex, int chain, string text, bool undoable = true)
{ ThrowIfDisposed(); return NativeMethods.RackDevChainMosaicSetProgram(_handle, trackId, deviceIndex, chain, text ?? "", undoable ? 1 : 0) != 0; }
public unsafe string RackDevChainMosaicProgram(int trackId, int deviceIndex, int chain)
{
ThrowIfDisposed();
int n = NativeMethods.RackDevChainMosaicProgram(_handle, trackId, deviceIndex, chain, null, 0);
if (n <= 0) return "";
var buf = new byte[n];
fixed (byte* p = buf) n = System.Math.Min(n, NativeMethods.RackDevChainMosaicProgram(_handle, trackId, deviceIndex, chain, p, buf.Length));
return System.Text.Encoding.UTF8.GetString(buf, 0, n);
}
public bool RackDevTryGetChainMosaicStatus(int trackId, int deviceIndex, int chain, out NotaMosaicStatus status)
{ ThrowIfDisposed(); return NativeMethods.RackDevChainMosaicStatus(_handle, trackId, deviceIndex, chain, out status) != 0; }
public long RackDevChainMosaicZoneSampleId(int trackId, int deviceIndex, int chain, int zone)
{ ThrowIfDisposed(); return NativeMethods.RackDevChainMosaicZoneSampleId(_handle, trackId, deviceIndex, chain, zone); }
}