use cookie for parameter pointer caching

Author: bandithedoge

src/clap/extensions/parameters.zig

@@ -29,16 +29,17 @@ pub fn makeParameters(comptime Plugin: type) *const c.clap_plugin_params_t {
                 return false;
 
             const state = clap.State.fromClap(clap_plugin);
-            const param = state.plugin.parameters.?.slice[index].*;
+            const param = state.plugin.parameters.?.slice[index];
 
-            switch (param) {
-                inline else => |p| {
+            switch (param.*) {
+                inline else => |*p| {
                     info.?.* = .{
                         .id = index,
-                        .default_value = @TypeOf(p).toFloat(p.options.default),
-                        .min_value = @TypeOf(p).toFloat(p.options.min),
-                        .max_value = @TypeOf(p).toFloat(p.options.max),
+                        .default_value = @TypeOf(p.*).toFloat(p.options.default),
+                        .min_value = @TypeOf(p.*).toFloat(p.options.min),
+                        .max_value = @TypeOf(p.*).toFloat(p.options.max),
                         .flags = 0,
+                        .cookie = p,
                     };
 
                     if (p.options.automatable)
@@ -130,7 +131,7 @@ pub fn makeParameters(comptime Plugin: type) *const c.clap_plugin_params_t {
         pub fn flush(clap_plugin: [*c]const c.clap_plugin_t, in: [*c]const c.clap_input_events_t, _: [*c]const c.clap_output_events_t) callconv(.c) void {
             for (0..in.?.*.size.?(in)) |i| {
                 const event = in.?.*.get.?(in, @intCast(i)).?;
-                clap.processEvent(Plugin, clap_plugin, event);
+                clap.State.fromClap(clap_plugin).handleEvent(event);
             }
         }
     };

src/clap/extensions/state.zig

@@ -26,7 +26,6 @@ pub const state = c.clap_plugin_state{
 };
 
 // TODO: make Writer and Reader buffered
-// TODO: move msgpack serialization to core
 
 pub const Writer = struct {
     clap_stream: *const c.clap_ostream,

src/clap/root.zig

@@ -147,28 +147,34 @@ pub const State = struct {
                 null,
         );
     }
-};
 
-pub fn processEvent(comptime Plugin: type, clap_plugin: *const c.clap_plugin_t, event: *const c.clap_event_header_t) void {
-    const state = State.fromClap(clap_plugin);
-    switch (event.type) {
-        c.CLAP_EVENT_PARAM_VALUE => {
-            std.debug.assert(@hasDecl(Plugin, "Parameters"));
-
-            const value_event: *const c.clap_event_param_value = @ptrCast(@alignCast(event));
-            const param = state.plugin.parameters.?.slice[value_event.param_id];
-
-            switch (param.*) {
-                inline else => |*p| {
-                    const value = @TypeOf(p.*).fromFloat(value_event.value);
-                    p.set(value);
-                    zigplug.log.debug("parameter '{s}' = {any}", .{ p.options.name, value });
-                },
+    // TODO: handle param_mod
+    pub fn handleParamEvent(self: *State, event: *const c.clap_event_param_value) void {
+        const param: *zigplug.Parameter = blk: {
+            if (event.cookie) |ptr|
+                break :blk @ptrCast(@alignCast(ptr))
+            else {
+                @branchHint(.unlikely);
+                break :blk self.plugin.parameters.?.slice[event.param_id];
             }
-        },
-        else => {},
+        };
+
+        switch (param.*) {
+            inline else => |*p| {
+                const value = @TypeOf(p.*).fromFloat(event.value);
+                p.set(value);
+                zigplug.log.debug("parameter '{s}' = {any}", .{ p.options.name, value });
+            },
+        }
     }
-}
+
+    pub fn handleEvent(self: *State, event: *const c.clap_event_header_t) void {
+        switch (event.type) {
+            c.CLAP_EVENT_PARAM_VALUE => self.handleParamEvent(@ptrCast(@alignCast(event))),
+            else => {},
+        }
+    }
+};
 
 fn ClapPlugin(comptime Plugin: type) type {
     return extern struct {
@@ -226,15 +232,11 @@ fn ClapPlugin(comptime Plugin: type) type {
 
             const event_count = clap_process.*.in_events.*.size.?(clap_process.*.in_events);
 
-            var event_i: u32 = 0;
-
-            while (event_i < event_count) {
-                const event = clap_process.*.in_events.*.get.?(clap_process.*.in_events, event_i);
-                event_i += 1;
+            for (0..event_count) |i| {
+                const event = clap_process.*.in_events.*.get.?(clap_process.*.in_events, @intCast(i));
                 switch (event.*.type) {
                     c.CLAP_EVENT_PARAM_VALUE => {
                         const value_event: *const c.clap_event_param_value = @ptrCast(@alignCast(event));
-                        const param = state.plugin.parameters.?.slice[value_event.param_id];
 
                         if (comptime Plugin.meta.sample_accurate_automation) {
                             end = value_event.header.time;
@@ -248,15 +250,9 @@ fn ClapPlugin(comptime Plugin: type) type {
                             end = samples;
                         }
 
-                        switch (param.*) {
-                            inline else => |*p| {
-                                const value = @TypeOf(p.*).fromFloat(value_event.value);
-                                p.set(value);
-                                zigplug.log.debug("parameter '{s}' = {any} at {}", .{ p.options.name, value, value_event.header.time });
-                            },
-                        }
+                        state.handleParamEvent(value_event);
                     },
-                    else => continue,
+                    else => state.handleEvent(event),
                 }
             }