Minecon724/project1
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

it work yay

Browse source
This commit is contained in:
Minecon724 2024-11-11 14:51:55 +01:00
parent 1ff7c3b76a
commit 9dfb188d8a
Signed by: Minecon724
GPG key ID: 3CCC4D267742C8E8
4 changed files with 68 additions and 59 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

15
main.py
View file

@ -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_right = numpy.zeros(num_frames, frames.dtype)
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)
@ -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_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))
if numpy.allclose(frames, merged, rtol=0.5, atol=0.5):
if numpy.allclose(frames, output, 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)

8
src/audiofile.c
View file

@ -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;

24
src/easy.c
View file

@ -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 *nameNode = lilv_port_get_name(plugin, port);
const char* name = lilv_node_as_string(nameNode);
lilv_node_free(nameNode);
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* defNode = NULL;
lilv_port_get_range(plugin, port, &defNode, NULL, NULL);
float defaultValue = lilv_node_as_float(defNode);
lilv_node_free(defNode);
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));
printf("Port %d: %s = %f\n", i, name, defaultValue);
}
}

80
src/main.c
View file

@ -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];
@ -50,55 +80,35 @@ int main(int argc, char *argv[]) {
lilv_instance_connect_port(instance, 1, input_right); // Input R
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