#!/usr/bin/env python3 # -*- coding: utf-8 -*- # LADSPA RDF python support # Copyright (C) 2011-2012 Filipe Coelho # # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # For a full copy of the GNU General Public License see the COPYING file # ------------------------------------------------------------------------------- # C types # Imports (Global) from ctypes import * from copy import deepcopy # Base Types LADSPA_Data = c_float LADSPA_Property = c_int LADSPA_PluginType = c_ulonglong # Unit Types LADSPA_UNIT_DB = 0x01 LADSPA_UNIT_COEF = 0x02 LADSPA_UNIT_HZ = 0x04 LADSPA_UNIT_S = 0x08 LADSPA_UNIT_MS = 0x10 LADSPA_UNIT_MIN = 0x20 LADSPA_UNIT_CLASS_AMPLITUDE = LADSPA_UNIT_DB|LADSPA_UNIT_COEF LADSPA_UNIT_CLASS_FREQUENCY = LADSPA_UNIT_HZ LADSPA_UNIT_CLASS_TIME = LADSPA_UNIT_S|LADSPA_UNIT_MS|LADSPA_UNIT_MIN # Port Types (Official API) LADSPA_PORT_INPUT = 0x1 LADSPA_PORT_OUTPUT = 0x2 LADSPA_PORT_CONTROL = 0x4 LADSPA_PORT_AUDIO = 0x8 # Port Hints LADSPA_PORT_UNIT = 0x1 LADSPA_PORT_DEFAULT = 0x2 LADSPA_PORT_LABEL = 0x4 # Plugin Types LADSPA_CLASS_UTILITY = 0x000000001 LADSPA_CLASS_GENERATOR = 0x000000002 LADSPA_CLASS_SIMULATOR = 0x000000004 LADSPA_CLASS_OSCILLATOR = 0x000000008 LADSPA_CLASS_TIME = 0x000000010 LADSPA_CLASS_DELAY = 0x000000020 LADSPA_CLASS_PHASER = 0x000000040 LADSPA_CLASS_FLANGER = 0x000000080 LADSPA_CLASS_CHORUS = 0x000000100 LADSPA_CLASS_REVERB = 0x000000200 LADSPA_CLASS_FREQUENCY = 0x000000400 LADSPA_CLASS_FREQUENCY_METER = 0x000000800 LADSPA_CLASS_FILTER = 0x000001000 LADSPA_CLASS_LOWPASS = 0x000002000 LADSPA_CLASS_HIGHPASS = 0x000004000 LADSPA_CLASS_BANDPASS = 0x000008000 LADSPA_CLASS_COMB = 0x000010000 LADSPA_CLASS_ALLPASS = 0x000020000 LADSPA_CLASS_EQ = 0x000040000 LADSPA_CLASS_PARAEQ = 0x000080000 LADSPA_CLASS_MULTIEQ = 0x000100000 LADSPA_CLASS_AMPLITUDE = 0x000200000 LADSPA_CLASS_PITCH = 0x000400000 LADSPA_CLASS_AMPLIFIER = 0x000800000 LADSPA_CLASS_WAVESHAPER = 0x001000000 LADSPA_CLASS_MODULATOR = 0x002000000 LADSPA_CLASS_DISTORTION = 0x004000000 LADSPA_CLASS_DYNAMICS = 0x008000000 LADSPA_CLASS_COMPRESSOR = 0x010000000 LADSPA_CLASS_EXPANDER = 0x020000000 LADSPA_CLASS_LIMITER = 0x040000000 LADSPA_CLASS_GATE = 0x080000000 LADSPA_CLASS_SPECTRAL = 0x100000000 LADSPA_CLASS_NOTCH = 0x200000000 LADSPA_GROUP_DYNAMICS = LADSPA_CLASS_DYNAMICS|LADSPA_CLASS_COMPRESSOR|LADSPA_CLASS_EXPANDER|LADSPA_CLASS_LIMITER|LADSPA_CLASS_GATE LADSPA_GROUP_AMPLITUDE = LADSPA_CLASS_AMPLITUDE|LADSPA_CLASS_AMPLIFIER|LADSPA_CLASS_WAVESHAPER|LADSPA_CLASS_MODULATOR|LADSPA_CLASS_DISTORTION|LADSPA_GROUP_DYNAMICS LADSPA_GROUP_EQ = LADSPA_CLASS_EQ|LADSPA_CLASS_PARAEQ|LADSPA_CLASS_MULTIEQ LADSPA_GROUP_FILTER = LADSPA_CLASS_FILTER|LADSPA_CLASS_LOWPASS|LADSPA_CLASS_HIGHPASS|LADSPA_CLASS_BANDPASS|LADSPA_CLASS_COMB|LADSPA_CLASS_ALLPASS|LADSPA_CLASS_NOTCH LADSPA_GROUP_FREQUENCY = LADSPA_CLASS_FREQUENCY|LADSPA_CLASS_FREQUENCY_METER|LADSPA_GROUP_FILTER|LADSPA_GROUP_EQ|LADSPA_CLASS_PITCH LADSPA_GROUP_SIMULATOR = LADSPA_CLASS_SIMULATOR|LADSPA_CLASS_REVERB LADSPA_GROUP_TIME = LADSPA_CLASS_TIME|LADSPA_CLASS_DELAY|LADSPA_CLASS_PHASER|LADSPA_CLASS_FLANGER|LADSPA_CLASS_CHORUS|LADSPA_CLASS_REVERB LADSPA_GROUP_GENERATOR = LADSPA_CLASS_GENERATOR|LADSPA_CLASS_OSCILLATOR # A Scale Point class LADSPA_RDF_ScalePoint(Structure): _fields_ = [ ("Value", LADSPA_Data), ("Label", c_char_p) ] # A Port class LADSPA_RDF_Port(Structure): _fields_ = [ ("Type", LADSPA_Property), ("Hints", LADSPA_Property), ("Label", c_char_p), ("Default", LADSPA_Data), ("Unit", LADSPA_Property), ("ScalePointCount", c_ulong), ("ScalePoints", POINTER(LADSPA_RDF_ScalePoint)) ] # The actual plugin descriptor class LADSPA_RDF_Descriptor(Structure): _fields_ = [ ("Type", LADSPA_PluginType), ("UniqueID", c_ulong), ("Title", c_char_p), ("Creator", c_char_p), ("PortCount", c_ulong), ("Ports", POINTER(LADSPA_RDF_Port)) ] # ------------------------------------------------------------------------------- # Python compatible C types PyLADSPA_RDF_ScalePoint = { 'Value': 0.0, 'Label': "" } PyLADSPA_RDF_Port = { 'Type': 0x0, 'Hints': 0x0, 'Label': "", 'Default': 0.0, 'Unit': 0x0, 'ScalePointCount': 0, 'ScalePoints': [], # Only here to help, NOT in the API: 'index': 0 } PyLADSPA_RDF_Descriptor = { 'Type': 0x0, 'UniqueID': 0, 'Title': "", 'Creator': "", 'PortCount': 0, 'Ports': [] } # ------------------------------------------------------------------------------- # RDF data and conversions # Namespaces NS_dc = "http://purl.org/dc/elements/1.1/" NS_rdf = "http://www.w3.org/1999/02/22-rdf-syntax-ns#" NS_rdfs = "http://www.w3.org/2000/01/rdf-schema#" NS_ladspa = "http://ladspa.org/ontology#" # Prefixes (sorted alphabetically and by type) rdf_prefix = { # Base types 'dc:creator': NS_dc+"creator", 'dc:rights': NS_dc+"rights", 'dc:title': NS_dc+"title", 'rdf:value': NS_rdf+"value", 'rdf:type': NS_rdf+"type", # LADSPA Stuff 'ladspa:forPort': NS_ladspa+"forPort", 'ladspa:hasLabel': NS_ladspa+"hasLabel", 'ladspa:hasPoint': NS_ladspa+"hasPoint", 'ladspa:hasPort': NS_ladspa+"hasPort", 'ladspa:hasPortValue': NS_ladspa+"hasPortValue", 'ladspa:hasScale': NS_ladspa+"hasScale", 'ladspa:hasSetting': NS_ladspa+"hasSetting", 'ladspa:hasUnit': NS_ladspa+"hasUnit", # LADSPA Extensions 'ladspa:NotchPlugin': NS_ladspa+"NotchPlugin", 'ladspa:SpectralPlugin': NS_ladspa+"SpectralPlugin" } def get_c_plugin_class(value): value_str = value.replace(NS_ladspa,"") if (value_str == "Plugin"): return 0 elif (value_str == "UtilityPlugin"): return LADSPA_CLASS_UTILITY elif (value_str == "GeneratorPlugin"): return LADSPA_CLASS_GENERATOR elif (value_str == "SimulatorPlugin"): return LADSPA_CLASS_SIMULATOR elif (value_str == "OscillatorPlugin"): return LADSPA_CLASS_OSCILLATOR elif (value_str == "TimePlugin"): return LADSPA_CLASS_TIME elif (value_str == "DelayPlugin"): return LADSPA_CLASS_DELAY elif (value_str == "PhaserPlugin"): return LADSPA_CLASS_PHASER elif (value_str == "FlangerPlugin"): return LADSPA_CLASS_FLANGER elif (value_str == "ChorusPlugin"): return LADSPA_CLASS_CHORUS elif (value_str == "ReverbPlugin"): return LADSPA_CLASS_REVERB elif (value_str == "FrequencyPlugin"): return LADSPA_CLASS_FREQUENCY elif (value_str == "FrequencyMeterPlugin"): return LADSPA_CLASS_FREQUENCY_METER elif (value_str == "FilterPlugin"): return LADSPA_CLASS_FILTER elif (value_str == "LowpassPlugin"): return LADSPA_CLASS_LOWPASS elif (value_str == "HighpassPlugin"): return LADSPA_CLASS_HIGHPASS elif (value_str == "BandpassPlugin"): return LADSPA_CLASS_BANDPASS elif (value_str == "CombPlugin"): return LADSPA_CLASS_COMB elif (value_str == "AllpassPlugin"): return LADSPA_CLASS_ALLPASS elif (value_str == "EQPlugin"): return LADSPA_CLASS_EQ elif (value_str == "ParaEQPlugin"): return LADSPA_CLASS_PARAEQ elif (value_str == "MultiEQPlugin"): return LADSPA_CLASS_MULTIEQ elif (value_str == "AmplitudePlugin"): return LADSPA_CLASS_AMPLITUDE elif (value_str == "PitchPlugin"): return LADSPA_CLASS_PITCH elif (value_str == "AmplifierPlugin"): return LADSPA_CLASS_AMPLIFIER elif (value_str == "WaveshaperPlugin"): return LADSPA_CLASS_WAVESHAPER elif (value_str == "ModulatorPlugin"): return LADSPA_CLASS_MODULATOR elif (value_str == "DistortionPlugin"): return LADSPA_CLASS_DISTORTION elif (value_str == "DynamicsPlugin"): return LADSPA_CLASS_DYNAMICS elif (value_str == "CompressorPlugin"): return LADSPA_CLASS_COMPRESSOR elif (value_str == "ExpanderPlugin"): return LADSPA_CLASS_EXPANDER elif (value_str == "LimiterPlugin"): return LADSPA_CLASS_LIMITER elif (value_str == "GatePlugin"): return LADSPA_CLASS_GATE elif (value_str == "SpectralPlugin"): return LADSPA_CLASS_SPECTRAL elif (value_str == "NotchPlugin"): return LADSPA_CLASS_NOTCH elif (value_str == "MixerPlugin"): return LADSPA_CLASS_EQ else: print("LADSPA_RDF - Got an unknown plugin type '%s'" % (value_str)) return 0 def get_c_port_type(value): value_str = value.replace(NS_ladspa,"") if (value_str == "Port"): return 0 elif (value_str == "ControlPort"): return LADSPA_PORT_CONTROL elif (value_str == "AudioPort"): return LADSPA_PORT_AUDIO elif (value_str == "InputPort"): return LADSPA_PORT_INPUT elif (value_str == "OutputPort"): return LADSPA_PORT_OUTPUT elif (value_str in ("ControlInputPort", "InputControlPort")): return LADSPA_PORT_CONTROL|LADSPA_PORT_INPUT elif (value_str in ("ControlOutputPort", "OutputControlPort")): return LADSPA_PORT_CONTROL|LADSPA_PORT_OUTPUT elif (value_str in ("AudioInputPort", "InputAudioPort")): return LADSPA_PORT_AUDIO|LADSPA_PORT_INPUT elif (value_str in ("AudioOutputPort", "OutputAudioPort")): return LADSPA_PORT_AUDIO|LADSPA_PORT_OUTPUT else: print("LADSPA_RDF - Got an unknown port type '%s'" % (value_str)) return 0 def get_c_unit_type(value): value_str = value.replace(NS_ladspa,"") if (value_str in ("Unit", "Units", "AmplitudeUnits", "FrequencyUnits", "TimeUnits")): return 0 elif (value_str == "dB"): return LADSPA_UNIT_DB elif (value_str == "coef"): return LADSPA_UNIT_COEF elif (value_str == "Hz"): return LADSPA_UNIT_HZ elif (value_str == "seconds"): return LADSPA_UNIT_S elif (value_str == "milliseconds"): return LADSPA_UNIT_MS elif (value_str == "minutes"): return LADSPA_UNIT_MIN else: print("LADSPA_RDF - Got an unknown unit type '%s'" % (value_str)) return 0 # ------------------------------------------------------------------------------- # Global objects global LADSPA_RDF_PATH, LADSPA_Plugins LADSPA_RDF_PATH = ("/usr/share/ladspa/rdf", "/usr/local/share/ladspa/rdf") LADSPA_Plugins = [] # Set LADSPA_RDF_PATH variable def set_rdf_path(PATH): global LADSPA_RDF_PATH LADSPA_RDF_PATH = PATH # ------------------------------------------------------------------------------- # Helper methods LADSPA_RDF_TYPE_PLUGIN = 1 LADSPA_RDF_TYPE_PORT = 2 # Check RDF Type def rdf_is_type(_subject, compare): if (type(_subject) == URIRef and NS_ladspa in _subject): if (compare == LADSPA_RDF_TYPE_PLUGIN): return bool(to_plugin_number(_subject).isdigit()) elif (compare == LADSPA_RDF_TYPE_PORT): return bool("." in to_plugin_number(_subject)) else: return False def to_float(rdf_item): return float(str(rdf_item).replace("f","")) # Convert RDF LADSPA subject into a number def to_plugin_number(_subject): return str(_subject).replace(NS_ladspa,"") # Convert RDF LADSPA subject into a plugin and port number def to_plugin_and_port_number(_subject): numbers = str(_subject).replace(NS_ladspa,"").split(".") return (numbers[0], numbers[1]) # Convert RDF LADSPA subject into a port number def to_plugin_port(_subject): return to_plugin_and_port_number(_subject)[1] # ------------------------------------------------------------------------------- # RDF store/retrieve data methods def check_and_add_plugin(plugin_id): global LADSPA_Plugins for i in range(len(LADSPA_Plugins)): if (LADSPA_Plugins[i]['UniqueID'] == plugin_id): return i else: plugin = deepcopy(PyLADSPA_RDF_Descriptor) plugin['UniqueID'] = plugin_id LADSPA_Plugins.append(plugin) return len(LADSPA_Plugins)-1 def set_plugin_value(plugin_id, key, value): global LADSPA_Plugins index = check_and_add_plugin(plugin_id) LADSPA_Plugins[index][key] = value def add_plugin_value(plugin_id, key, value): global LADSPA_Plugins index = check_and_add_plugin(plugin_id) LADSPA_Plugins[index][key] += value def or_plugin_value(plugin_id, key, value): global LADSPA_Plugins index = check_and_add_plugin(plugin_id) LADSPA_Plugins[index][key] |= value def append_plugin_value(plugin_id, key, value): global LADSPA_Plugins index = check_and_add_plugin(plugin_id) LADSPA_Plugins[index][key].append(value) def check_and_add_port(plugin_id, port_id): global LADSPA_Plugins index = check_and_add_plugin(plugin_id) Ports = LADSPA_Plugins[index]['Ports'] for i in range(len(Ports)): if (Ports[i]['index'] == port_id): return (index, i) else: pcount = LADSPA_Plugins[index]['PortCount'] port = deepcopy(PyLADSPA_RDF_Port) port['index'] = port_id Ports.append(port) LADSPA_Plugins[index]['PortCount'] += 1 return (index, pcount) def set_port_value(plugin_id, port_id, key, value): global LADSPA_Plugins i, j = check_and_add_port(plugin_id, port_id) LADSPA_Plugins[i]['Ports'][j][key] = value def add_port_value(plugin_id, port_id, key, value): global LADSPA_Plugins i, j = check_and_add_port(plugin_id, port_id) LADSPA_Plugins[i]['Ports'][j][key] += value def or_port_value(plugin_id, port_id, key, value): global LADSPA_Plugins i, j = check_and_add_port(plugin_id, port_id) LADSPA_Plugins[i]['Ports'][j][key] |= value def append_port_value(plugin_id, port_id, key, value): global LADSPA_Plugins i, j = check_and_add_port(plugin_id, port_id) LADSPA_Plugins[i]['Ports'][j][key].append(value) def add_scalepoint(plugin_id, port_id, value, label): global LADSPA_Plugins i, j = check_and_add_port(plugin_id, port_id) Port = LADSPA_Plugins[i]['Ports'][j] scalepoint = deepcopy(PyLADSPA_RDF_ScalePoint) scalepoint['Value'] = value scalepoint['Label'] = label Port['ScalePoints'].append(scalepoint) Port['ScalePointCount'] += 1 def set_port_default(plugin_id, port_id, value): global LADSPA_Plugins i, j = check_and_add_port(plugin_id, port_id) Port = LADSPA_Plugins[i]['Ports'][j] Port['Default'] = value Port['Hints'] |= LADSPA_PORT_DEFAULT def get_node_objects(value_nodes, n_subject): ret_nodes = [] for _subject, _predicate, _object in value_nodes: if (_subject == n_subject): ret_nodes.append((_predicate, _object)) return ret_nodes def append_and_sort(value, vlist): if (len(vlist) == 0): vlist.append(value) elif (value < vlist[0]): vlist.insert(0, value) elif (value > vlist[len(vlist)-1]): vlist.append(value) else: for i in range(len(vlist)): if (value < vlist[i]): vlist.insert(i, value) break else: print("LADSPA_RDF - CRITICAL ERROR #001") return vlist def get_value_index(value, vlist): for i in range(len(vlist)): if (vlist[i] == value): return i else: print("LADSPA_RDF - CRITICAL ERROR #002") return 0 # ------------------------------------------------------------------------------- # RDF sort data methods # Sort the plugin's port's ScalePoints by value def SORT_PyLADSPA_RDF_ScalePoints(old_dict_list): new_dict_list = [] indexes_list = [] for i in range(len(old_dict_list)): new_dict_list.append(deepcopy(PyLADSPA_RDF_ScalePoint)) append_and_sort(old_dict_list[i]['Value'], indexes_list) for i in range(len(old_dict_list)): index = get_value_index(old_dict_list[i]['Value'], indexes_list) new_dict_list[index]['Value'] = old_dict_list[i]['Value'] new_dict_list[index]['Label'] = old_dict_list[i]['Label'] return new_dict_list # Sort the plugin's port by index def SORT_PyLADSPA_RDF_Ports(old_dict_list): new_dict_list = [] max_index = -1 for i in range(len(old_dict_list)): if (old_dict_list[i]['index'] > max_index): max_index = old_dict_list[i]['index'] for i in range(max_index+1): new_dict_list.append(deepcopy(PyLADSPA_RDF_Port)) for i in range(len(old_dict_list)): index = old_dict_list[i]['index'] new_dict_list[index]['index'] = old_dict_list[i]['index'] new_dict_list[index]['Type'] = old_dict_list[i]['Type'] new_dict_list[index]['Hints'] = old_dict_list[i]['Hints'] new_dict_list[index]['Unit'] = old_dict_list[i]['Unit'] new_dict_list[index]['Default'] = old_dict_list[i]['Default'] new_dict_list[index]['Label'] = old_dict_list[i]['Label'] new_dict_list[index]['ScalePointCount'] = old_dict_list[i]['ScalePointCount'] new_dict_list[index]['ScalePoints'] = SORT_PyLADSPA_RDF_ScalePoints(old_dict_list[i]['ScalePoints']) return new_dict_list # ------------------------------------------------------------------------------- # RDF data parsing from rdflib import ConjunctiveGraph, URIRef, Literal, BNode # Fully parse rdf file def parse_rdf_file(filename): primer = ConjunctiveGraph() try: primer.parse(filename, format='xml') rdf_list = [(x, y, z) for x, y, z in primer] except: rdf_list = [] # For BNodes index_nodes = [] # Subject [index], Predicate, Plugin, Port value_nodes = [] # Subject [index], Predicate, Object # Parse RDF list for _subject, _predicate, _object in rdf_list: # Fix broken or old plugins if (_predicate == URIRef("http://ladspa.org/ontology#hasUnits")): _predicate = URIRef(rdf_prefix['ladspa:hasUnit']) # Plugin information if (rdf_is_type(_subject, LADSPA_RDF_TYPE_PLUGIN)): plugin_id = int(to_plugin_number(_subject)) if (_predicate == URIRef(rdf_prefix['dc:creator'])): set_plugin_value(plugin_id, 'Creator', str(_object)) elif (_predicate == URIRef(rdf_prefix['dc:rights'])): # No useful information here pass elif (_predicate == URIRef(rdf_prefix['dc:title'])): set_plugin_value(plugin_id, 'Title', str(_object)) elif (_predicate == URIRef(rdf_prefix['rdf:type'])): c_class = get_c_plugin_class(str(_object)) or_plugin_value(plugin_id, 'Type', c_class) elif (_predicate == URIRef(rdf_prefix['ladspa:hasPort'])): # No useful information here pass elif (_predicate == URIRef(rdf_prefix['ladspa:hasSetting'])): index_nodes.append((_object, _predicate, plugin_id, None)) else: print("LADSPA_RDF - Plugin predicate '%s' not handled" % (_predicate)) # Port information elif (rdf_is_type(_subject, LADSPA_RDF_TYPE_PORT)): plugin_port = to_plugin_and_port_number(_subject) plugin_id = int(plugin_port[0]) port_id = int(plugin_port[1]) if (_predicate == URIRef(rdf_prefix['rdf:type'])): c_class = get_c_port_type(str(_object)) or_port_value(plugin_id, port_id, 'Type', c_class) elif (_predicate == URIRef(rdf_prefix['ladspa:hasLabel'])): set_port_value(plugin_id, port_id, 'Label', str(_object)) or_port_value(plugin_id, port_id, 'Hints', LADSPA_PORT_LABEL) elif (_predicate == URIRef(rdf_prefix['ladspa:hasScale'])): index_nodes.append((_object, _predicate, plugin_id, port_id)) elif (_predicate == URIRef(rdf_prefix['ladspa:hasUnit'])): c_unit = get_c_unit_type(str(_object)) set_port_value(plugin_id, port_id, 'Unit', c_unit) or_port_value(plugin_id, port_id, 'Hints', LADSPA_PORT_UNIT) else: print("LADSPA_RDF - Port predicate '%s' not handled" % (_predicate)) # These "extensions" are already implemented elif (_subject in (URIRef(rdf_prefix['ladspa:NotchPlugin']), URIRef(rdf_prefix['ladspa:SpectralPlugin']))): pass elif (type(_subject) == BNode): value_nodes.append((_subject, _predicate, _object)) else: print("LADSPA_RDF - Unknown subject type '%s'" % (_subject)) # Parse BNodes, indexes bnodes_data_dump = [] for n_subject, n_predicate, plugin_id, port_id in index_nodes: n_objects = get_node_objects(value_nodes, n_subject) for subn_predicate, subn_subject in n_objects: subn_objects = get_node_objects(value_nodes, subn_subject) for real_predicate, real_object in subn_objects: if (n_predicate == URIRef(rdf_prefix['ladspa:hasScale']) and subn_predicate == URIRef(rdf_prefix['ladspa:hasPoint'])): bnodes_data_dump.append(("scalepoint", subn_subject, plugin_id, port_id, real_predicate, real_object)) elif (n_predicate == URIRef(rdf_prefix['ladspa:hasSetting']) and subn_predicate == URIRef(rdf_prefix['ladspa:hasPortValue'])): bnodes_data_dump.append(("port_default", subn_subject, plugin_id, port_id, real_predicate, real_object)) else: print("LADSPA_RDF - Unknown BNode combo - '%s' + '%s'" % (n_predicate, subn_predicate)) # Process BNodes, values scalepoints = [] # subject, plugin, port, value, label port_defaults = [] # subject, plugin, port, def-value for n_type, n_subject, n_plugin, n_port, n_predicate, n_object in bnodes_data_dump: if (n_type == "scalepoint"): for i in range(len(scalepoints)): if (scalepoints[i][0] == n_subject): index = i break else: scalepoints.append([n_subject, n_plugin, n_port, None, None]) index = len(scalepoints)-1 if (n_predicate == URIRef(rdf_prefix['rdf:value'])): scalepoints[index][3] = to_float(n_object) elif (n_predicate == URIRef(rdf_prefix['ladspa:hasLabel'])): scalepoints[index][4] = str(n_object) elif (n_type == "port_default"): for i in range(len(port_defaults)): if (port_defaults[i][0] == n_subject): index = i break else: port_defaults.append([n_subject, n_plugin, None, None]) index = len(port_defaults)-1 if (n_predicate == URIRef(rdf_prefix['ladspa:forPort'])): port_defaults[index][2] = int(to_plugin_port(n_object)) elif (n_predicate == URIRef(rdf_prefix['rdf:value'])): port_defaults[index][3] = to_float(n_object) # Now add the last information for scalepoint in scalepoints: index, plugin_id, port_id, value, label = scalepoint add_scalepoint(plugin_id, port_id, value, label) for port_default in port_defaults: index, plugin_id, port_id, value = port_default set_port_default(plugin_id, port_id, value) # ------------------------------------------------------------------------------- # LADSPA_RDF main methods import os # Main function - check all rdfs for information about ladspa plugins def recheck_all_plugins(qobject, start_value, percent_value, m_value): global LADSPA_RDF_PATH, LADSPA_Plugins LADSPA_Plugins = [] rdf_files = [] rdf_extensions = (".rdf", ".rdF", ".rDF", ".RDF", ".RDf", "Rdf") # Get all RDF files for PATH in LADSPA_RDF_PATH: for root, dirs, files in os.walk(PATH): for filename in [filename for filename in files if filename.endswith(rdf_extensions)]: rdf_files.append(os.path.join(root, filename)) # Parse all RDF files for i in range(len(rdf_files)): rdf_file = rdf_files[i] # Tell GUI we're parsing this bundle if (qobject): percent = (float(i) / len(rdf_files) ) * percent_value qobject.pluginLook(start_value + (percent * m_value), rdf_file) # Parse RDF parse_rdf_file(rdf_file) return LADSPA_Plugins # Convert PyLADSPA_Plugins into ctype structs def get_c_ladspa_rdfs(PyPluginList): C_LADSPA_Plugins = [] c_unicode_error_str = "(unicode error)".encode("utf-8") for plugin in PyPluginList: # Sort the ports by index ladspa_ports = SORT_PyLADSPA_RDF_Ports(plugin['Ports']) # Initial data desc = LADSPA_RDF_Descriptor() desc.Type = plugin['Type'] desc.UniqueID = plugin['UniqueID'] try: if (plugin['Title']) desc.Title = plugin['Title'].encode("utf-8") else: desc.Title = None except: desc.Title = c_unicode_error_str try: if (plugin['Creator']) desc.Creator = plugin['Creator'].encode("utf-8") else: desc.Creator = None except: desc.Creator = c_unicode_error_str desc.PortCount = plugin['PortCount'] # Ports _PortType = LADSPA_RDF_Port*desc.PortCount desc.Ports = _PortType() for i in range(desc.PortCount): port = LADSPA_RDF_Port() py_port = ladspa_ports[i] port.Type = py_port['Type'] port.Hints = py_port['Hints'] try: port.Label = py_port['Label'].encode("utf-8") except: port.Label = c_unicode_error_str port.Default = py_port['Default'] port.Unit = py_port['Unit'] # ScalePoints port.ScalePointCount = py_port['ScalePointCount'] _ScalePointType = LADSPA_RDF_ScalePoint*port.ScalePointCount port.ScalePoints = _ScalePointType() for j in range(port.ScalePointCount): scalepoint = LADSPA_RDF_ScalePoint() py_scalepoint = py_port['ScalePoints'][j] try: scalepoint.Label = py_scalepoint['Label'].encode("utf-8") except: scalepoint.Label = c_unicode_error_str scalepoint.Value = py_scalepoint['Value'] port.ScalePoints[j] = scalepoint desc.Ports[i] = port C_LADSPA_Plugins.append(desc) return C_LADSPA_Plugins # ------------------------------------------------------------------------------- # Implementation test #if __name__ == '__main__': #set_rdf_path(["/home/falktx/Personal/FOSS/GIT/Cadence/lrdf/"]) #plugins = recheck_all_plugins(None, 0) #for plugin in LADSPA_Plugins: #print("----------------------") #print("Type: 0x%X" % (plugin["Type"])) #print("UniqueID: %i" % (plugin["UniqueID"])) #print("Title: %s" % (plugin["Title"])) #print("Creator: %s" % (plugin["Creator"])) #print("Ports: (%i)" % (plugin["PortCount"])) #for i in range(plugin["PortCount"]): #port = plugin["Ports"][i] #print(" --> Port #%i" % (i+1)) #print(" Type: 0x%X" % (port["Type"])) #print(" Hints: 0x%X" % (port["Hints"])) #print(" Label: %s" % (port["Label"])) #print(" Default: %f" % (port["Default"])) #print(" Unit: 0x%i" % (port["Unit"])) #print(" ScalePoints: (%i)" % (port["ScalePointCount"])) #for j in range(port["ScalePointCount"]): #scalepoint = port["ScalePoints"][j] #print(" --> ScalePoint #%i" % (j+1)) #print(" Value: %f" % (scalepoint["Value"])) #print(" Label: %s" % (scalepoint["Label"])) #print(len(LADSPA_Plugins)) #get_c_ladspa_rdfs(LADSPA_Plugins)