Skip to content

armgit / nota

Public Imported from GitHub
0

Nota — a free DAW for macOS, Windows and Linux. No subscription, no account — just open it and make music.

Fix bug with UI not updating for separate windows of instrument

Egor Khindikaynen123be35e8d83
diff --git a/CHANGELOG.md b/CHANGELOG.md
index d1df79e6..a4bbaecc 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -799,6 +799,10 @@ Entry categories: `Added`, `Changed`, `Fixed`, `Removed`.
returns the compressor's status line.
### Fixed
+- **A rack chain's pop-out GUI showed a frozen picture.** Opening **GUI** on an effect or
+ instrument inside an Instrument Rack, Drum Rack or Audio Effect Rack chain showed its real
+ editor, but its meters, scopes, curves and held keys never moved. They now follow that
+ device's own signal live.
- **Rack macro mappings came loose when a chain's effects changed.** Removing or reordering
an effect in an Instrument Rack, Drum Rack or Audio Effect Rack chain left the macros
mapped to whichever device now sat at the old position. A mapping now moves with its
diff --git a/src/managed/Nota.App/DeviceCards/Rack/IRackAccess.cs b/src/managed/Nota.App/DeviceCards/Rack/IRackAccess.cs
index d366eac3..d1868d88 100644
--- a/src/managed/Nota.App/DeviceCards/Rack/IRackAccess.cs
+++ b/src/managed/Nota.App/DeviceCards/Rack/IRackAccess.cs
@@ -58,6 +58,12 @@ internal interface IRackAccess
int MappingCurve(int index); bool SetMappingCurve(int index, int curve);
/// <summary>Whether a chain can take a hosted plug-in effect (not Nota Rhythm's voices).</summary>
bool HostsPlugins => true;
+ // Live telemetry of a chain device (meters, scopes, curves) for its pop-out card; none by default.
+ float ChainDeviceGainReduction(int chain, int dev) => 0f;
+ int ChainDeviceScope(int chain, int dev, float[] outSamples, int maxSamples) => 0;
+ int ChainDeviceLayerWave(int chain, int dev, int layer, float[] outSamples, int maxSamples) => 0;
+ string ChainDeviceText(int chain, int dev, int id) => "";
+ void ChainDeviceAction(int chain, int dev, int id, int iarg, float farg) { }
}
internal sealed class InstrumentRackAccess(IAudioEngine e, int t) : IRackAccess
@@ -91,6 +97,11 @@ internal sealed class InstrumentRackAccess(IAudioEngine e, int t) : IRackAccess
public void SetChainDeviceBypassed(int c, int d, bool b) => e.RackSetChainDeviceBypassed(t, c, d, b);
public int ChainDeviceBuiltinKind(int c, int d) => e.RackChainDeviceBuiltinKind(t, c, d);
public void OpenChainDeviceEditor(int c, int d) => e.RackOpenChainDeviceEditor(t, c, d);
+ public float ChainDeviceGainReduction(int c, int d) => e.RackDevChainDeviceGainReduction(t, -1, c, d);
+ public int ChainDeviceScope(int c, int d, float[] o, int n) => e.RackDevChainDeviceScope(t, -1, c, d, o, n);
+ public int ChainDeviceLayerWave(int c, int d, int l, float[] o, int n) => e.RackDevChainDeviceLayerWave(t, -1, c, d, l, o, n);
+ public string ChainDeviceText(int c, int d, int id) => e.RackDevChainDeviceText(t, -1, c, d, id);
+ public void ChainDeviceAction(int c, int d, int id, int iarg, float farg) => e.RackDevChainDeviceAction(t, -1, c, d, id, iarg, farg);
public float ChainGain(int c) => e.RackChainGain(t, c);
public void SetChainGain(int c, float v) => e.RackSetChainGain(t, c, v);
public float ChainPan(int c) => e.RackChainPan(t, c);
@@ -144,6 +155,11 @@ internal sealed class EffectRackAccess(IAudioEngine e, int t, int di) : IRackAcc
public void SetChainDeviceBypassed(int c, int d, bool b) => e.RackDevSetChainDeviceBypassed(t, di, c, d, b);
public int ChainDeviceBuiltinKind(int c, int d) => e.RackDevChainDeviceBuiltinKind(t, di, c, d);
public void OpenChainDeviceEditor(int c, int d) => e.RackDevOpenChainDeviceEditor(t, di, c, d);
+ public float ChainDeviceGainReduction(int c, int d) => e.RackDevChainDeviceGainReduction(t, di, c, d);
+ public int ChainDeviceScope(int c, int d, float[] o, int n) => e.RackDevChainDeviceScope(t, di, c, d, o, n);
+ public int ChainDeviceLayerWave(int c, int d, int l, float[] o, int n) => e.RackDevChainDeviceLayerWave(t, di, c, d, l, o, n);
+ public string ChainDeviceText(int c, int d, int id) => e.RackDevChainDeviceText(t, di, c, d, id);
+ public void ChainDeviceAction(int c, int d, int id, int iarg, float farg) => e.RackDevChainDeviceAction(t, di, c, d, id, iarg, farg);
public float ChainGain(int c) => e.RackDevChainGain(t, di, c);
public void SetChainGain(int c, float v) => e.RackDevSetChainGain(t, di, c, v);
public float ChainPan(int c) => e.RackDevChainPan(t, di, c);
diff --git a/src/managed/Nota.App/DeviceCards/Rack/RackCardView.cs b/src/managed/Nota.App/DeviceCards/Rack/RackCardView.cs
index 89d57fd2..e6b6bba0 100644
--- a/src/managed/Nota.App/DeviceCards/Rack/RackCardView.cs
+++ b/src/managed/Nota.App/DeviceCards/Rack/RackCardView.cs
@@ -1654,8 +1654,11 @@ internal class RackChainEngineProxy : System.Reflection.DispatchProxy
case nameof(Nota.Application.IAudioEngine.InstrumentParamDefault): return Inner.RackChainInstrumentParamDefault((int)args![0]!, Chain, (int)args![1]!);
case nameof(Nota.Application.IAudioEngine.BeginAutomationWrite):
case nameof(Nota.Application.IAudioEngine.EndAutomationWrite): return null;
- case nameof(Nota.Application.IAudioEngine.InstrumentVoiceCount): return -1;
- case nameof(Nota.Application.IAudioEngine.InstrumentHeldNotes): return 0;
+ // Live telemetry comes from the chain instrument, not the track's rack instrument.
+ case nameof(Nota.Application.IAudioEngine.InstrumentScope): return Inner.RackChainInstrumentScope((int)args![0]!, Chain, (float[])args![1]!);
+ case nameof(Nota.Application.IAudioEngine.InstrumentVoiceCount): return Inner.RackChainInstrumentVoiceCount((int)args![0]!, Chain);
+ case nameof(Nota.Application.IAudioEngine.InstrumentHeldNotes): return Inner.RackChainInstrumentHeldNotes((int)args![0]!, Chain, (int[])args![1]!);
+ case nameof(Nota.Application.IAudioEngine.InstrumentAction): Inner.RackChainInstrumentAction((int)args![0]!, Chain, (int)args![1]!, (int)args![2]!, (float)args![3]!); return null;
default: return m!.Invoke(Inner, args);
}
}
@@ -1683,14 +1686,14 @@ internal class RackChainDeviceEngineProxy : System.Reflection.DispatchProxy
case nameof(Nota.Application.IAudioEngine.DeviceName): return Access.ChainDeviceName(Chain, Dev);
case nameof(Nota.Application.IAudioEngine.DeviceBypassed): return Access.ChainDeviceBypassed(Chain, Dev);
case nameof(Nota.Application.IAudioEngine.SetDeviceBypassed): Access.SetChainDeviceBypassed(Chain, Dev, (bool)args![2]!); return null;
- case nameof(Nota.Application.IAudioEngine.DeviceGainReduction): return 0f;
case nameof(Nota.Application.IAudioEngine.DeviceLoadFile): return false; // chain devices keep params only
- case nameof(Nota.Application.IAudioEngine.DeviceText): return "";
- // No telemetry surface for chain devices — passing through would read the
- // track's top-level device at the same index.
- case nameof(Nota.Application.IAudioEngine.DeviceScope): return 0;
- case nameof(Nota.Application.IAudioEngine.DeviceLayerWave): return 0;
- case nameof(Nota.Application.IAudioEngine.DeviceAction): return null; // same: it would command the top-level device
+ // Live telemetry (meters, scopes, curves) comes from the chain device itself —
+ // passing through would read/command the track's top-level device at the same index.
+ case nameof(Nota.Application.IAudioEngine.DeviceGainReduction): return Access.ChainDeviceGainReduction(Chain, Dev);
+ case nameof(Nota.Application.IAudioEngine.DeviceText): return Access.ChainDeviceText(Chain, Dev, (int)args![2]!);
+ case nameof(Nota.Application.IAudioEngine.DeviceScope): return Access.ChainDeviceScope(Chain, Dev, (float[])args![2]!, (int)args![3]!);
+ case nameof(Nota.Application.IAudioEngine.DeviceLayerWave): return Access.ChainDeviceLayerWave(Chain, Dev, (int)args![2]!, (float[])args![3]!, (int)args![4]!);
+ case nameof(Nota.Application.IAudioEngine.DeviceAction): Access.ChainDeviceAction(Chain, Dev, (int)args![2]!, (int)args![3]!, (float)args![4]!); return null;
case nameof(Nota.Application.IAudioEngine.DeviceAcceptsSidechain): return false;
case nameof(Nota.Application.IAudioEngine.DeviceSidechainSource): return -1;
case nameof(Nota.Application.IAudioEngine.DeviceSidechainGain): return 0f;
diff --git a/src/managed/Nota.Application/Engine/IAudioEngine.cs b/src/managed/Nota.Application/Engine/IAudioEngine.cs
index c5c9b0a1..ee8511e8 100644
--- a/src/managed/Nota.Application/Engine/IAudioEngine.cs
+++ b/src/managed/Nota.Application/Engine/IAudioEngine.cs
@@ -479,6 +479,12 @@ public interface IAudioEngine : IDisposable
void RackChainInstrumentParamSet(int trackId, int chain, int param, float normalized);
/// <summary>Factory-default value (0..1) of a chain instrument param, for double-click reset.</summary>
float RackChainInstrumentParamDefault(int trackId, int chain, int param);
+ // Chain-instrument telemetry — mirrors InstrumentScope / InstrumentVoiceCount /
+ // InstrumentHeldNotes / InstrumentAction for the instrument on a rack chain.
+ int RackChainInstrumentScope(int trackId, int chain, float[] outv);
+ int RackChainInstrumentVoiceCount(int trackId, int chain);
+ int RackChainInstrumentHeldNotes(int trackId, int chain, int[] outNotes);
+ void RackChainInstrumentAction(int trackId, int chain, int id, int iarg, float farg);
/// <summary>Built-in Sampler settings for a chain instrument. False if it isn't a Sampler.</summary>
bool RackChainSamplerInfo(int trackId, int chain, out NotaSamplerInfo info);
/// <summary>Sets a chain Sampler's root note (lock-free). False if the chain isn't a Sampler.</summary>
@@ -577,6 +583,13 @@ public interface IAudioEngine : IDisposable
void RackDevChainDeviceParamSet(int trackId, int deviceIndex, int chain, int dev, int param, float value);
void RackDevSetChainDeviceBypassed(int trackId, int deviceIndex, int chain, int dev, bool bypassed);
bool RackDevChainDeviceBypassed(int trackId, int deviceIndex, int chain, int dev);
+ // Chain-device telemetry (deviceIndex -1 = the track's Instrument Rack) — mirrors
+ // DeviceGainReduction / DeviceScope / DeviceLayerWave / DeviceText / DeviceAction.
+ float RackDevChainDeviceGainReduction(int trackId, int deviceIndex, int chain, int dev);
+ int RackDevChainDeviceScope(int trackId, int deviceIndex, int chain, int dev, float[] outSamples, int maxSamples);
+ int RackDevChainDeviceLayerWave(int trackId, int deviceIndex, int chain, int dev, int layer, float[] outSamples, int maxSamples);
+ string RackDevChainDeviceText(int trackId, int deviceIndex, int chain, int dev, int id);
+ void RackDevChainDeviceAction(int trackId, int deviceIndex, int chain, int dev, int id, int iarg, float farg);
void RackDevSetChainGain(int trackId, int deviceIndex, int chain, float v);
void RackDevSetChainPan(int trackId, int deviceIndex, int chain, float v);
void RackDevSetChainMute(int trackId, int deviceIndex, int chain, bool mute);
diff --git a/src/managed/Nota.Infrastructure/Interop/NativeMethods.Rack.cs b/src/managed/Nota.Infrastructure/Interop/NativeMethods.Rack.cs
index 7771b064..d6a66421 100644
--- a/src/managed/Nota.Infrastructure/Interop/NativeMethods.Rack.cs
+++ b/src/managed/Nota.Infrastructure/Interop/NativeMethods.Rack.cs
@@ -36,6 +36,15 @@ internal static partial class NativeMethods
[LibraryImport(Lib, EntryPoint = "nota_rack_chain_instrument_param_default")]
internal static partial float RackChainInstrumentParamDefault(IntPtr engine, int trackId, int chain, int param);
+ [LibraryImport(Lib, EntryPoint = "nota_rack_chain_instrument_scope")]
+ internal static partial int RackChainInstrumentScope(IntPtr engine, int trackId, int chain, [Out] float[] outv, int maxN);
+ [LibraryImport(Lib, EntryPoint = "nota_rack_chain_instrument_voice_count")]
+ internal static partial int RackChainInstrumentVoiceCount(IntPtr engine, int trackId, int chain);
+ [LibraryImport(Lib, EntryPoint = "nota_rack_chain_instrument_held_notes")]
+ internal static partial int RackChainInstrumentHeldNotes(IntPtr engine, int trackId, int chain, [Out] int[] outNotes, int maxN);
+ [LibraryImport(Lib, EntryPoint = "nota_rack_chain_instrument_action")]
+ internal static partial void RackChainInstrumentAction(IntPtr engine, int trackId, int chain, int id, int iarg, float farg);
+
[LibraryImport(Lib, EntryPoint = "nota_rack_chain_sampler_info")]
internal static partial int RackChainSamplerInfo(IntPtr engine, int trackId, int chain, out NotaSamplerInfo info);
diff --git a/src/managed/Nota.Infrastructure/Interop/NativeMethods.RackDev.cs b/src/managed/Nota.Infrastructure/Interop/NativeMethods.RackDev.cs
index d9a3cb66..df5f2dde 100644
--- a/src/managed/Nota.Infrastructure/Interop/NativeMethods.RackDev.cs
+++ b/src/managed/Nota.Infrastructure/Interop/NativeMethods.RackDev.cs
@@ -99,6 +99,17 @@ internal static partial class NativeMethods
[LibraryImport(Lib, EntryPoint = "nota_rackdev_chain_device_bypassed")]
internal static partial int RackDevChainDeviceBypassed(IntPtr engine, int trackId, int deviceIndex, int chain, int dev);
+ [LibraryImport(Lib, EntryPoint = "nota_rackdev_chain_device_gain_reduction")]
+ internal static partial float RackDevChainDeviceGainReduction(IntPtr engine, int trackId, int deviceIndex, int chain, int dev);
+ [LibraryImport(Lib, EntryPoint = "nota_rackdev_chain_device_scope")]
+ internal static partial int RackDevChainDeviceScope(IntPtr engine, int trackId, int deviceIndex, int chain, int dev, [Out] float[] outSamples, int maxSamples);
+ [LibraryImport(Lib, EntryPoint = "nota_rackdev_chain_device_layer_wave")]
+ internal static partial int RackDevChainDeviceLayerWave(IntPtr engine, int trackId, int deviceIndex, int chain, int dev, int layer, [Out] float[] outSamples, int maxSamples);
+ [LibraryImport(Lib, EntryPoint = "nota_rackdev_chain_device_text")]
+ internal static partial int RackDevChainDeviceText(IntPtr engine, int trackId, int deviceIndex, int chain, int dev, int id, [Out] byte[]? outBytes, int cap);
+ [LibraryImport(Lib, EntryPoint = "nota_rackdev_chain_device_action")]
+ internal static partial void RackDevChainDeviceAction(IntPtr engine, int trackId, int deviceIndex, int chain, int dev, int id, int iarg, float farg);
+
[LibraryImport(Lib, EntryPoint = "nota_rackdev_set_chain_gain")]
internal static partial void RackDevSetChainGain(IntPtr engine, int trackId, int deviceIndex, int chain, float v);
diff --git a/src/managed/Nota.Infrastructure/Interop/NotaEngine.Rack.cs b/src/managed/Nota.Infrastructure/Interop/NotaEngine.Rack.cs
index e6bbb25a..198ea28c 100644
--- a/src/managed/Nota.Infrastructure/Interop/NotaEngine.Rack.cs
+++ b/src/managed/Nota.Infrastructure/Interop/NotaEngine.Rack.cs
@@ -117,6 +117,15 @@ public sealed partial class NotaEngine
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 RackChainSamplerInfo(int trackId, int chain, out NotaSamplerInfo info)
{ ThrowIfDisposed(); return NativeMethods.RackChainSamplerInfo(_handle, trackId, chain, out info) != 0; }
diff --git a/src/managed/Nota.Infrastructure/Interop/NotaEngine.RackDev.cs b/src/managed/Nota.Infrastructure/Interop/NotaEngine.RackDev.cs
index 42d0968d..093171e9 100644
--- a/src/managed/Nota.Infrastructure/Interop/NotaEngine.RackDev.cs
+++ b/src/managed/Nota.Infrastructure/Interop/NotaEngine.RackDev.cs
@@ -101,6 +101,24 @@ public sealed partial class NotaEngine
public bool RackDevChainDeviceBypassed(int trackId, int deviceIndex, int chain, int dev)
{ ThrowIfDisposed(); return NativeMethods.RackDevChainDeviceBypassed(_handle, trackId, deviceIndex, chain, dev) != 0; }
+ public float RackDevChainDeviceGainReduction(int trackId, int deviceIndex, int chain, int dev)
+ { ThrowIfDisposed(); return NativeMethods.RackDevChainDeviceGainReduction(_handle, trackId, deviceIndex, chain, dev); }
+ public int RackDevChainDeviceScope(int trackId, int deviceIndex, int chain, int dev, float[] outSamples, int maxSamples)
+ { ThrowIfDisposed(); return NativeMethods.RackDevChainDeviceScope(_handle, trackId, deviceIndex, chain, dev, outSamples, maxSamples); }
+ public int RackDevChainDeviceLayerWave(int trackId, int deviceIndex, int chain, int dev, int layer, float[] outSamples, int maxSamples)
+ { ThrowIfDisposed(); return NativeMethods.RackDevChainDeviceLayerWave(_handle, trackId, deviceIndex, chain, dev, layer, outSamples, maxSamples); }
+ public void RackDevChainDeviceAction(int trackId, int deviceIndex, int chain, int dev, int id, int iarg, float farg)
+ { ThrowIfDisposed(); NativeMethods.RackDevChainDeviceAction(_handle, trackId, deviceIndex, chain, dev, id, iarg, farg); }
+ public string RackDevChainDeviceText(int trackId, int deviceIndex, int chain, int dev, int id)
+ {
+ ThrowIfDisposed();
+ int n = NativeMethods.RackDevChainDeviceText(_handle, trackId, deviceIndex, chain, dev, id, null, 0);
+ if (n <= 0) return "";
+ var buf = new byte[n + 1];
+ NativeMethods.RackDevChainDeviceText(_handle, trackId, deviceIndex, chain, dev, id, buf, buf.Length);
+ return System.Text.Encoding.UTF8.GetString(buf, 0, n);
+ }
+
public void RackDevSetChainGain(int trackId, int deviceIndex, int chain, float v)
{ ThrowIfDisposed(); NativeMethods.RackDevSetChainGain(_handle, trackId, deviceIndex, chain, v); }
diff --git a/src/native/nota.engine/include/nota/nota_engine.h b/src/native/nota.engine/include/nota/nota_engine.h
index 25cd5f0a..dfb38e91 100644
--- a/src/native/nota.engine/include/nota/nota_engine.h
+++ b/src/native/nota.engine/include/nota/nota_engine.h
@@ -945,6 +945,12 @@ NOTA_API const char* nota_rack_chain_instrument_param_id(const NotaEngine* engin
NOTA_API float nota_rack_chain_instrument_param_get(const NotaEngine* engine, int32_t track_id, int32_t chain, int32_t param);
NOTA_API void nota_rack_chain_instrument_param_set(NotaEngine* engine, int32_t track_id, int32_t chain, int32_t param, float normalized);
NOTA_API float nota_rack_chain_instrument_param_default(const NotaEngine* engine, int32_t track_id, int32_t chain, int32_t param);
+// Chain-instrument telemetry: same semantics as nota_track_instrument_scope /
+// _voice_count / nota_track_held_notes / nota_track_instrument_action.
+NOTA_API int32_t nota_rack_chain_instrument_scope(const NotaEngine* engine, int32_t track_id, int32_t chain, float* out, int32_t max_n);
+NOTA_API int32_t nota_rack_chain_instrument_voice_count(const NotaEngine* engine, int32_t track_id, int32_t chain);
+NOTA_API int32_t nota_rack_chain_instrument_held_notes(const NotaEngine* engine, int32_t track_id, int32_t chain, int32_t* out, int32_t max_n);
+NOTA_API void nota_rack_chain_instrument_action(NotaEngine* engine, int32_t track_id, int32_t chain, int32_t id, int32_t iarg, float farg);
/* Chain instrument GUI + preset (hosted plugins). */
NOTA_API void nota_rack_open_chain_instrument_editor(NotaEngine* engine, int32_t track_id, int32_t chain);
NOTA_API void nota_rack_open_chain_device_editor(NotaEngine* engine, int32_t track_id, int32_t chain, int32_t dev);
@@ -1049,6 +1055,13 @@ NOTA_API float nota_rackdev_chain_device_param_get(const NotaEngine* engin
NOTA_API void nota_rackdev_chain_device_param_set(NotaEngine* engine, int32_t track_id, int32_t device_index, int32_t chain, int32_t dev, int32_t param, float value);
NOTA_API void nota_rackdev_set_chain_device_bypassed(NotaEngine* engine, int32_t track_id, int32_t device_index, int32_t chain, int32_t dev, int32_t bypassed);
NOTA_API int32_t nota_rackdev_chain_device_bypassed(const NotaEngine* engine, int32_t track_id, int32_t device_index, int32_t chain, int32_t dev);
+// Chain-device telemetry (device_index -1 = the track's Instrument Rack): same semantics
+// as nota_device_gain_reduction / _scope / _layer_wave / _text / _action.
+NOTA_API float nota_rackdev_chain_device_gain_reduction(const NotaEngine* engine, int32_t track_id, int32_t device_index, int32_t chain, int32_t dev);
+NOTA_API int32_t nota_rackdev_chain_device_scope(const NotaEngine* engine, int32_t track_id, int32_t device_index, int32_t chain, int32_t dev, float* out, int32_t max_samples);
+NOTA_API int32_t nota_rackdev_chain_device_layer_wave(const NotaEngine* engine, int32_t track_id, int32_t device_index, int32_t chain, int32_t dev, int32_t layer, float* out, int32_t max_samples);
+NOTA_API int32_t nota_rackdev_chain_device_text(const NotaEngine* engine, int32_t track_id, int32_t device_index, int32_t chain, int32_t dev, int32_t id, char* out, int32_t cap);
+NOTA_API void nota_rackdev_chain_device_action(NotaEngine* engine, int32_t track_id, int32_t device_index, int32_t chain, int32_t dev, int32_t id, int32_t iarg, float farg);
NOTA_API void nota_rackdev_set_chain_gain(NotaEngine* engine, int32_t track_id, int32_t device_index, int32_t chain, float v);
NOTA_API void nota_rackdev_set_chain_pan (NotaEngine* engine, int32_t track_id, int32_t device_index, int32_t chain, float v);
NOTA_API void nota_rackdev_set_chain_mute(NotaEngine* engine, int32_t track_id, int32_t device_index, int32_t chain, int32_t b);
diff --git a/src/native/nota.engine/src/Engine.h b/src/native/nota.engine/src/Engine.h
index d7504cd6..f2faec0c 100644
--- a/src/native/nota.engine/src/Engine.h
+++ b/src/native/nota.engine/src/Engine.h
@@ -675,6 +675,12 @@ public:
float rackChainInstrumentParamGet(int32_t trackId, int32_t deviceIndex, int32_t chain, int32_t param) const;
void rackChainInstrumentParamSet(int32_t trackId, int32_t deviceIndex, int32_t chain, int32_t param, float normalized);
float rackChainInstrumentParamDefault(int32_t trackId, int32_t deviceIndex, int32_t chain, int32_t param) const;
+ // Live telemetry of a chain instrument (same surface as instrumentScope/… for a track
+ // instrument) — lets its pop-out editor animate its graphs/keys.
+ int32_t rackChainInstrumentScope(int32_t trackId, int32_t deviceIndex, int32_t chain, float* out, int32_t maxN) const;
+ int32_t rackChainInstrumentVoiceCount(int32_t trackId, int32_t deviceIndex, int32_t chain) const;
+ int32_t rackChainInstrumentHeldNotes(int32_t trackId, int32_t deviceIndex, int32_t chain, int32_t* out, int32_t maxN) const;
+ void rackChainInstrumentAction(int32_t trackId, int32_t deviceIndex, int32_t chain, int32_t id, int32_t iarg, float farg);
// Chain instrument GUI + preset capture (hosted plugins): open the native editor,
// read the stable identifier + opaque state. Message thread.
void rackOpenChainInstrumentEditor(int32_t trackId, int32_t deviceIndex, int32_t chain);
@@ -699,6 +705,13 @@ public:
void rackChainDeviceParamSet(int32_t trackId, int32_t deviceIndex, int32_t chain, int32_t dev, int32_t param, float value);
void rackSetChainDeviceBypassed(int32_t trackId, int32_t deviceIndex, int32_t chain, int32_t dev, bool bypassed);
bool rackChainDeviceBypassed(int32_t trackId, int32_t deviceIndex, int32_t chain, int32_t dev) const;
+ // Live telemetry of a chain device (same surface as deviceScope/deviceText/… for a top-level
+ // device) — lets the chain device's pop-out card draw its meters/curves.
+ float rackChainDeviceGainReduction(int32_t trackId, int32_t deviceIndex, int32_t chain, int32_t dev) const;
+ int32_t rackChainDeviceScope(int32_t trackId, int32_t deviceIndex, int32_t chain, int32_t dev, float* out, int32_t maxSamples) const;
+ int32_t rackChainDeviceLayerWave(int32_t trackId, int32_t deviceIndex, int32_t chain, int32_t dev, int32_t layer, float* out, int32_t maxSamples) const;
+ std::string rackChainDeviceText(int32_t trackId, int32_t deviceIndex, int32_t chain, int32_t dev, int32_t id) const;
+ void rackChainDeviceAction(int32_t trackId, int32_t deviceIndex, int32_t chain, int32_t dev, int32_t id, int32_t iarg, float farg);
void rackSetChainGain(int32_t trackId, int32_t deviceIndex, int32_t chain, float v);
void rackSetChainPan (int32_t trackId, int32_t deviceIndex, int32_t chain, float v);
void rackSetChainMute(int32_t trackId, int32_t deviceIndex, int32_t chain, bool b);
diff --git a/src/native/nota.engine/src/Engine_Rack.cpp b/src/native/nota.engine/src/Engine_Rack.cpp
index 1c28264d..e354674c 100644
--- a/src/native/nota.engine/src/Engine_Rack.cpp
+++ b/src/native/nota.engine/src/Engine_Rack.cpp
@@ -173,6 +173,20 @@ float Engine::rackChainInstrumentParamDefault(int32_t t, int32_t di, int32_t c,
auto fresh = RackCore::makeInstrument(inst->kind()); // built-in default == a fresh one's value
return fresh ? fresh->pluginParamGet(p) : inst->pluginParamGet(p);
}
+int32_t Engine::rackChainInstrumentScope(int32_t t, int32_t di, int32_t c, float* out, int32_t n) const {
+ if (!out || n <= 0) return 0;
+ auto* r = rackCoreAt(t, di); Instrument* inst = r ? r->chainInstrument(c) : nullptr; return inst ? inst->scopeRead(out, n) : 0;
+}
+int32_t Engine::rackChainInstrumentVoiceCount(int32_t t, int32_t di, int32_t c) const {
+ auto* r = rackCoreAt(t, di); Instrument* inst = r ? r->chainInstrument(c) : nullptr; return inst ? inst->activeVoiceCount() : -1;
+}
+int32_t Engine::rackChainInstrumentHeldNotes(int32_t t, int32_t di, int32_t c, int32_t* out, int32_t n) const {
+ if (!out || n <= 0) return 0;
+ auto* r = rackCoreAt(t, di); Instrument* inst = r ? r->chainInstrument(c) : nullptr; return inst ? inst->heldNotes(out, n) : 0;
+}
+void Engine::rackChainInstrumentAction(int32_t t, int32_t di, int32_t c, int32_t id, int32_t iarg, float farg) {
+ auto* r = rackCoreAt(t, di); Instrument* inst = r ? r->chainInstrument(c) : nullptr; if (inst) inst->action(id, iarg, farg);
+}
void Engine::rackOpenChainInstrumentEditor(int32_t t, int32_t di, int32_t c) {
auto* r = rackCoreAt(t, di);
Instrument* inst = r ? r->chainInstrument(c) : nullptr;
@@ -260,6 +274,21 @@ void Engine::rackSetChainDeviceBypassed(int32_t t, int32_t di, int32_t c, int32_
bool Engine::rackChainDeviceBypassed(int32_t t, int32_t di, int32_t c, int32_t d) const {
auto* r = rackCoreAt(t, di); Device* dev = r ? r->chainDeviceAt(c, d) : nullptr; return dev && dev->bypassed();
}
+float Engine::rackChainDeviceGainReduction(int32_t t, int32_t di, int32_t c, int32_t d) const {
+ auto* r = rackCoreAt(t, di); Device* dev = r ? r->chainDeviceAt(c, d) : nullptr; return dev ? dev->gainReductionDb() : 0.0f;
+}
+int32_t Engine::rackChainDeviceScope(int32_t t, int32_t di, int32_t c, int32_t d, float* out, int32_t n) const {
+ auto* r = rackCoreAt(t, di); Device* dev = r ? r->chainDeviceAt(c, d) : nullptr; return dev ? dev->scopeRead(out, n) : 0;
+}
+int32_t Engine::rackChainDeviceLayerWave(int32_t t, int32_t di, int32_t c, int32_t d, int32_t layer, float* out, int32_t n) const {
+ auto* r = rackCoreAt(t, di); Device* dev = r ? r->chainDeviceAt(c, d) : nullptr; return dev ? dev->layerWave(layer, out, n) : 0;
+}
+std::string Engine::rackChainDeviceText(int32_t t, int32_t di, int32_t c, int32_t d, int32_t id) const {
+ auto* r = rackCoreAt(t, di); Device* dev = r ? r->chainDeviceAt(c, d) : nullptr; return dev ? dev->deviceText(id) : std::string{};
+}
+void Engine::rackChainDeviceAction(int32_t t, int32_t di, int32_t c, int32_t d, int32_t id, int32_t iarg, float farg) {
+ auto* r = rackCoreAt(t, di); Device* dev = r ? r->chainDeviceAt(c, d) : nullptr; if (dev) dev->deviceAction(id, iarg, farg);
+}
// ---- per-chain controls --------------------------------------------------
void Engine::rackSetChainGain(int32_t t, int32_t di, int32_t c, float v) { if (auto* r = rackCoreAt(t, di)) r->setChainGain(c, v); }
diff --git a/src/native/nota.engine/src/nota_engine_rack.cpp b/src/native/nota.engine/src/nota_engine_rack.cpp
index 954fe962..df2b95b0 100644
--- a/src/native/nota.engine/src/nota_engine_rack.cpp
+++ b/src/native/nota.engine/src/nota_engine_rack.cpp
@@ -10,6 +10,8 @@
#include "nota_engine_internal.h"
+#include <algorithm>
+#include <cstring>
#include <string>
extern "C" {
@@ -60,6 +62,10 @@ const char* nota_rack_chain_instrument_param_id(const NotaEngine* e, int32_t t,
float nota_rack_chain_instrument_param_get(const NotaEngine* e, int32_t t, int32_t c, int32_t p) { return e ? CENG(e)->rackChainInstrumentParamGet(t, -1, c, p) : 0.0f; }
void nota_rack_chain_instrument_param_set(NotaEngine* e, int32_t t, int32_t c, int32_t p, float v) { if (e) ENG(e)->rackChainInstrumentParamSet(t, -1, c, p, v); }
float nota_rack_chain_instrument_param_default(const NotaEngine* e, int32_t t, int32_t c, int32_t p) { return e ? CENG(e)->rackChainInstrumentParamDefault(t, -1, c, p) : 0.0f; }
+int32_t nota_rack_chain_instrument_scope(const NotaEngine* e, int32_t t, int32_t c, float* out, int32_t n) { return e ? CENG(e)->rackChainInstrumentScope(t, -1, c, out, n) : 0; }
+int32_t nota_rack_chain_instrument_voice_count(const NotaEngine* e, int32_t t, int32_t c) { return e ? CENG(e)->rackChainInstrumentVoiceCount(t, -1, c) : -1; }
+int32_t nota_rack_chain_instrument_held_notes(const NotaEngine* e, int32_t t, int32_t c, int32_t* out, int32_t n) { return e ? CENG(e)->rackChainInstrumentHeldNotes(t, -1, c, out, n) : 0; }
+void nota_rack_chain_instrument_action(NotaEngine* e, int32_t t, int32_t c, int32_t id, int32_t iarg, float farg) { if (e) ENG(e)->rackChainInstrumentAction(t, -1, c, id, iarg, farg); }
void nota_rack_open_chain_instrument_editor(NotaEngine* e, int32_t t, int32_t c) { if (e) ENG(e)->rackOpenChainInstrumentEditor(t, -1, c); }
void nota_rack_open_chain_device_editor(NotaEngine* e, int32_t t, int32_t c, int32_t d) { if (e) ENG(e)->rackOpenChainDeviceEditor(t, -1, c, d); }
const char* nota_rack_chain_instrument_plugin_id(const NotaEngine* e, int32_t t, int32_t c) {
@@ -177,6 +183,21 @@ float nota_rackdev_chain_device_param_get(const NotaEngine* e, int32_t t, int32_
void nota_rackdev_chain_device_param_set(NotaEngine* e, int32_t t, int32_t di, int32_t c, int32_t d, int32_t p, float v) { if (e) ENG(e)->rackChainDeviceParamSet(t, di, c, d, p, v); }
void nota_rackdev_set_chain_device_bypassed(NotaEngine* e, int32_t t, int32_t di, int32_t c, int32_t d, int32_t b) { if (e) ENG(e)->rackSetChainDeviceBypassed(t, di, c, d, b != 0); }
int32_t nota_rackdev_chain_device_bypassed(const NotaEngine* e, int32_t t, int32_t di, int32_t c, int32_t d) { return (e && CENG(e)->rackChainDeviceBypassed(t, di, c, d)) ? 1 : 0; }
+float nota_rackdev_chain_device_gain_reduction(const NotaEngine* e, int32_t t, int32_t di, int32_t c, int32_t d) { return e ? CENG(e)->rackChainDeviceGainReduction(t, di, c, d) : 0.0f; }
+int32_t nota_rackdev_chain_device_scope(const NotaEngine* e, int32_t t, int32_t di, int32_t c, int32_t d, float* out, int32_t n) { return e ? CENG(e)->rackChainDeviceScope(t, di, c, d, out, n) : 0; }
+int32_t nota_rackdev_chain_device_layer_wave(const NotaEngine* e, int32_t t, int32_t di, int32_t c, int32_t d, int32_t layer, float* out, int32_t n) { return e ? CENG(e)->rackChainDeviceLayerWave(t, di, c, d, layer, out, n) : 0; }
+int32_t nota_rackdev_chain_device_text(const NotaEngine* e, int32_t t, int32_t di, int32_t c, int32_t d, int32_t id, char* out, int32_t cap) {
+ if (!e) return 0;
+ const std::string s = CENG(e)->rackChainDeviceText(t, di, c, d, id);
+ const int32_t n = static_cast<int32_t>(s.size());
+ if (out && cap > 0) {
+ const int32_t m = std::min(n, cap - 1);
+ std::memcpy(out, s.data(), static_cast<size_t>(m));
+ out[m] = '\0';
+ }
+ return n; // full length (probe with a null buffer, then fetch)
+}
+void nota_rackdev_chain_device_action(NotaEngine* e, int32_t t, int32_t di, int32_t c, int32_t d, int32_t id, int32_t iarg, float farg) { if (e) ENG(e)->rackChainDeviceAction(t, di, c, d, id, iarg, farg); }
void nota_rackdev_set_chain_gain(NotaEngine* e, int32_t t, int32_t di, int32_t c, float v) { if (e) ENG(e)->rackSetChainGain(t, di, c, v); }
void nota_rackdev_set_chain_pan (NotaEngine* e, int32_t t, int32_t di, int32_t c, float v) { if (e) ENG(e)->rackSetChainPan(t, di, c, v); }
diff --git a/tests/Nota.SmokeTest/Program.cs b/tests/Nota.SmokeTest/Program.cs
index 303b822a..cf07a336 100644
--- a/tests/Nota.SmokeTest/Program.cs
+++ b/tests/Nota.SmokeTest/Program.cs
@@ -7577,6 +7577,8 @@ Console.WriteLine("-- Instrument Rack: C ABI + persistence --");
int c2 = re.RackAddChain(rt, 2); // Nota Physical
Check(c2 == 1 && re.RackChainCount(rt) == 2, "second chain added");
Check(re.RackChainInstrumentKind(rt, 1) == 2, "chain 1 hosts Nota Physical");
+ Check(re.RackChainInstrumentVoiceCount(rt, 1) == 0 && re.RackChainInstrumentHeldNotes(rt, 1, new int[16]) == 0,
+ "chain instrument telemetry reaches the chain's own instrument (idle Physical: 0 voices)");
int dEq = re.RackAddChainDevice(rt, 0, 0); // EQ on chain 0
Check(dEq == 0 && re.RackChainDeviceCount(rt, 0) == 1, "EQ device added to chain 0");
@@ -7700,6 +7702,15 @@ Console.WriteLine("-- Audio Effect Rack: engine + C ABI + persistence --");
re.Seek(0); re.Play(); re.RenderOffline(aeBuf, frames); re.StopTransport();
Check(float.IsFinite(aeBuf[0]) && Rms(aeBuf, frames) > 1e-5f, $"{mname} mode renders audible + finite (rms={Rms(aeBuf, frames):0.0000})");
}
+
+ // Chain-device telemetry: a Compressor inside the rack reports its own live scope
+ // (what its pop-out card draws), not the track's top-level device at that index.
+ int cd = re.RackDevAddChainDevice(at, adi, 0, 1);
+ re.Seek(0); re.Play(); re.RenderOffline(aeBuf, frames); re.StopTransport();
+ var csc = new float[14];
+ int cn = re.RackDevChainDeviceScope(at, adi, 0, cd, csc, csc.Length);
+ Check(cn == 14 && csc[8] > 1000 && csc[0] > 0.001f, $"chain compressor scope reports live levels (n {cn}, sr {csc[8]:0}, in {csc[0]:0.000})");
+ Check(re.DeviceScope(at, cd, new float[14], 14) == 0, "top-level scope at the chain device's index stays empty");
}
re.RackDevSetDryWet(tr, di, 0.35f);
re.RackDevSetVolume(tr, di, 1.5f);