it work yay

main.py

@@ -1,7 +1,7 @@
 import lilv, numpy, time
 import soundfile
 
-CHUNK_SIZE = 128
+CHUNK_SIZE = 1024
 
 frames, sample_rate = soundfile.read('a.flac')
 num_frames = len(frames)
@@ -34,8 +34,7 @@ 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_left = numpy.zeros(num_frames, frames.dtype)
+output = numpy.zeros((num_frames, 2), frames.dtype)
-output_right = numpy.zeros(num_frames, frames.dtype)
 
 input_left_chunk = numpy.zeros(CHUNK_SIZE, frames.dtype)
 input_right_chunk = numpy.zeros(CHUNK_SIZE, frames.dtype)
@@ -65,15 +64,13 @@ for start in range(0, num_frames, CHUNK_SIZE):
 
     instance.run(chunk_size)
 
-    output_left[start:end] = output_left_chunk[:chunk_size]
+    output[start:end, 0] = output_left_chunk[:chunk_size]
-    output_right[start:end] = output_right_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))
+if numpy.allclose(frames, output, rtol=0.5, atol=0.5):
-
-if numpy.allclose(frames, merged, rtol=0.5, atol=0.5):
     print("Warning: output is identical")
 
-soundfile.write('aoutt.flac', merged, sample_rate)
+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);
+        uint32_t nPorts = lilv_plugin_get_num_ports(plugin);
-        for (uint32_t i = 0; i < n_ports; i++) {
+        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;
+            LilvNode *nameNode = lilv_port_get_name(plugin, port);
-            lilv_port_get_range(plugin, port, &def, NULL, NULL);
+            const char* name = lilv_node_as_string(nameNode);
-            printf("Port %d: %s = %f\n", i, name, lilv_node_as_float(def));
+            lilv_node_free(nameNode);
-            lilv_node_free(def);
-        }
 
-        LilvNodes *features = lilv_plugin_get_required_features(plugin);
+            LilvNode* defNode = NULL;
-        LILV_FOREACH(nodes, i, features) {
+            lilv_port_get_range(plugin, port, &defNode, NULL, NULL);
-            LilvNode *n = lilv_nodes_get(features, i);
+            float defaultValue = lilv_node_as_float(defNode);
-            printf("Feat: %s\n", lilv_node_as_string(n));
+            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 input_buffer[BUFFER_SIZE * 2];
-    float out_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_left[i] = input_buffer[i * 2];
-            input_right[i] = buffer[i * 2 + 1];
+            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];
+            output_buffer[i * 2] = output_left[i];
-            out_buffer[i * 2 + 1] = output_right[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