it work yay

README.md

@@ -0,0 +1,10 @@
+LV2 plugins:
+- Linux Studio Plugins `lv2-lsp-plugins`
+
+C requirements (headers):
+- lilv `liblilv-0-devel`
+- sndfile `libsndfile-devel`
+
+Python requirements:
+- lilv `python3-lilv` (not on pypi)
+- soundfile `python311-SoundFile`

main.py

@@ -1,11 +1,11 @@
-import lilv, numpy, wave
+import lilv, numpy, time
 import soundfile
-from ctypes import c_float, c_int
+
+CHUNK_SIZE = 1024
 
 frames, sample_rate = soundfile.read('a.flac')
 num_frames = len(frames)
 print(f"{sample_rate}Hz | {int(num_frames/sample_rate/60)}:{int(num_frames/sample_rate%60)}")
-print(frames.dtype)
 frames = frames.astype(numpy.float32)
 
 world = lilv.World()
@@ -14,57 +14,63 @@ world.load_all()
 plugins = world.get_all_plugins()
 
 plugin = plugins.get_by_uri("http://lsp-plug.in/plugins/lv2/comp_delay_x2_stereo")
+if plugin is None:
+    print("No plugin comp_delay_x2_stereo")
+    exit()
 
-print(plugin.get_name())
+print("Using:", plugin.get_name())
 
 for i in range(plugin.get_num_ports()):
     port = plugin.get_port(i)
-    print(f"Port {i}: {port.get_name()} = {port.get_range()[0]}")
+    #print(f"Port {i}: {port.get_name()} = {port.get_range()[0]}")
 
 instance = lilv.Instance(plugin, sample_rate)
 
-output_left = numpy.zeros(num_frames, frames.dtype)
-output_right = numpy.zeros(num_frames, frames.dtype)
+instance.connect_port(4, numpy.array([1], dtype=numpy.int32)) # while 1 is default it needs to be set as int32 for whatever reason
 
-input_left_chunk = numpy.zeros(512, frames.dtype)
-input_right_chunk = numpy.zeros(512, frames.dtype)
-output_left_chunk = numpy.zeros(512, frames.dtype)
-output_right_chunk = numpy.zeros(512, frames.dtype)
+knob_mode = numpy.array([2], dtype=numpy.float32) # by the way, this can't be put into connect_port, even if just the number is a variable
+instance.connect_port(16, knob_mode)
+
+knob_time = numpy.array([10.0], dtype=numpy.float32) # but this can?????? it can be any of the three
+instance.connect_port(22, knob_time)
+
+output = numpy.zeros((num_frames, 2), frames.dtype)
+
+input_left_chunk = numpy.zeros(CHUNK_SIZE, frames.dtype)
+input_right_chunk = numpy.zeros(CHUNK_SIZE, frames.dtype)
+output_left_chunk = numpy.zeros(CHUNK_SIZE, frames.dtype)
+output_right_chunk = numpy.zeros(CHUNK_SIZE, frames.dtype)
 
 instance.connect_port(0, input_left_chunk)
 instance.connect_port(1, input_right_chunk)
 instance.connect_port(2, output_left_chunk)
 instance.connect_port(3, output_right_chunk)
 
-mode_left = numpy.array([2], dtype=numpy.int32)
-instance.connect_port(5, mode_left)
-
-time_left = numpy.array([0.0], dtype=numpy.float32)
-instance.connect_port(11, time_left)
-
-mode_right = numpy.array([2], dtype=numpy.int32)
-instance.connect_port(16, mode_right)
-
-time_right = numpy.array([500.0], dtype=numpy.float32)
-instance.connect_port(22, time_right)
-
 instance.activate()
 
-print(f"frames: {num_frames}\n")
-for start in range(0, num_frames, 512):
-    end = min(start + 512, num_frames)
+print(f"\nFrames: {num_frames}")
+print(f"Chunk size: {CHUNK_SIZE}")
+print(f"So {int(numpy.ceil(num_frames/CHUNK_SIZE))} iterations\n")
+
+for start in range(0, num_frames, CHUNK_SIZE):
+    end = min(start + CHUNK_SIZE, num_frames)
     chunk_size = end - start
-    print("\033[F", start, chunk_size, end)
+    print(start, chunk_size, end, "       \033[F")
 
     input_left_chunk[:chunk_size] = frames[start:end, 0]
     input_right_chunk[:chunk_size] = frames[start:end, 1]
+    output_left_chunk.fill(0)
+    output_right_chunk.fill(0)
 
     instance.run(chunk_size)
 
-    output_left[start:end] = output_left_chunk[:chunk_size]
-    output_right[start:end] = output_right_chunk[:chunk_size]
+    output[start:end, 0] = output_left_chunk[:chunk_size]
+    output[start:end, 1] = output_right_chunk[:chunk_size]
 
+print("done processing                  ")
 instance.deactivate()
 
-merged = numpy.column_stack((output_left, output_right))
-soundfile.write('aoutt.flac', merged, sample_rate)
+if numpy.allclose(frames, output, rtol=0.5, atol=0.5):
+    print("Warning: output is identical")
+
+soundfile.write('aoutt.flac', output, sample_rate)

src/audiofile.c

@@ -1,9 +1,11 @@
 #include <audiofile.h>
 
 SNDFILE *audiofile_read(const char *path, SF_INFO *sfinfo) {
+    printf("Input file: \"%s\"\n", path);
+
     SNDFILE *sndfile = sf_open(path, SFM_READ, sfinfo);
     if (sndfile == NULL) {
-        fprintf(stderr, "Failed to read audio file: %s\n", sf_strerror(NULL));
+        fprintf(stderr, "Failed to open audio file: %s\n", sf_strerror(NULL));
         return NULL;
     }
 
@@ -16,12 +18,14 @@ SNDFILE *audiofile_read(const char *path, SF_INFO *sfinfo) {
     int seconds = (double)sfinfo->frames / sfinfo->samplerate;
     int minutes = seconds / 60;
     printf("Duration: %d:%d\n", minutes, seconds % 60);
-    printf("Sample rate: %dHz\n\n", sfinfo->samplerate);
+    printf("Sample rate: %dHz\n", sfinfo->samplerate);
 
     return sndfile;
 }
 
 SNDFILE *audiofile_open_for_write(const char *path, SF_INFO *og_info) {
+    printf("Output file: \"%s\"\n", path);
+
     SF_INFO	sfinfo = {0};
     sfinfo.samplerate = og_info->samplerate;
     sfinfo.format = og_info->format;

src/easy.c

@@ -12,22 +12,20 @@ const LilvPlugin* easy_load_plugin(LilvWorld* world, const char* uri) {
         printf("Loaded plugin \"%s\"\n", lilv_node_as_string(plugin_name));
         lilv_node_free(plugin_name);
 
-        uint32_t n_ports = lilv_plugin_get_num_ports(plugin);
-        for (uint32_t i = 0; i < n_ports; i++) {
+        uint32_t nPorts = lilv_plugin_get_num_ports(plugin);
+        for (uint32_t i = 0; i < nPorts; i++) {
             const LilvPort* port = lilv_plugin_get_port_by_index(plugin, i);
-            // Get port properties
-            const char* name = lilv_node_as_string(lilv_port_get_name(plugin, port));
             
-            LilvNode* def = NULL;
-            lilv_port_get_range(plugin, port, &def, NULL, NULL);
-            printf("Port %d: %s = %f\n", i, name, lilv_node_as_float(def));
-            lilv_node_free(def);
-        }
+            LilvNode *nameNode = lilv_port_get_name(plugin, port);
+            const char* name = lilv_node_as_string(nameNode);
+            lilv_node_free(nameNode);
 
-        LilvNodes *features = lilv_plugin_get_required_features(plugin);
-        LILV_FOREACH(nodes, i, features) {
-            LilvNode *n = lilv_nodes_get(features, i);
-            printf("Feat: %s\n", lilv_node_as_string(n));
+            LilvNode* defNode = NULL;
+            lilv_port_get_range(plugin, port, &defNode, NULL, NULL);
+            float defaultValue = lilv_node_as_float(defNode);
+            lilv_node_free(defNode);
+
+            printf("Port %d: %s = %f\n", i, name, defaultValue);
         }
     }
 

src/main.c

@@ -1,5 +1,8 @@
 #include <stdio.h>
+#include <stdlib.h>
 #include <sndfile.h>
+#include <string.h>
+#include <time.h>
 
 #include "easy.h"
 #include "audiofile.h"
@@ -13,6 +16,22 @@ http://calf.sourceforge.net/plugins/BassEnhancer
 */
 
 int main(int argc, char *argv[]) {
+    if (argc < 2) {
+        printf("Usage: %s <input> [output]\n", argv[0]);
+        return 2;
+    }
+
+    char *input_filename = argv[1];
+    char *output_filename;
+
+    if (argc < 3) {
+        output_filename = malloc((strlen(input_filename) + 4) * sizeof(char));
+        strcpy(output_filename, "out-");
+        strcat(output_filename, input_filename);
+    } else {
+        output_filename = argv[2];
+    }
+
     LilvWorld *world = lilv_world_new();
     lilv_world_load_all(world);
 
@@ -20,12 +39,12 @@ int main(int argc, char *argv[]) {
 
     SF_INFO sfinfo = {0};
     SNDFILE *sndfile;
-    if ((sndfile = audiofile_read("a.flac", &sfinfo)) == NULL) {
+    if ((sndfile = audiofile_read(input_filename, &sfinfo)) == NULL) {
         return 1;
     }
 
     SNDFILE *out_sndfile;
-    if ((out_sndfile = audiofile_open_for_write("aout.flac", &sfinfo)) == NULL) {
+    if ((out_sndfile = audiofile_open_for_write(output_filename, &sfinfo)) == NULL) {
         return 1;
     }
     
@@ -41,6 +60,17 @@ int main(int argc, char *argv[]) {
 
     LilvInstance *instance = lilv_plugin_instantiate(plugin, sfinfo.samplerate, NULL);
 
+    float knob_enabled = 1;
+    lilv_instance_connect_port(instance, 4, &knob_enabled);
+
+    float knob_mode = 2;
+    lilv_instance_connect_port(instance, 16, &knob_mode);
+
+    float knob_time = 50.0f; // ms
+    lilv_instance_connect_port(instance, 22, &knob_time);
+
+    //
+
     float input_left[BUFFER_SIZE];
     float input_right[BUFFER_SIZE];
     float output_left[BUFFER_SIZE];
@@ -51,54 +81,34 @@ int main(int argc, char *argv[]) {
     lilv_instance_connect_port(instance, 2, output_left); // Output L
     lilv_instance_connect_port(instance, 3, output_right); // Output R
     
-    float sc[BUFFER_SIZE] = {0};
-    lilv_instance_connect_port(instance, 4, &sc); // Output R
-    lilv_instance_connect_port(instance, 5, &sc); // Output R
-
-    /*float bypass = 0.0f;
-    lilv_instance_connect_port(instance, 6, &bypass);
-
-    float aa = 0.0f;
-    lilv_instance_connect_port(instance, 8, &aa);*/
-
-    /*int mode_r = 2;
-    float time_r = 999.0f; // ms
-
-    lilv_instance_connect_port(instance, 5, &mode_r); // Mode Right
-    lilv_instance_connect_port(instance, 11, &time_r); // Time Right
-
-    float time_dr =1.0f; // ms
-    lilv_instance_connect_port(instance, 13, &time_dr); // Time Right
-
-    float aa = 0.0f;
-    lilv_instance_connect_port(instance, 4, &aa);*/
-    
-    lilv_instance_activate(instance);
-
     // start processing
 
+    lilv_instance_activate(instance);
     printf("Now processing\n");
+    clock_t start = clock();
 
-    float buffer[BUFFER_SIZE * 2];
-    float out_buffer[BUFFER_SIZE * 2];
+    float input_buffer[BUFFER_SIZE * 2];
+    float output_buffer[BUFFER_SIZE * 2];
     int frames_read;
-    while ((frames_read = sf_readf_float(sndfile, buffer, BUFFER_SIZE))) {
+    while ((frames_read = sf_readf_float(sndfile, input_buffer, BUFFER_SIZE))) {
+        // a frame is 2 samples and a sample is a number basically and it go left right left right (or how many channels)
         for (sf_count_t i = 0; i < frames_read; i++) {
-            input_left[i] = buffer[i * 2];
-            input_right[i] = buffer[i * 2 + 1];
+            input_left[i] = input_buffer[i * 2];
+            input_right[i] = input_buffer[i * 2 + 1];
         }
 
         lilv_instance_run(instance, frames_read);
 
         for (sf_count_t i = 0; i < frames_read; i++) {
-            out_buffer[i * 2] = output_left[i];
-            out_buffer[i * 2 + 1] = output_right[i];
+            output_buffer[i * 2] = output_left[i];
+            output_buffer[i * 2 + 1] = output_right[i];
         }
 
-        sf_writef_float(out_sndfile, out_buffer, frames_read);
+        sf_writef_float(out_sndfile, output_buffer, frames_read);
     }
 
-    printf("Done processing\n");
+    clock_t end = clock();
+    printf("Done processing. Took %ldns\n", (long)((double)(end - start) / CLOCKS_PER_SEC * 1000000));
 
     // end processing