From 31cc05d5ef6e840ebe2b4c265f374f913f4758cc Mon Sep 17 00:00:00 2001 From: David Robillard Date: Sat, 26 Dec 2020 19:22:03 +0100 Subject: Format all code with clang-format --- utils/lv2bench.c | 436 ++++++++++++++++++++++++++++--------------------------- 1 file changed, 219 insertions(+), 217 deletions(-) (limited to 'utils/lv2bench.c') diff --git a/utils/lv2bench.c b/utils/lv2bench.c index 000f062..7365b5b 100644 --- a/utils/lv2bench.c +++ b/utils/lv2bench.c @@ -47,236 +47,238 @@ static bool full_output = false; static void print_version(void) { - printf( - "lv2bench (lilv) " LILV_VERSION "\n" - "Copyright 2012-2019 David Robillard \n" - "License: \n" - "This is free software: you are free to change and redistribute it.\n" - "There is NO WARRANTY, to the extent permitted by law.\n"); + printf("lv2bench (lilv) " LILV_VERSION "\n" + "Copyright 2012-2019 David Robillard \n" + "License: \n" + "This is free software: you are free to change and redistribute it.\n" + "There is NO WARRANTY, to the extent permitted by law.\n"); } static void print_usage(void) { - printf("lv2bench - Benchmark all installed and supported LV2 plugins.\n"); - printf("Usage: lv2bench [OPTIONS] [PLUGIN_URI]\n"); - printf("\n"); - printf(" -b BLOCK_SIZE Specify block size, in audio frames.\n"); - printf(" -f, --full Full plottable output.\n"); - printf(" -h, --help Display this help and exit.\n"); - printf(" -n FRAMES Total number of audio frames to process\n"); - printf(" --version Display version information and exit\n"); + printf("lv2bench - Benchmark all installed and supported LV2 plugins.\n"); + printf("Usage: lv2bench [OPTIONS] [PLUGIN_URI]\n"); + printf("\n"); + printf(" -b BLOCK_SIZE Specify block size, in audio frames.\n"); + printf(" -f, --full Full plottable output.\n"); + printf(" -h, --help Display this help and exit.\n"); + printf(" -n FRAMES Total number of audio frames to process\n"); + printf(" --version Display version information and exit\n"); } static double bench(const LilvPlugin* p, uint32_t sample_count, uint32_t block_size) { - URITable uri_table; - uri_table_init(&uri_table); - - LV2_URID_Map map = { &uri_table, uri_table_map }; - LV2_Feature map_feature = { LV2_URID_MAP_URI, &map }; - LV2_URID_Unmap unmap = { &uri_table, uri_table_unmap }; - LV2_Feature unmap_feature = { LV2_URID_UNMAP_URI, &unmap }; - const LV2_Feature* features[] = { &map_feature, &unmap_feature, NULL }; - - float* const buf = (float*)calloc(block_size * 2, sizeof(float)); - float* const in = buf; - float* const out = buf + block_size; - if (!buf) { - fprintf(stderr, "Out of memory\n"); - return 0.0; - } - - const size_t atom_capacity = 1024; - - LV2_Atom_Sequence seq_in = { - { sizeof(LV2_Atom_Sequence_Body), - uri_table_map(&uri_table, LV2_ATOM__Sequence) }, - { 0, 0 } }; - - LV2_Atom_Sequence* seq_out = (LV2_Atom_Sequence*)malloc( - sizeof(LV2_Atom_Sequence) + atom_capacity); - - const char* uri = lilv_node_as_string(lilv_plugin_get_uri(p)); - LilvNodes* required = lilv_plugin_get_required_features(p); - LILV_FOREACH(nodes, i, required) { - const LilvNode* feature = lilv_nodes_get(required, i); - if (!lilv_node_equals(feature, urid_map)) { - fprintf(stderr, "<%s> requires feature <%s>, skipping\n", - uri, lilv_node_as_uri(feature)); - free(seq_out); - free(buf); - uri_table_destroy(&uri_table); - return 0.0; - } - } - - LilvInstance* instance = lilv_plugin_instantiate(p, 48000.0, features); - if (!instance) { - fprintf(stderr, "Failed to instantiate <%s>\n", - lilv_node_as_uri(lilv_plugin_get_uri(p))); - free(seq_out); - free(buf); - uri_table_destroy(&uri_table); - return 0.0; - } - - const uint32_t n_ports = lilv_plugin_get_num_ports(p); - float* const mins = (float*)calloc(n_ports, sizeof(float)); - float* const maxes = (float*)calloc(n_ports, sizeof(float)); - float* const controls = (float*)calloc(n_ports, sizeof(float)); - lilv_plugin_get_port_ranges_float(p, mins, maxes, controls); - - for (uint32_t index = 0; index < n_ports; ++index) { - const LilvPort* port = lilv_plugin_get_port_by_index(p, index); - if (lilv_port_is_a(p, port, lv2_ControlPort)) { - if (isnan(controls[index])) { - if (!isnan(mins[index])) { - controls[index] = mins[index]; - } else if (!isnan(maxes[index])) { - controls[index] = maxes[index]; - } else { - controls[index] = 0.0; - } - } - lilv_instance_connect_port(instance, index, &controls[index]); - } else if (lilv_port_is_a(p, port, lv2_AudioPort) || - lilv_port_is_a(p, port, lv2_CVPort)) { - if (lilv_port_is_a(p, port, lv2_InputPort)) { - lilv_instance_connect_port(instance, index, in); - } else if (lilv_port_is_a(p, port, lv2_OutputPort)) { - lilv_instance_connect_port(instance, index, out); - } else { - fprintf(stderr, "<%s> port %u neither input nor output, skipping\n", - uri, index); - lilv_instance_free(instance); - free(seq_out); - free(buf); - free(controls); - uri_table_destroy(&uri_table); - return 0.0; - } - } else if (lilv_port_is_a(p, port, atom_AtomPort)) { - if (lilv_port_is_a(p, port, lv2_InputPort)) { - lilv_instance_connect_port(instance, index, &seq_in); - } else { - lilv_instance_connect_port(instance, index, seq_out); - } - } else { - fprintf(stderr, "<%s> port %u has unknown type, skipping\n", - uri, index); - lilv_instance_free(instance); - free(seq_out); - free(buf); - free(controls); - uri_table_destroy(&uri_table); - return 0.0; - } - } - - lilv_instance_activate(instance); - - struct timespec ts = bench_start(); - for (uint32_t i = 0; i < (sample_count / block_size); ++i) { - seq_in.atom.size = sizeof(LV2_Atom_Sequence_Body); - seq_in.atom.type = uri_table_map(&uri_table, LV2_ATOM__Sequence); - seq_out->atom.size = atom_capacity; - seq_out->atom.type = uri_table_map(&uri_table, LV2_ATOM__Chunk); - - lilv_instance_run(instance, block_size); - } - const double elapsed = bench_end(&ts); - - lilv_instance_deactivate(instance); - lilv_instance_free(instance); - free(controls); - free(maxes); - free(mins); - free(seq_out); - - uri_table_destroy(&uri_table); - - if (full_output) { - printf("%u %u ", block_size, sample_count); - } - printf("%lf %s\n", elapsed, uri); - - free(buf); - return elapsed; + URITable uri_table; + uri_table_init(&uri_table); + + LV2_URID_Map map = {&uri_table, uri_table_map}; + LV2_Feature map_feature = {LV2_URID_MAP_URI, &map}; + LV2_URID_Unmap unmap = {&uri_table, uri_table_unmap}; + LV2_Feature unmap_feature = {LV2_URID_UNMAP_URI, &unmap}; + const LV2_Feature* features[] = {&map_feature, &unmap_feature, NULL}; + + float* const buf = (float*)calloc(block_size * 2, sizeof(float)); + float* const in = buf; + float* const out = buf + block_size; + if (!buf) { + fprintf(stderr, "Out of memory\n"); + return 0.0; + } + + const size_t atom_capacity = 1024; + + LV2_Atom_Sequence seq_in = {{sizeof(LV2_Atom_Sequence_Body), + uri_table_map(&uri_table, LV2_ATOM__Sequence)}, + {0, 0}}; + + LV2_Atom_Sequence* seq_out = + (LV2_Atom_Sequence*)malloc(sizeof(LV2_Atom_Sequence) + atom_capacity); + + const char* uri = lilv_node_as_string(lilv_plugin_get_uri(p)); + LilvNodes* required = lilv_plugin_get_required_features(p); + LILV_FOREACH (nodes, i, required) { + const LilvNode* feature = lilv_nodes_get(required, i); + if (!lilv_node_equals(feature, urid_map)) { + fprintf(stderr, + "<%s> requires feature <%s>, skipping\n", + uri, + lilv_node_as_uri(feature)); + free(seq_out); + free(buf); + uri_table_destroy(&uri_table); + return 0.0; + } + } + + LilvInstance* instance = lilv_plugin_instantiate(p, 48000.0, features); + if (!instance) { + fprintf(stderr, + "Failed to instantiate <%s>\n", + lilv_node_as_uri(lilv_plugin_get_uri(p))); + free(seq_out); + free(buf); + uri_table_destroy(&uri_table); + return 0.0; + } + + const uint32_t n_ports = lilv_plugin_get_num_ports(p); + float* const mins = (float*)calloc(n_ports, sizeof(float)); + float* const maxes = (float*)calloc(n_ports, sizeof(float)); + float* const controls = (float*)calloc(n_ports, sizeof(float)); + lilv_plugin_get_port_ranges_float(p, mins, maxes, controls); + + for (uint32_t index = 0; index < n_ports; ++index) { + const LilvPort* port = lilv_plugin_get_port_by_index(p, index); + if (lilv_port_is_a(p, port, lv2_ControlPort)) { + if (isnan(controls[index])) { + if (!isnan(mins[index])) { + controls[index] = mins[index]; + } else if (!isnan(maxes[index])) { + controls[index] = maxes[index]; + } else { + controls[index] = 0.0; + } + } + lilv_instance_connect_port(instance, index, &controls[index]); + } else if (lilv_port_is_a(p, port, lv2_AudioPort) || + lilv_port_is_a(p, port, lv2_CVPort)) { + if (lilv_port_is_a(p, port, lv2_InputPort)) { + lilv_instance_connect_port(instance, index, in); + } else if (lilv_port_is_a(p, port, lv2_OutputPort)) { + lilv_instance_connect_port(instance, index, out); + } else { + fprintf(stderr, + "<%s> port %u neither input nor output, skipping\n", + uri, + index); + lilv_instance_free(instance); + free(seq_out); + free(buf); + free(controls); + uri_table_destroy(&uri_table); + return 0.0; + } + } else if (lilv_port_is_a(p, port, atom_AtomPort)) { + if (lilv_port_is_a(p, port, lv2_InputPort)) { + lilv_instance_connect_port(instance, index, &seq_in); + } else { + lilv_instance_connect_port(instance, index, seq_out); + } + } else { + fprintf(stderr, "<%s> port %u has unknown type, skipping\n", uri, index); + lilv_instance_free(instance); + free(seq_out); + free(buf); + free(controls); + uri_table_destroy(&uri_table); + return 0.0; + } + } + + lilv_instance_activate(instance); + + struct timespec ts = bench_start(); + for (uint32_t i = 0; i < (sample_count / block_size); ++i) { + seq_in.atom.size = sizeof(LV2_Atom_Sequence_Body); + seq_in.atom.type = uri_table_map(&uri_table, LV2_ATOM__Sequence); + seq_out->atom.size = atom_capacity; + seq_out->atom.type = uri_table_map(&uri_table, LV2_ATOM__Chunk); + + lilv_instance_run(instance, block_size); + } + const double elapsed = bench_end(&ts); + + lilv_instance_deactivate(instance); + lilv_instance_free(instance); + free(controls); + free(maxes); + free(mins); + free(seq_out); + + uri_table_destroy(&uri_table); + + if (full_output) { + printf("%u %u ", block_size, sample_count); + } + printf("%lf %s\n", elapsed, uri); + + free(buf); + return elapsed; } int main(int argc, char** argv) { - uint32_t block_size = 512; - uint32_t sample_count = (1 << 19); - - int a = 1; - for (; a < argc; ++a) { - if (!strcmp(argv[a], "--version")) { - print_version(); - return 0; - } - - if (!strcmp(argv[a], "--help")) { - print_usage(); - return 0; - } - - if (!strcmp(argv[a], "-f")) { - full_output = true; - } else if (!strcmp(argv[a], "-n") && (a + 1 < argc)) { - sample_count = atoi(argv[++a]); - } else if (!strcmp(argv[a], "-b") && (a + 1 < argc)) { - block_size = atoi(argv[++a]); - } else if (argv[a][0] != '-') { - break; - } else { - print_usage(); - return 1; - } - } - - const char* const plugin_uri_str = (a < argc ? argv[a++] : NULL); - - LilvWorld* world = lilv_world_new(); - lilv_world_load_all(world); - - atom_AtomPort = lilv_new_uri(world, LV2_ATOM__AtomPort); - atom_Sequence = lilv_new_uri(world, LV2_ATOM__Sequence); - lv2_AudioPort = lilv_new_uri(world, LV2_CORE__AudioPort); - lv2_CVPort = lilv_new_uri(world, LV2_CORE__CVPort); - lv2_ControlPort = lilv_new_uri(world, LV2_CORE__ControlPort); - lv2_InputPort = lilv_new_uri(world, LV2_CORE__InputPort); - lv2_OutputPort = lilv_new_uri(world, LV2_CORE__OutputPort); - urid_map = lilv_new_uri(world, LV2_URID__map); - - if (full_output) { - printf("# Block Samples Time Plugin\n"); - } - - const LilvPlugins* plugins = lilv_world_get_all_plugins(world); - if (plugin_uri_str) { - LilvNode* uri = lilv_new_uri(world, plugin_uri_str); - bench(lilv_plugins_get_by_uri(plugins, uri), sample_count, block_size); - lilv_node_free(uri); - } else { - LILV_FOREACH(plugins, i, plugins) { - bench(lilv_plugins_get(plugins, i), sample_count, block_size); - } - } - - lilv_node_free(urid_map); - lilv_node_free(lv2_OutputPort); - lilv_node_free(lv2_InputPort); - lilv_node_free(lv2_ControlPort); - lilv_node_free(lv2_CVPort); - lilv_node_free(lv2_AudioPort); - lilv_node_free(atom_Sequence); - lilv_node_free(atom_AtomPort); - - lilv_world_free(world); - - return 0; + uint32_t block_size = 512; + uint32_t sample_count = (1 << 19); + + int a = 1; + for (; a < argc; ++a) { + if (!strcmp(argv[a], "--version")) { + print_version(); + return 0; + } + + if (!strcmp(argv[a], "--help")) { + print_usage(); + return 0; + } + + if (!strcmp(argv[a], "-f")) { + full_output = true; + } else if (!strcmp(argv[a], "-n") && (a + 1 < argc)) { + sample_count = atoi(argv[++a]); + } else if (!strcmp(argv[a], "-b") && (a + 1 < argc)) { + block_size = atoi(argv[++a]); + } else if (argv[a][0] != '-') { + break; + } else { + print_usage(); + return 1; + } + } + + const char* const plugin_uri_str = (a < argc ? argv[a++] : NULL); + + LilvWorld* world = lilv_world_new(); + lilv_world_load_all(world); + + atom_AtomPort = lilv_new_uri(world, LV2_ATOM__AtomPort); + atom_Sequence = lilv_new_uri(world, LV2_ATOM__Sequence); + lv2_AudioPort = lilv_new_uri(world, LV2_CORE__AudioPort); + lv2_CVPort = lilv_new_uri(world, LV2_CORE__CVPort); + lv2_ControlPort = lilv_new_uri(world, LV2_CORE__ControlPort); + lv2_InputPort = lilv_new_uri(world, LV2_CORE__InputPort); + lv2_OutputPort = lilv_new_uri(world, LV2_CORE__OutputPort); + urid_map = lilv_new_uri(world, LV2_URID__map); + + if (full_output) { + printf("# Block Samples Time Plugin\n"); + } + + const LilvPlugins* plugins = lilv_world_get_all_plugins(world); + if (plugin_uri_str) { + LilvNode* uri = lilv_new_uri(world, plugin_uri_str); + bench(lilv_plugins_get_by_uri(plugins, uri), sample_count, block_size); + lilv_node_free(uri); + } else { + LILV_FOREACH (plugins, i, plugins) { + bench(lilv_plugins_get(plugins, i), sample_count, block_size); + } + } + + lilv_node_free(urid_map); + lilv_node_free(lv2_OutputPort); + lilv_node_free(lv2_InputPort); + lilv_node_free(lv2_ControlPort); + lilv_node_free(lv2_CVPort); + lilv_node_free(lv2_AudioPort); + lilv_node_free(atom_Sequence); + lilv_node_free(atom_AtomPort); + + lilv_world_free(world); + + return 0; } -- cgit v1.2.1