Exemplo n.º 1
0
def get_pedalboards():
    def get_presets(p):
        presets = p.get_related(pset.Preset)
        def get_preset_data(preset):
            W.load_resource(preset.me)
            label = W.find_nodes(preset.me, rdfs.label.me, None).get_first().as_string()
            return dict(uri=preset.as_string(), label=label)
        return list(LILV_FOREACH(presets, get_preset_data))

    pedalboards = []

    for pedalboard in PLUGINS:
        # check if the plugin is a pedalboard
        def fill_in_type(node):
            return node.as_string()
        plugin_types = [i for i in LILV_FOREACH(pedalboard.get_value(rdf.type_), fill_in_type)]

        if "http://portalmod.com/ns/modpedal#Pedalboard" not in plugin_types:
            continue

        pedalboards.append({
            'bundlepath': lilv.lilv_uri_to_path(pedalboard.get_bundle_uri().as_string()),
            'uri':  pedalboard.get_uri().as_string(),
            'name': pedalboard.get_value(modpedal.name).get_first().as_string(),
            'screenshot': lilv.lilv_uri_to_path(pedalboard.get_value(modpedal.screenshot).get_first().as_string()),
            'thumbnail':  lilv.lilv_uri_to_path(pedalboard.get_value(modpedal.thumbnail).get_first().as_string()),
            'width':  pedalboard.get_value(modpedal.width).get_first().as_int(),
            'height': pedalboard.get_value(modpedal.height).get_first().as_int(),
            'presets': get_presets(pedalboard)
        })

    return pedalboards
Exemplo n.º 2
0
Arquivo: lv2.py Projeto: EQ4/mod-ui
def get_pedalboards(asDictionary):
    global W, PLUGINS

    # define needed namespaces
    rdf      = NS(W, lilv.LILV_NS_RDF)
    rdfs     = NS(W, lilv.LILV_NS_RDFS)
    pset     = NS(W, "http://lv2plug.in/ns/ext/presets#")
    modpedal = NS(W, "http://moddevices.com/ns/modpedal#")

    # fill in presets for a plugin
    def get_presets(p):
        presets = p.get_related(pset.Preset)
        def get_preset_data(preset):
            W.load_resource(preset.me)
            label = W.find_nodes(preset.me, rdfs.label.me, None).get_first().as_string()
            return { 'uri': preset.as_string(), 'label': label }
        return list(LILV_FOREACH(presets, get_preset_data))

    # check each plugin for a pedalboard type
    if asDictionary:
        pedalboards = {}
    else:
        pedalboards = []

    for pedalboard in PLUGINS:
        # check if the plugin is a pedalboard
        def fill_in_type(node):
            return node.as_string()
        plugin_types = [i for i in LILV_FOREACH(pedalboard.get_value(rdf.type_), fill_in_type)]

        if "http://moddevices.com/ns/modpedal#Pedalboard" not in plugin_types:
            continue

        # ready
        pedalboard = {
            'bundlepath': lilv.lilv_uri_to_path(pedalboard.get_bundle_uri().as_string()),
            'name': pedalboard.get_name().as_string(),
            'uri':  pedalboard.get_uri().as_string(),
            'screenshot': lilv.lilv_uri_to_path(pedalboard.get_value(modpedal.screenshot).get_first().as_string() or ""),
            'thumbnail':  lilv.lilv_uri_to_path(pedalboard.get_value(modpedal.thumbnail).get_first().as_string() or ""),
            'width':  pedalboard.get_value(modpedal.width).get_first().as_int(),
            'height': pedalboard.get_value(modpedal.height).get_first().as_int(),
            'presets': get_presets(pedalboard)
        }

        if asDictionary:
            pedalboards[pedalboard['uri']] = pedalboard
        else:
            pedalboards.append(pedalboard)

    return pedalboards
Exemplo n.º 3
0
def refresh():
    global W, BUNDLES, PLUGINS, PLUGNFO, PLUGNFOk

    BUNDLES = []
    PLUGINS = W.get_all_plugins()
    PLUGNFO = {}
    PLUGNFOk = []

    # Make a list of all installed bundles
    for p in PLUGINS:
        bundles = lilv.lilv_plugin_get_data_uris(p.me)

        # store empty dict for later
        uri = p.get_uri().as_uri()
        PLUGNFO[uri] = {}
        PLUGNFOk.append(uri)

        it = lilv.lilv_nodes_begin(bundles)
        while not lilv.lilv_nodes_is_end(bundles, it):
            bundle = lilv.lilv_nodes_get(bundles, it)
            it = lilv.lilv_nodes_next(bundles, it)

            if bundle is None:
                continue
            if not lilv.lilv_node_is_uri(bundle):
                continue

            bundle = os.path.dirname(
                lilv.lilv_uri_to_path(lilv.lilv_node_as_uri(bundle)))

            if not bundle.endswith(os.sep):
                bundle += os.sep

            if bundle not in BUNDLES:
                BUNDLES.append(bundle)
Exemplo n.º 4
0
    def generate_bundles(self):
        if not self.useAbsolutePath:
            return []

        bundles = []
        bnodes = lilv.lilv_plugin_get_data_uris(self.plugin.me)

        it = lilv.lilv_nodes_begin(bnodes)
        while not lilv.lilv_nodes_is_end(bnodes, it):
            bnode = lilv.lilv_nodes_get(bnodes, it)
            it = lilv.lilv_nodes_next(bnodes, it)

            if bnode is None:
                continue
            if not lilv.lilv_node_is_uri(bnode):
                continue

            bpath = os.path.abspath(
                os.path.dirname(
                    lilv.lilv_uri_to_path(lilv.lilv_node_as_uri(bnode))))

            if not bpath.endswith(os.sep):
                bpath += os.sep

            if bpath not in bundles:
                bundles.append(bpath)

        if self.bundle not in bundles:
            bundles.append(self.bundle)

        del bnodes, it

        return bundles
Exemplo n.º 5
0
    def generate_bundles(self):
        if not self.useAbsolutePath:
            return []

        bundles = []
        bnodes = lilv.lilv_plugin_get_data_uris(self.plugin.me)

        it = lilv.lilv_nodes_begin(bnodes)
        while not lilv.lilv_nodes_is_end(bnodes, it):
            bnode = lilv.lilv_nodes_get(bnodes, it)
            it = lilv.lilv_nodes_next(bnodes, it)

            if bnode is None:
                continue
            if not lilv.lilv_node_is_uri(bnode):
                continue

            bpath = os.path.abspath(
                os.path.dirname(
                    lilv.lilv_uri_to_path(lilv.lilv_node_as_uri(bnode))
                )
            )

            if not bpath.endswith(os.sep):
                bpath += os.sep

            if bpath not in bundles:
                bundles.append(bpath)

        if self.bundle not in bundles:
            bundles.append(self.bundle)

        del bnodes, it

        return bundles
Exemplo n.º 6
0
def refresh():
    global W, BUNDLES, PLUGINS, PLUGNFO

    BUNDLES = []
    PLUGINS = W.get_all_plugins()
    PLUGNFO = {}

    # Make a list of all installed bundles
    for p in PLUGINS:
        bundles = lilv.lilv_plugin_get_data_uris(p.me)

        # store empty dict for later
        PLUGNFO[p.get_uri().as_uri()] = {}

        it = lilv.lilv_nodes_begin(bundles)
        while not lilv.lilv_nodes_is_end(bundles, it):
            bundle = lilv.lilv_nodes_get(bundles, it)
            it     = lilv.lilv_nodes_next(bundles, it)

            if bundle is None:
                continue
            if not lilv.lilv_node_is_uri(bundle):
                continue

            bundle = os.path.dirname(lilv.lilv_uri_to_path(lilv.lilv_node_as_uri(bundle)))

            if not bundle.endswith(os.sep):
                bundle += os.sep

            if bundle not in BUNDLES:
                BUNDLES.append(bundle)
Exemplo n.º 7
0
def get_bundle_dirname(bundleuri):
    bundle = lilv.lilv_uri_to_path(bundleuri)

    if not os.path.exists(bundle):
        raise IOError(bundleuri)
    if os.path.isfile(bundle):
        bundle = os.path.dirname(bundle)

    return bundle
Exemplo n.º 8
0
def get_bundle_dirname(bundleuri):
    bundle = lilv.lilv_uri_to_path(bundleuri)

    if not os.path.exists(bundle):
        raise IOError(bundleuri)
    if os.path.isfile(bundle):
        bundle = os.path.dirname(bundle)

    return bundle
Exemplo n.º 9
0
def plugin_has_modgui(world, plugin):
    # define the needed stuff
    ns_modgui = NS(world, "http://moddevices.com/ns/modgui#")

    # --------------------------------------------------------------------------------------------------------
    # get the proper modgui

    modguigui = None

    nodes = plugin.get_value(ns_modgui.gui)
    it = nodes.begin()
    while not nodes.is_end(it):
        mgui = nodes.get(it)
        it = nodes.next(it)
        if mgui.me is None:
            continue
        resdir = world.find_nodes(mgui.me, ns_modgui.resourcesDirectory.me,
                                  None).get_first()
        if resdir.me is None:
            continue
        modguigui = mgui
        if os.path.expanduser("~") in lilv.lilv_uri_to_path(
                resdir.as_string()):
            # found a modgui in the home dir, stop here and use it
            break

    del nodes, it

    # --------------------------------------------------------------------------------------------------------
    # check selected modgui

    if modguigui is None or modguigui.me is None:
        return False

    # resourcesDirectory *must* be present
    modgui_resdir = world.find_nodes(modguigui.me,
                                     ns_modgui.resourcesDirectory.me,
                                     None).get_first()

    if modgui_resdir.me is None:
        return False

    return os.path.exists(lilv.lilv_uri_to_path(modgui_resdir.as_string()))
Exemplo n.º 10
0
    def generate_binary(self, bundle):
        binary = lilv.lilv_uri_to_path(
            self.plugin.get_library_uri().as_string() or "")

        if not binary:
            self.errors.append("plugin binary is missing")
        elif not self.useAbsolutePath:
            binary = binary.replace(bundle, "", 1)

        return binary
Exemplo n.º 11
0
    def generate_binary(self, bundle):
        binary = lilv.lilv_uri_to_path(
            self.plugin.get_library_uri().as_string() or ""
        )

        if not binary:
            self.errors.append("plugin binary is missing")
        elif not self.useAbsolutePath:
            binary = binary.replace(bundle, "", 1)

        return binary
Exemplo n.º 12
0
def main():
    """ LV2 plugin binaries are designed to be accessed via a symbol
    'lv2_descriptor'.
    This is a problem when linking statically as the descriptor symbols clash.
    This script renames the symbols to a name containing the md5 hash of the
    plugin uri, and also writes a C header (.h) file containing info about the
    available plugins, and a file containing a list of plugin libraries for
    linking."""

    world = lilv.World()
    world.load_all()
    plugins = world.get_all_plugins()
    initial_plugin_list = []
    for plugin in plugins:
        uri = plugin.get_uri().as_string()
        library = lilv.lilv_uri_to_path(plugin.get_library_uri().as_string())
        initial_plugin_list.append({
            'uri':
            uri,
            'library':
            library,
            'symbol':
            "lv2_descriptor_%s" % md5(uri).hexdigest()
        })
    f = open("descriptors.h", "w")
    f.write("/* This file is automatically generated by staticizer.py*/\n\n")

    plugin_list = []
    for p in initial_plugin_list:
        try:
            subprocess.check_output([
                "arm-none-eabi-objcopy", "--redefine-sym",
                "lv2_descriptor=%s" % (p['symbol'], ), p['library']
            ],
                                    stderr=subprocess.STDOUT)
        except subprocess.CalledProcessError as e:
            print "Failed to process %s (%d): %s" % (p['uri'], e.returncode,
                                                     e.output)
            continue
        plugin_list.append(p)

    for p in plugin_list:
        f.write("extern const LV2_Descriptor *%s(uint32_t index);\n" %
                p['symbol'])

    f.write("\nconst void* lv2_descriptor_loaders[] = {\n")
    for p in plugin_list:
        f.write("    %s,\n" % p['symbol'])

    f.write("    NULL\n};\n\n")
    f.close()
    f = open("plugin_library_list.txt", "w")
    f.write(" ".join([p['library'] for p in plugin_list]))
    f.close()
Exemplo n.º 13
0
def plugin_has_modgui(world, plugin):
    # define the needed stuff
    ns_modgui = NS(world, "http://moddevices.com/ns/modgui#")

    # --------------------------------------------------------------------------------------------------------
    # get the proper modgui

    modguigui = None

    nodes = plugin.get_value(ns_modgui.gui)
    it    = nodes.begin()
    while not nodes.is_end(it):
        mgui = nodes.get(it)
        it   = nodes.next(it)
        if mgui.me is None:
            continue
        resdir = world.find_nodes(mgui.me, ns_modgui.resourcesDirectory.me, None).get_first()
        if resdir.me is None:
            continue
        modguigui = mgui
        if os.path.expanduser("~") in lilv.lilv_uri_to_path(resdir.as_string()):
            # found a modgui in the home dir, stop here and use it
            break

    del nodes, it

    # --------------------------------------------------------------------------------------------------------
    # check selected modgui

    if modguigui is None or modguigui.me is None:
        return False

    # resourcesDirectory *must* be present
    modgui_resdir = world.find_nodes(modguigui.me, ns_modgui.resourcesDirectory.me, None).get_first()

    if modgui_resdir.me is None:
        return False

    return os.path.exists(lilv.lilv_uri_to_path(modgui_resdir.as_string()))
Exemplo n.º 14
0
def main():
    """ LV2 plugin binaries are designed to be accessed via a symbol
    'lv2_descriptor'.
    This is a problem when linking statically as the descriptor symbols clash.
    This script renames the symbols to a name containing the md5 hash of the
    plugin uri, and also writes a C header (.h) file containing info about the
    available plugins, and a file containing a list of plugin libraries for
    linking."""

    world = lilv.World()
    world.load_all()
    plugins = world.get_all_plugins()
    initial_plugin_list = []
    for plugin in plugins:
        uri = plugin.get_uri().as_string()
        library = lilv.lilv_uri_to_path(plugin.get_library_uri().as_string())
        initial_plugin_list.append({'uri': uri,
                                    'library': library,
                                    'symbol': "lv2_descriptor_%s" % md5(uri).hexdigest()})
    f = open("descriptors.h", "w")
    f.write("/* This file is automatically generated by staticizer.py*/\n\n")

    plugin_list = []
    for p in initial_plugin_list:
        try:
            subprocess.check_output(["arm-none-eabi-objcopy", "--redefine-sym", "lv2_descriptor=%s" % (p['symbol'],), p['library']], stderr=subprocess.STDOUT)
        except subprocess.CalledProcessError  as e:
            print "Failed to process %s (%d): %s" % (p['uri'], e.returncode, e.output)
            continue
        plugin_list.append(p)

    for p in plugin_list:
        f.write("extern const LV2_Descriptor *%s(uint32_t index);\n" % p['symbol'])

    f.write("\nconst void* lv2_descriptor_loaders[] = {\n")
    for p in plugin_list:
        f.write("    %s,\n" % p['symbol'])

    f.write("    NULL\n};\n\n")
    f.close()
    f = open("plugin_library_list.txt", "w")
    f.write(" ".join([p['library'] for p in plugin_list]))
    f.close()
Exemplo n.º 15
0
    def fill_plugin_info(plugin):
        bundleuri = plugin.get_bundle_uri().as_string()
        microver  = plugin.get_value(lv2core.microVersion).get_first()
        minorver  = plugin.get_value(lv2core.minorVersion).get_first()
        modguigui = plugin.get_value(modgui.gui).get_first()

        if modguigui.me is not None:
            modgui_scrn  = world.find_nodes(modguigui.me, modgui.screenshot      .me, None).get_first()
            modgui_thumb = world.find_nodes(modguigui.me, modgui.thumbnail       .me, None).get_first()
            modgui_icon  = world.find_nodes(modguigui.me, modgui.iconTemplate    .me, None).get_first()
            modgui_setts = world.find_nodes(modguigui.me, modgui.settingsTemplate.me, None).get_first()
            modgui_data  = world.find_nodes(modguigui.me, modgui.templateData    .me, None).get_first()

        global index
        index = -1

        return {
            'name': plugin.get_name().as_string(),
            'uri' : plugin.get_uri().as_string(),
            'author': {
                'name'    : plugin.get_author_name().as_string() or "",
                'homepage': plugin.get_author_homepage().as_string() or "",
                'email'   : (plugin.get_author_email().as_string() or "").replace(bundleuri,"",1),
            },

            'ports': [fill_port_info(plugin, p) for p in (plugin.get_port_by_index(i) for i in range(plugin.get_num_ports()))],

            'gui': {
                'screenshot'      : lilv.lilv_uri_to_path(modgui_scrn .as_string()) if modgui_scrn .me else "",
                'thumbnail'       : lilv.lilv_uri_to_path(modgui_thumb.as_string()) if modgui_thumb.me else "",
                'iconTemplate'    : lilv.lilv_uri_to_path(modgui_icon .as_string()) if modgui_icon .me else "",
                'settingsTemplate': lilv.lilv_uri_to_path(modgui_setts.as_string()) if modgui_setts.me else "",
                'templateData'    :
                    json.load(open(lilv.lilv_uri_to_path(modgui_data.as_string()), 'r')) if modgui_data.me else {},
            } if modguigui.me is not None else {},

            'binary'  : lilv.lilv_uri_to_path(plugin.get_library_uri().as_string()),
            'category': get_category(plugin.get_value(rdf.type_)),
            'license' : (plugin.get_value(doap.license).get_first().as_string() or "").replace(bundleuri,"",1),

            'description'  : plugin.get_value(rdfs.comment).get_first().as_string() or "",
            'documentation': plugin.get_value(lv2core.documentation).get_first().as_string() or "",
            'microVersion' : microver.as_int() if microver.me else 0,
            'minorVersion' : minorver.as_int() if minorver.me else 0,
        }
Exemplo n.º 16
0
Arquivo: lv2.py Projeto: EQ4/mod-ui
def remove_bundle_to_lilv_world(bundlepath, returnPlugins = False):
    global W, BUNDLES, PLUGINS, PLUGNFO, PLUGNFOk

    # lilv wants the last character as the separator
    if not bundlepath.endswith(os.sep):
        bundlepath += os.sep

    # stop now if bundle is not loaded
    if bundlepath not in BUNDLES:
        return [] if returnPlugins else False

    # In case returnPlugins is used
    removedPlugins = []

    # remove from loaded list
    BUNDLES.remove(bundlepath)

    # remove all plugins that are present on that bundle
    for p in PLUGINS:
        uri = p.get_uri().as_uri()

        if uri not in PLUGNFOk:
            continue

        bundles = lilv.lilv_plugin_get_data_uris(p.me)

        it = lilv.lilv_nodes_begin(bundles)
        while not lilv.lilv_nodes_is_end(bundles, it):
            bundle = lilv.lilv_nodes_get(bundles, it)
            it     = lilv.lilv_nodes_next(bundles, it)

            if bundle is None:
                continue
            if not lilv.lilv_node_is_uri(bundle):
                continue

            bundle = os.path.dirname(lilv.lilv_uri_to_path(lilv.lilv_node_as_uri(bundle)))

            if not bundle.endswith(os.sep):
                bundle += os.sep

            if bundlepath != bundle:
                continue

            PLUGNFOk.remove(uri)
            PLUGNFO.pop(uri)

            if returnPlugins:
                removedPlugins.append(uri)

    # convert bundle string into a lilv node
    bundlenode = lilv.lilv_new_file_uri(W.me, None, bundlepath)

    # unload the bundle
    lilv.lilv_world_unload_bundle(W.me, bundlenode)

    # free bundlenode, no longer needed
    lilv.lilv_node_free(bundlenode)

    # refresh lilv plugins
    PLUGINS = W.get_all_plugins()

    return removedPlugins if returnPlugins else True
Exemplo n.º 17
0
def get_plugin_info(world, plugin):
    # define the needed stuff
    ns_doap    = NS(world, lilv.LILV_NS_DOAP)
    ns_rdf     = NS(world, lilv.LILV_NS_RDF)
    ns_rdfs    = NS(world, lilv.LILV_NS_RDFS)
    ns_lv2core = NS(world, lilv.LILV_NS_LV2)
    ns_atom    = NS(world, "http://lv2plug.in/ns/ext/atom#")
    ns_midi    = NS(world, "http://lv2plug.in/ns/ext/midi#")
    ns_pprops  = NS(world, "http://lv2plug.in/ns/ext/port-props#")
    ns_pset    = NS(world, "http://lv2plug.in/ns/ext/presets#")
    ns_units   = NS(world, "http://lv2plug.in/ns/extensions/units#")
    ns_mod     = NS(world, "http://moddevices.com/ns/mod#")
    ns_modgui  = NS(world, "http://moddevices.com/ns/modgui#")

    bundleuri = plugin.get_bundle_uri().as_string()
    bundle    = lilv.lilv_uri_to_path(bundleuri)

    errors   = []
    warnings = []

    # --------------------------------------------------------------------------------------------------------
    # uri

    uri = plugin.get_uri().as_string() or ""

    if not uri:
        errors.append("plugin uri is missing or invalid")
    elif uri.startswith("file:"):
        errors.append("plugin uri is local, and thus not suitable for redistribution")
    #elif not (uri.startswith("http:") or uri.startswith("https:")):
        #warnings.append("plugin uri is not a real url")

    # --------------------------------------------------------------------------------------------------------
    # name

    name = plugin.get_name().as_string() or ""

    if not name:
        errors.append("plugin name is missing")

    # --------------------------------------------------------------------------------------------------------
    # binary

    binary = lilv.lilv_uri_to_path(plugin.get_library_uri().as_string() or "")

    if not binary:
        errors.append("plugin binary is missing")

    # --------------------------------------------------------------------------------------------------------
    # license

    license = plugin.get_value(ns_doap.license).get_first().as_string() or ""

    if not license:
        errors.append("plugin license is missing")
    elif license.startswith(bundleuri):
        license = license.replace(bundleuri,"",1)
        warnings.append("plugin license entry is a local path instead of a string")

    # --------------------------------------------------------------------------------------------------------
    # comment

    comment = plugin.get_value(ns_rdfs.comment).get_first().as_string() or ""

    if not comment:
        errors.append("plugin comment is missing")

    # --------------------------------------------------------------------------------------------------------
    # version

    microver = plugin.get_value(ns_lv2core.microVersion).get_first()
    minorver = plugin.get_value(ns_lv2core.minorVersion).get_first()

    if microver.me is None and minorver.me is None:
        errors.append("plugin is missing version information")
        microVersion = 0
        minorVersion = 0

    else:
        if microver.me is  None:
            errors.append("plugin is missing microVersion")
            microVersion = 0
        else:
            microVersion = microver.as_int()

        if minorver.me is None:
            errors.append("plugin is missing minorVersion")
            minorVersion = 0
        else:
            minorVersion = minorver.as_int()

    del microver
    del minorver

    version = "%d.%d" % (microVersion, minorVersion)

    if minorVersion == 0 and microVersion == 0:
        stability = "experimental"
    elif minorVersion % 2 == 0:
        stability = "stable" if microVersion % 2 == 0 else "testing"
    else:
        stability = "unstable"

    # --------------------------------------------------------------------------------------------------------
    # author

    author = {
        'name'    : plugin.get_author_name().as_string() or "",
        'homepage': plugin.get_author_homepage().as_string() or "",
        'email'   : plugin.get_author_email().as_string() or "",
    }

    if not author['name']:
        errors.append("plugin author name is missing")

    if not author['homepage']:
        warnings.append("plugin author homepage is missing")

    if not author['email']:
        warnings.append("plugin author email is missing")
    elif author['email'].startswith(bundleuri):
        author['email'] = author['email'].replace(bundleuri,"",1)
        warnings.append("plugin author email entry is missing 'mailto:' prefix")
    elif author['email'].startswith("mailto:"):
        author['email'] = author['email'].replace("mailto:","",1)

    # --------------------------------------------------------------------------------------------------------
    # brand

    brand = plugin.get_value(ns_mod.brand).get_first().as_string() or ""

    if not brand:
        brand = author['name'].split(" - ",1)[0].split(" ",1)[0]
        brand = brand.rstrip(",").rstrip(";")
        if len(brand) > 10:
            brand = brand[:10]
        warnings.append("plugin brand is missing")

    elif len(brand) > 10:
        brand = brand[:10]
        errors.append("plugin brand has more than 10 characters")

    # --------------------------------------------------------------------------------------------------------
    # label

    label = plugin.get_value(ns_mod.label).get_first().as_string() or ""

    if not label:
        if len(name) <= 16:
            label = name
        else:
            labels = name.split(" - ",1)[0].split(" ")
            if labels[0].lower() in bundle.lower() and len(labels) > 1 and not labels[1].startswith(("(","[")):
                label = labels[1]
            else:
                label = labels[0]

            if len(label) > 16:
                label = label[:16]

            warnings.append("plugin label is missing")
            del labels

    elif len(label) > 16:
        label = label[:16]
        errors.append("plugin label has more than 16 characters")

    # --------------------------------------------------------------------------------------------------------
    # bundles

    bnodes  = lilv.lilv_plugin_get_data_uris(plugin.me)
    bundles = []

    it = lilv.lilv_nodes_begin(bnodes)
    while not lilv.lilv_nodes_is_end(bnodes, it):
        bnode = lilv.lilv_nodes_get(bnodes, it)
        it    = lilv.lilv_nodes_next(bnodes, it)

        if bnode is None:
            continue
        if not lilv.lilv_node_is_uri(bnode):
            continue

        bpath = os.path.dirname(lilv.lilv_uri_to_path(lilv.lilv_node_as_uri(bnode)))

        if not bpath.endswith(os.sep):
            bpath += os.sep

        if bpath not in bundles:
            bundles.append(bpath)

    if bundle not in bundles:
        bundles.append(bundle)

    del bnodes, it

    # --------------------------------------------------------------------------------------------------------
    # get the proper modgui

    modguigui = None

    nodes = plugin.get_value(ns_modgui.gui)
    it    = nodes.begin()
    while not nodes.is_end(it):
        mgui = nodes.get(it)
        it   = nodes.next(it)
        if mgui.me is None:
            continue
        resdir = world.find_nodes(mgui.me, ns_modgui.resourcesDirectory.me, None).get_first()
        if resdir.me is None:
            continue
        modguigui = mgui
        if os.path.expanduser("~") in lilv.lilv_uri_to_path(resdir.as_string()):
            # found a modgui in the home dir, stop here and use it
            break

    del nodes, it

    # --------------------------------------------------------------------------------------------------------
    # gui

    gui = {}

    if modguigui is None or modguigui.me is None:
        warnings.append("no modgui available")

    else:
        # resourcesDirectory *must* be present
        modgui_resdir = world.find_nodes(modguigui.me, ns_modgui.resourcesDirectory.me, None).get_first()

        if modgui_resdir.me is None:
            errors.append("modgui has no resourcesDirectory data")

        else:
            gui['resourcesDirectory'] = lilv.lilv_uri_to_path(modgui_resdir.as_string())

            # check if modgui is defined in a separate file
            gui['usingSeeAlso'] = os.path.exists(os.path.join(bundle, "modgui.ttl"))

            # check if the modgui definition is on its own file and in the user dir
            gui['modificableInPlace'] = bool((bundle not in gui['resourcesDirectory'] or gui['usingSeeAlso']) and
                                              os.path.expanduser("~") in gui['resourcesDirectory'])

            # icon and settings templates
            modgui_icon  = world.find_nodes(modguigui.me, ns_modgui.iconTemplate    .me, None).get_first()
            modgui_setts = world.find_nodes(modguigui.me, ns_modgui.settingsTemplate.me, None).get_first()

            if modgui_icon.me is None:
                errors.append("modgui has no iconTemplate data")
            else:
                iconFile = lilv.lilv_uri_to_path(modgui_icon.as_string())
                if os.path.exists(iconFile):
                    with open(iconFile, 'r') as fd:
                        gui['iconTemplate'] = fd.read()
                else:
                    errors.append("modgui iconTemplate file is missing")
                del iconFile

            if modgui_setts.me is not None:
                settingsFile = lilv.lilv_uri_to_path(modgui_setts.as_string())
                if os.path.exists(settingsFile):
                    with open(settingsFile, 'r') as fd:
                        gui['settingsTemplate'] = fd.read()
                else:
                    errors.append("modgui settingsTemplate file is missing")
                del settingsFile

            # javascript and stylesheet files
            modgui_script = world.find_nodes(modguigui.me, ns_modgui.javascript.me, None).get_first()
            modgui_style  = world.find_nodes(modguigui.me, ns_modgui.stylesheet.me, None).get_first()

            if modgui_script.me is not None:
                javascriptFile = lilv.lilv_uri_to_path(modgui_script.as_string())
                if os.path.exists(javascriptFile):
                    gui['javascript'] = javascriptFile
                else:
                    errors.append("modgui javascript file is missing")
                del javascriptFile

            if modgui_style.me is None:
                errors.append("modgui has no stylesheet data")
            else:
                stylesheetFile = lilv.lilv_uri_to_path(modgui_style.as_string())
                if os.path.exists(stylesheetFile):
                    gui['stylesheet'] = stylesheetFile
                else:
                    errors.append("modgui stylesheet file is missing")
                del stylesheetFile

            # template data for backwards compatibility
            # FIXME remove later once we got rid of all templateData files
            modgui_templ = world.find_nodes(modguigui.me, ns_modgui.templateData.me, None).get_first()

            if modgui_templ.me is not None:
                warnings.append("modgui is using old deprecated templateData")
                templFile = lilv.lilv_uri_to_path(modgui_templ.as_string())
                if os.path.exists(templFile):
                    with open(templFile, 'r') as fd:
                        try:
                            data = json.loads(fd.read())
                        except:
                            data = {}
                        keys = list(data.keys())

                        if 'author' in keys:
                            gui['brand'] = data['author']
                        if 'label' in keys:
                            gui['label'] = data['label']
                        if 'color' in keys:
                            gui['color'] = data['color']
                        if 'knob' in keys:
                            gui['knob'] = data['knob']
                        if 'controls' in keys:
                            index = 0
                            ports = []
                            for ctrl in data['controls']:
                                ports.append({
                                    'index' : index,
                                    'name'  : ctrl['name'],
                                    'symbol': ctrl['symbol'],
                                })
                                index += 1
                            gui['ports'] = ports
                del templFile

            # screenshot and thumbnail
            modgui_scrn  = world.find_nodes(modguigui.me, ns_modgui.screenshot.me, None).get_first()
            modgui_thumb = world.find_nodes(modguigui.me, ns_modgui.thumbnail .me, None).get_first()

            if modgui_scrn.me is not None:
                gui['screenshot'] = lilv.lilv_uri_to_path(modgui_scrn.as_string())
                if not os.path.exists(gui['screenshot']):
                    errors.append("modgui screenshot file is missing")
            else:
                errors.append("modgui has no screnshot data")

            if modgui_thumb.me is not None:
                gui['thumbnail'] = lilv.lilv_uri_to_path(modgui_thumb.as_string())
                if not os.path.exists(gui['thumbnail']):
                    errors.append("modgui thumbnail file is missing")
            else:
                errors.append("modgui has no thumbnail data")

            # extra stuff, all optional
            modgui_brand = world.find_nodes(modguigui.me, ns_modgui.brand.me, None).get_first()
            modgui_label = world.find_nodes(modguigui.me, ns_modgui.label.me, None).get_first()
            modgui_model = world.find_nodes(modguigui.me, ns_modgui.model.me, None).get_first()
            modgui_panel = world.find_nodes(modguigui.me, ns_modgui.panel.me, None).get_first()
            modgui_color = world.find_nodes(modguigui.me, ns_modgui.color.me, None).get_first()
            modgui_knob  = world.find_nodes(modguigui.me, ns_modgui.knob .me, None).get_first()

            if modgui_brand.me is not None:
                gui['brand'] = modgui_brand.as_string()
            if modgui_label.me is not None:
                gui['label'] = modgui_label.as_string()
            if modgui_model.me is not None:
                gui['model'] = modgui_model.as_string()
            if modgui_panel.me is not None:
                gui['panel'] = modgui_panel.as_string()
            if modgui_color.me is not None:
                gui['color'] = modgui_color.as_string()
            if modgui_knob.me is not None:
                gui['knob'] = modgui_knob.as_string()

            # ports
            errpr = False
            ports = []
            nodes = world.find_nodes(modguigui.me, ns_modgui.port.me, None)
            it    = lilv.lilv_nodes_begin(nodes.me)
            while not lilv.lilv_nodes_is_end(nodes.me, it):
                port = lilv.lilv_nodes_get(nodes.me, it)
                it   = lilv.lilv_nodes_next(nodes.me, it)
                if port is None:
                    break
                port_indx = world.find_nodes(port, ns_lv2core.index .me, None).get_first()
                port_symb = world.find_nodes(port, ns_lv2core.symbol.me, None).get_first()
                port_name = world.find_nodes(port, ns_lv2core.name  .me, None).get_first()

                if None in (port_indx.me, port_name.me, port_symb.me):
                    if not errpr:
                        errors.append("modgui has some invalid port data")
                        errpr = True
                    continue

                ports.append({
                    'index' : port_indx.as_int(),
                    'symbol': port_symb.as_string(),
                    'name'  : port_name.as_string(),
                })

            # sort ports
            if len(ports) > 0:
                ports2 = {}

                for port in ports:
                    ports2[port['index']] = port
                gui['ports'] = [ports2[i] for i in ports2]

                del ports2

            # cleanup
            del ports, nodes, it

    # --------------------------------------------------------------------------------------------------------
    # ports

    index = 0
    ports = {
        'audio'  : { 'input': [], 'output': [] },
        'control': { 'input': [], 'output': [] },
        'midi'   : { 'input': [], 'output': [] }
    }

    portsymbols = []
    portnames   = []

    # function for filling port info
    def fill_port_info(port):
        # base data
        portname = lilv.lilv_node_as_string(port.get_name()) or ""

        if not portname:
            portname = "_%i" % index
            errors.append("port with index %i has no name" % index)

        portsymbol = lilv.lilv_node_as_string(port.get_symbol()) or ""

        if not portsymbol:
            portsymbol = "_%i" % index
            errors.append("port with index %i has no symbol" % index)

        # check for duplicate names
        if portname in portsymbols:
            warnings.append("port name '%s' is not unique" % portname)
        else:
            portnames.append(portname)

        # check for duplicate symbols
        if portsymbol in portsymbols:
            errors.append("port symbol '%s' is not unique" % portsymbol)
        else:
            portsymbols.append(portsymbol)

        # short name
        psname = lilv.lilv_nodes_get_first(port.get_value(ns_lv2core.shortname.me))

        if psname is not None:
            psname = lilv.lilv_node_as_string(psname) or ""

        if not psname:
            psname = get_short_port_name(portname)
            warnings.append("port '%s' has no short name" % portname)

        elif len(psname) > 16:
            psname = psname[:16]
            errors.append("port '%s' short name has more than 16 characters" % portname)

        # port types
        types = [typ.rsplit("#",1)[-1].replace("Port","",1) for typ in get_port_data(port, ns_rdf.type_)]

        if "Atom" in types \
            and port.supports_event(ns_midi.MidiEvent.me) \
            and lilv.Nodes(port.get_value(ns_atom.bufferType.me)).get_first() == ns_atom.Sequence:
                types.append("MIDI")

        # port properties
        properties = [typ.rsplit("#",1)[-1] for typ in get_port_data(port, ns_lv2core.portProperty)]

        # data
        ranges      = {}
        scalepoints = []

        # unit block
        ulabel  = ""
        urender = ""
        usymbol = ""

        # control and cv must contain ranges, might contain scale points
        if "Control" in types or "CV" in types:
            isInteger = "integer" in properties

            if isInteger and "CV" in types:
                errors.append("port '%s' has integer property and CV type" % portname)

            xdefault = lilv.lilv_nodes_get_first(port.get_value(ns_lv2core.default.me))
            xminimum = lilv.lilv_nodes_get_first(port.get_value(ns_lv2core.minimum.me))
            xmaximum = lilv.lilv_nodes_get_first(port.get_value(ns_lv2core.maximum.me))

            if xminimum is not None and xmaximum is not None:
                if isInteger:
                    if is_integer(lilv.lilv_node_as_string(xminimum)):
                        ranges['minimum'] = lilv.lilv_node_as_int(xminimum)
                    else:
                        ranges['minimum'] = lilv.lilv_node_as_float(xminimum)
                        if fmod(ranges['minimum'], 1.0) == 0.0:
                            warnings.append("port '%s' has integer property but minimum value is float" % portname)
                        else:
                            errors.append("port '%s' has integer property but minimum value has non-zero decimals" % portname)
                        ranges['minimum'] = int(ranges['minimum'])

                    if is_integer(lilv.lilv_node_as_string(xmaximum)):
                        ranges['maximum'] = lilv.lilv_node_as_int(xmaximum)
                    else:
                        ranges['maximum'] = lilv.lilv_node_as_float(xmaximum)
                        if fmod(ranges['maximum'], 1.0) == 0.0:
                            warnings.append("port '%s' has integer property but maximum value is float" % portname)
                        else:
                            errors.append("port '%s' has integer property but maximum value has non-zero decimals" % portname)
                        ranges['maximum'] = int(ranges['maximum'])

                else:
                    ranges['minimum'] = lilv.lilv_node_as_float(xminimum)
                    ranges['maximum'] = lilv.lilv_node_as_float(xmaximum)

                    if is_integer(lilv.lilv_node_as_string(xminimum)):
                        warnings.append("port '%s' minimum value is an integer" % portname)

                    if is_integer(lilv.lilv_node_as_string(xmaximum)):
                        warnings.append("port '%s' maximum value is an integer" % portname)

                if ranges['minimum'] >= ranges['maximum']:
                    ranges['maximum'] = ranges['minimum'] + (1 if isInteger else 0.1)
                    errors.append("port '%s' minimum value is equal or higher than its maximum" % portname)

                if xdefault is not None:
                    if isInteger:
                        if is_integer(lilv.lilv_node_as_string(xdefault)):
                            ranges['default'] = lilv.lilv_node_as_int(xdefault)
                        else:
                            ranges['default'] = lilv.lilv_node_as_float(xdefault)
                            if fmod(ranges['default'], 1.0) == 0.0:
                                warnings.append("port '%s' has integer property but default value is float" % portname)
                            else:
                                errors.append("port '%s' has integer property but default value has non-zero decimals" % portname)
                            ranges['default'] = int(ranges['default'])
                    else:
                        ranges['default'] = lilv.lilv_node_as_float(xdefault)

                        if is_integer(lilv.lilv_node_as_string(xdefault)):
                            warnings.append("port '%s' default value is an integer" % portname)

                    testmin = ranges['minimum']
                    testmax = ranges['maximum']

                    if "sampleRate" in properties:
                        testmin *= 48000
                        testmax *= 48000

                    if not (testmin <= ranges['default'] <= testmax):
                        ranges['default'] = ranges['minimum']
                        errors.append("port '%s' default value is out of bounds" % portname)

                else:
                    ranges['default'] = ranges['minimum']

                    if "Input" in types:
                        errors.append("port '%s' is missing default value" % portname)

            else:
                if isInteger:
                    ranges['minimum'] = 0
                    ranges['maximum'] = 1
                    ranges['default'] = 0
                else:
                    ranges['minimum'] = -1.0 if "CV" in types else 0.0
                    ranges['maximum'] = 1.0
                    ranges['default'] = 0.0

                if "CV" not in types:
                    errors.append("port '%s' is missing value ranges" % portname)

            nodes = port.get_scale_points()

            if nodes is not None:
                it = lilv.lilv_scale_points_begin(nodes)
                while not lilv.lilv_scale_points_is_end(nodes, it):
                    sp = lilv.lilv_scale_points_get(nodes, it)
                    it = lilv.lilv_scale_points_next(nodes, it)

                    if sp is None:
                        continue

                    label = lilv.lilv_scale_point_get_label(sp)
                    value = lilv.lilv_scale_point_get_value(sp)

                    if label is None:
                        errors.append("a port scalepoint is missing its label")
                        continue

                    label = lilv.lilv_node_as_string(label) or ""

                    if not label:
                        errors.append("a port scalepoint is missing its label")
                        continue

                    if value is None:
                        errors.append("port scalepoint '%s' is missing its value" % label)
                        continue

                    if isInteger:
                        if is_integer(lilv.lilv_node_as_string(value)):
                            value = lilv.lilv_node_as_int(value)
                        else:
                            value = lilv.lilv_node_as_float(value)
                            if fmod(value, 1.0) == 0.0:
                                warnings.append("port '%s' has integer property but scalepoint '%s' value is float" % (portname, label))
                            else:
                                errors.append("port '%s' has integer property but scalepoint '%s' value has non-zero decimals" % (portname, label))
                            value = int(value)
                    else:
                        if is_integer(lilv.lilv_node_as_string(value)):
                            warnings.append("port '%s' scalepoint '%s' value is an integer" % (portname, label))
                        value = lilv.lilv_node_as_float(value)

                    if ranges['minimum'] <= value <= ranges['maximum']:
                        scalepoints.append({'label': label, 'value': value})
                    else:
                        errors.append(("port scalepoint '%s' has an out-of-bounds value:\n" % label) +
                                      ("%d < %d < %d" if isInteger else "%f < %f < %f") % (ranges['minimum'], value, ranges['maximum']))

            if "enumeration" in properties and len(scalepoints) <= 1:
                errors.append("port '%s' wants to use enumeration but doesn't have enough values" % portname)
                properties.remove("enumeration")

        # control ports might contain unit
        if "Control" in types:
            # unit
            uunit = lilv.lilv_nodes_get_first(port.get_value(ns_units.unit.me))

            if uunit is not None:
                uuri = lilv.lilv_node_as_uri(uunit)

                # using pre-existing lv2 unit
                if uuri is not None and uuri.startswith("http://lv2plug.in/ns/"):
                    uuri  = uuri.replace("http://lv2plug.in/ns/extensions/units#","",1)
                    alnum = uuri.isalnum()

                    if not alnum:
                        errors.append("port '%s' has wrong lv2 unit uri" % portname)
                        uuri = uuri.rsplit("#",1)[-1].rsplit("/",1)[-1]

                    ulabel, urender, usymbol = get_port_unit(uuri)

                    if alnum and not (ulabel and urender and usymbol):
                        errors.append("port '%s' has unknown lv2 unit (our bug?, data is '%s', '%s', '%s')" % (portname,
                                                                                                               ulabel,
                                                                                                               urender,
                                                                                                               usymbol))

                # using custom unit
                else:
                    xlabel  = world.find_nodes(uunit, ns_rdfs  .label.me, None).get_first()
                    xrender = world.find_nodes(uunit, ns_units.render.me, None).get_first()
                    xsymbol = world.find_nodes(uunit, ns_units.symbol.me, None).get_first()

                    if xlabel.me is not None:
                        ulabel = xlabel.as_string()
                    else:
                        errors.append("port '%s' has custom unit with no label" % portname)

                    if xrender.me is not None:
                        urender = xrender.as_string()
                    else:
                        errors.append("port '%s' has custom unit with no render" % portname)

                    if xsymbol.me is not None:
                        usymbol = xsymbol.as_string()
                    else:
                        errors.append("port '%s' has custom unit with no symbol" % portname)

        return (types, {
            'name'   : portname,
            'symbol' : portsymbol,
            'ranges' : ranges,
            'units'  : {
                'label' : ulabel,
                'render': urender,
                'symbol': usymbol,
            } if "Control" in types and ulabel and urender and usymbol else {},
            'designation': (get_port_data(port, ns_lv2core.designation) or [None])[0],
            'properties' : properties,
            'rangeSteps' : (get_port_data(port, ns_mod.rangeSteps) or get_port_data(port, ns_pprops.rangeSteps) or [None])[0],
            "scalePoints": scalepoints,
            'shortname'  : psname,
        })

    for p in (plugin.get_port_by_index(i) for i in range(plugin.get_num_ports())):
        types, info = fill_port_info(p)

        info['index'] = index
        index += 1

        isInput = "Input" in types
        types.remove("Input" if isInput else "Output")

        for typ in [typl.lower() for typl in types]:
            if typ not in ports.keys():
                ports[typ] = { 'input': [], 'output': [] }
            ports[typ]["input" if isInput else "output"].append(info)

    # --------------------------------------------------------------------------------------------------------
    # presets

    def get_preset_data(preset):
        world.load_resource(preset.me)

        uri   = preset.as_string() or ""
        label = world.find_nodes(preset.me, ns_rdfs.label.me, None).get_first().as_string() or ""

        if not uri:
            errors.append("preset with label '%s' has no uri" % (label or "<unknown>"))
        if not label:
            errors.append("preset with uri '%s' has no label" % (uri or "<unknown>"))

        return { 'uri': uri, 'label': label }

    presetsrel = plugin.get_related(ns_pset.Preset)
    presets    = list(LILV_FOREACH(presetsrel, get_preset_data))

    del presetsrel

    # --------------------------------------------------------------------------------------------------------
    # done

    return {
        'uri' : uri,
        'name': name,

        'binary' : binary,
        'brand'  : brand,
        'label'  : label,
        'license': license,
        'comment': comment,

        'category'    : get_category(plugin.get_value(ns_rdf.type_)),
        'microVersion': microVersion,
        'minorVersion': minorVersion,

        'version'  : version,
        'stability': stability,

        'author' : author,
        'bundles': bundles,
        'gui'    : gui,
        'ports'  : ports,
        'presets': presets,

        'errors'  : errors,
        'warnings': warnings,
    }
Exemplo n.º 18
0
def get_pedalboard_info(bundle):
    # lilv wants the last character as the separator
    if not bundle.endswith(os.sep):
        bundle += os.sep

    # Create our own unique lilv world
    # We'll load a single bundle and get all plugins from it
    world = lilv.World()

    # this is needed when loading specific bundles instead of load_all
    # (these functions are not exposed via World yet)
    lilv.lilv_world_load_specifications(world.me)
    lilv.lilv_world_load_plugin_classes(world.me)

    # convert bundle string into a lilv node
    bundlenode = lilv.lilv_new_file_uri(world.me, None, bundle)

    # load the bundle
    world.load_bundle(bundlenode)

    # free bundlenode, no longer needed
    lilv.lilv_node_free(bundlenode)

    # get all plugins in the bundle
    plugins = world.get_all_plugins()

    # make sure the bundle includes 1 and only 1 plugin (the pedalboard)
    if plugins.size() != 1:
        raise Exception('get_pedalboard_info(%s) - bundle has 0 or > 1 plugin'.format(bundle))

    # no indexing in python-lilv yet, just get the first item
    plugin = None
    for p in plugins:
        plugin = p
        break

    if plugin is None:
        raise Exception('get_pedalboard_info(%s) - failed to get plugin, you are using an old lilv!'.format(bundle))

    # define the needed stuff
    ns_rdf      = NS(world, lilv.LILV_NS_RDF)
    ns_lv2core  = NS(world, lilv.LILV_NS_LV2)
    ns_ingen    = NS(world, "http://drobilla.net/ns/ingen#")
    ns_modpedal = NS(world, "http://moddevices.com/ns/modpedal#")

    # check if the plugin is a pedalboard
    def fill_in_type(node):
        return node.as_string()
    plugin_types = [i for i in LILV_FOREACH(plugin.get_value(ns_rdf.type_), fill_in_type)]

    if "http://moddevices.com/ns/modpedal#Pedalboard" not in plugin_types:
        raise Exception('get_pedalboard_info(%s) - plugin has no mod:Pedalboard type'.format(bundle))

    # let's get all the info now
    ingenarcs   = []
    ingenblocks = []

    info = {
        'name'  : plugin.get_name().as_string(),
        'uri'   : plugin.get_uri().as_string(),
        'author': plugin.get_author_name().as_string() or "", # Might be empty
        'hardware': {
            # we save this info later
            'audio': {
                'ins' : 0,
                'outs': 0
             },
            'cv': {
                'ins' : 0,
                'outs': 0
             },
            'midi': {
                'ins' : 0,
                'outs': 0
             }
        },
        'size': {
            'width' : plugin.get_value(ns_modpedal.width).get_first().as_int(),
            'height': plugin.get_value(ns_modpedal.height).get_first().as_int(),
        },
        'screenshot' : os.path.basename(plugin.get_value(ns_modpedal.screenshot).get_first().as_string()),
        'thumbnail'  : os.path.basename(plugin.get_value(ns_modpedal.thumbnail).get_first().as_string()),
        'connections': [], # we save this info later
        'plugins'    : []  # we save this info later
    }

    # connections
    arcs = plugin.get_value(ns_ingen.arc)
    it = arcs.begin()
    while not arcs.is_end(it):
        arc = arcs.get(it)
        it  = arcs.next(it)

        if arc.me is None:
            continue

        head = lilv.lilv_world_get(world.me, arc.me, ns_ingen.head.me, None)
        tail = lilv.lilv_world_get(world.me, arc.me, ns_ingen.tail.me, None)

        if head is None or tail is None:
            continue

        ingenarcs.append({
            "source": lilv.lilv_uri_to_path(lilv.lilv_node_as_string(tail)).replace(bundle,"",1),
            "target": lilv.lilv_uri_to_path(lilv.lilv_node_as_string(head)).replace(bundle,"",1)
        })

    # hardware ports
    handled_port_uris = []
    ports = plugin.get_value(ns_lv2core.port)
    it = ports.begin()
    while not ports.is_end(it):
        port = ports.get(it)
        it   = ports.next(it)

        if port.me is None:
            continue

        # check if we already handled this port
        port_uri = port.as_uri()
        if port_uri in handled_port_uris:
            continue
        handled_port_uris.append(port_uri)

        # get types
        port_types = lilv.lilv_world_find_nodes(world.me, port.me, ns_rdf.type_.me, None)

        if port_types is None:
            continue

        portDir  = "" # input or output
        portType = "" # atom, audio or cv

        it2 = lilv.lilv_nodes_begin(port_types)
        while not lilv.lilv_nodes_is_end(port_types, it2):
            port_type = lilv.lilv_nodes_get(port_types, it2)
            it2 = lilv.lilv_nodes_next(port_types, it2)

            if port_type is None:
                continue

            port_type_uri = lilv.lilv_node_as_uri(port_type)

            if port_type_uri == "http://lv2plug.in/ns/lv2core#InputPort":
                portDir = "input"
            elif port_type_uri == "http://lv2plug.in/ns/lv2core#OutputPort":
                portDir = "output"
            elif port_type_uri == "http://lv2plug.in/ns/lv2core#AudioPort":
                portType = "audio"
            elif port_type_uri == "http://lv2plug.in/ns/lv2core#CVPort":
                portType = "cv"
            elif port_type_uri == "http://lv2plug.in/ns/ext/atom#AtomPort":
                portType = "atom"

        if not (portDir or portType):
            continue

        if portType == "audio":
            if portDir == "input":
                info['hardware']['audio']['ins'] += 1
            else:
                info['hardware']['audio']['outs'] += 1

        elif portType == "atom":
            if portDir == "input":
                info['hardware']['midi']['ins'] += 1
            else:
                info['hardware']['midi']['outs'] += 1

        elif portType == "cv":
            if portDir == "input":
                info['hardware']['cv']['ins'] += 1
            else:
                info['hardware']['cv']['outs'] += 1

    # plugins
    blocks = plugin.get_value(ns_ingen.block)
    it = blocks.begin()
    while not blocks.is_end(it):
        block = blocks.get(it)
        it    = blocks.next(it)

        if block.me is None:
            continue

        protouri1 = lilv.lilv_world_get(world.me, block.me, ns_lv2core.prototype.me, None)
        protouri2 = lilv.lilv_world_get(world.me, block.me, ns_ingen.prototype.me, None)

        if protouri1 is not None:
            proto = protouri1
        elif protouri2 is not None:
            proto = protouri2
        else:
            continue

        uri = lilv.lilv_node_as_uri(proto)

        microver = lilv.lilv_world_get(world.me, block.me, ns_lv2core.microVersion.me, None)
        minorver = lilv.lilv_world_get(world.me, block.me, ns_lv2core.minorVersion.me, None)

        ingenblocks.append({
            "uri": uri,
            "x": lilv.lilv_node_as_float(lilv.lilv_world_get(world.me, block.me, ns_ingen.canvasX.me, None)),
            "y": lilv.lilv_node_as_float(lilv.lilv_world_get(world.me, block.me, ns_ingen.canvasY.me, None)),
            "microVersion": lilv.lilv_node_as_int(microver) if microver else 0,
            "minorVersion": lilv.lilv_node_as_int(minorver) if minorver else 0,
        })

    info['connections'] = ingenarcs
    info['plugins']     = ingenblocks

    return info
Exemplo n.º 19
0
    def __init__(self, world, plugin, useAbsolutePath=True):
        self.world = world
        self.plugin = plugin
        self.useAbsolutePath = useAbsolutePath

        self.ns_doap = NS(world, lilv.LILV_NS_DOAP)
        self.ns_lv2core = NS(world, lilv.LILV_NS_LV2)
        self.ns_rdfs = NS(world, lilv.LILV_NS_RDFS)
        self.ns_rdf = NS(world, lilv.LILV_NS_RDF)

        self.ns_morph = NS(world, "http://lv2plug.in/ns/ext/morph#")
        self.ns_pset = NS(world, "http://lv2plug.in/ns/ext/presets#")
        self.ns_mod = NS(world, "http://moddevices.com/ns/mod#")
        self.ns_modgui = NS(world, "http://moddevices.com/ns/modgui#")

        self.errors = []
        self.warnings = []

        self.bundleuri = self.plugin.get_bundle_uri().as_string()
        self.bundle = lilv.lilv_uri_to_path(self.bundleuri)

        self.author = self.generate_author(
            world,
            plugin,
            self.bundleuri
        )

        self.uri = self.generate_uri()
        self.name = self.generate_name()

        self.binary = self.generate_binary(self.bundle)
        self.brand = self.generate_brand(self.author)
        self.label = self.generate_label()
        self.theLicense = self.generate_license()
        self.comment = self.generate_comment()

        self.version, self.minorVersion, self.microVersion = \
            self.generate_version_data()

        self.stability = self.generate_stability(
            self.minorVersion,
            self.microVersion
        )

        self.bundles = self.generate_bundles()

        self.ports = self.generate_ports()

        self.data = {
            'uri': self.uri,
            'name': self.name,

            'binary': self.binary,
            'brand': self.brand,
            'label': self.label,
            'license': self.theLicense,
            'comment': self.comment,

            'category': get_category(plugin.get_value(self.ns_rdf.type_)),
            'microVersion': self.microVersion,
            'minorVersion': self.minorVersion,

            'version': self.version,
            'stability': self.stability,

            'author': self.author,
            'bundles': self.bundles,
            'gui': None,  # gui,
            'ports': self.ports,
            'presets': [],  # presets,

            'errors': self.errors,
            'warnings': self.warnings,
        }
Exemplo n.º 20
0
def get_pedalboard_info(bundle):
    # lilv wants the last character as the separator
    bundle = os.path.abspath(bundle)
    if not bundle.endswith(os.sep):
        bundle += os.sep

    # Create our own unique lilv world
    # We'll load a single bundle and get all plugins from it
    world = lilv.World()

    # this is needed when loading specific bundles instead of load_all
    # (these functions are not exposed via World yet)
    lilv.lilv_world_load_specifications(world.me)
    lilv.lilv_world_load_plugin_classes(world.me)

    # convert bundle string into a lilv node
    bundlenode = lilv.lilv_new_file_uri(world.me, None, bundle)

    # load the bundle
    world.load_bundle(bundlenode)

    # free bundlenode, no longer needed
    lilv.lilv_node_free(bundlenode)

    # get all plugins in the bundle
    plugins = world.get_all_plugins()

    # make sure the bundle includes 1 and only 1 plugin (the pedalboard)
    if plugins.size() != 1:
        raise Exception(
            'get_pedalboard_info(%s) - bundle has 0 or > 1 plugin'.format(
                bundle))

    # no indexing in python-lilv yet, just get the first item
    plugin = None
    for p in plugins:
        plugin = p
        break

    if plugin is None:
        raise Exception(
            'get_pedalboard_info(%s) - failed to get plugin, you are using an old lilv!'
            .format(bundle))

    # define the needed stuff
    ns_rdf = NS(world, lilv.LILV_NS_RDF)
    ns_lv2core = NS(world, lilv.LILV_NS_LV2)
    ns_ingen = NS(world, "http://drobilla.net/ns/ingen#")
    ns_modpedal = NS(world, "http://moddevices.com/ns/modpedal#")

    # check if the plugin is a pedalboard
    def fill_in_type(node):
        return node.as_string()

    plugin_types = [
        i for i in LILV_FOREACH(plugin.get_value(ns_rdf.type_), fill_in_type)
    ]

    if "http://moddevices.com/ns/modpedal#Pedalboard" not in plugin_types:
        raise Exception(
            'get_pedalboard_info(%s) - plugin has no mod:Pedalboard type'.
            format(bundle))

    # let's get all the info now
    ingenarcs = []
    ingenblocks = []

    info = {
        'name':
        plugin.get_name().as_string(),
        'uri':
        plugin.get_uri().as_string(),
        'author':
        plugin.get_author_name().as_string() or "",  # Might be empty
        'hardware': {
            # we save this info later
            'audio': {
                'ins': 0,
                'outs': 0
            },
            'cv': {
                'ins': 0,
                'outs': 0
            },
            'midi': {
                'ins': 0,
                'outs': 0
            }
        },
        'size': {
            'width': plugin.get_value(ns_modpedal.width).get_first().as_int(),
            'height':
            plugin.get_value(ns_modpedal.height).get_first().as_int(),
        },
        'screenshot':
        os.path.basename(
            plugin.get_value(ns_modpedal.screenshot).get_first().as_string()
            or ""),
        'thumbnail':
        os.path.basename(
            plugin.get_value(ns_modpedal.thumbnail).get_first().as_string()
            or ""),
        'connections': [],  # we save this info later
        'plugins': []  # we save this info later
    }

    # connections
    arcs = plugin.get_value(ns_ingen.arc)
    it = arcs.begin()
    while not arcs.is_end(it):
        arc = arcs.get(it)
        it = arcs.next(it)

        if arc.me is None:
            continue

        head = lilv.lilv_world_get(world.me, arc.me, ns_ingen.head.me, None)
        tail = lilv.lilv_world_get(world.me, arc.me, ns_ingen.tail.me, None)

        if head is None or tail is None:
            continue

        ingenarcs.append({
            "source":
            lilv.lilv_uri_to_path(lilv.lilv_node_as_string(tail)).replace(
                bundle, "", 1),
            "target":
            lilv.lilv_uri_to_path(lilv.lilv_node_as_string(head)).replace(
                bundle, "", 1)
        })

    # hardware ports
    handled_port_uris = []
    ports = plugin.get_value(ns_lv2core.port)
    it = ports.begin()
    while not ports.is_end(it):
        port = ports.get(it)
        it = ports.next(it)

        if port.me is None:
            continue

        # check if we already handled this port
        port_uri = port.as_uri()
        if port_uri in handled_port_uris:
            continue
        if port_uri.endswith("/control_in") or port_uri.endswith(
                "/control_out"):
            continue
        handled_port_uris.append(port_uri)

        # get types
        port_types = lilv.lilv_world_find_nodes(world.me, port.me,
                                                ns_rdf.type_.me, None)

        if port_types is None:
            continue

        portDir = ""  # input or output
        portType = ""  # atom, audio or cv

        it2 = lilv.lilv_nodes_begin(port_types)
        while not lilv.lilv_nodes_is_end(port_types, it2):
            port_type = lilv.lilv_nodes_get(port_types, it2)
            it2 = lilv.lilv_nodes_next(port_types, it2)

            if port_type is None:
                continue

            port_type_uri = lilv.lilv_node_as_uri(port_type)

            if port_type_uri == "http://lv2plug.in/ns/lv2core#InputPort":
                portDir = "input"
            elif port_type_uri == "http://lv2plug.in/ns/lv2core#OutputPort":
                portDir = "output"
            elif port_type_uri == "http://lv2plug.in/ns/lv2core#AudioPort":
                portType = "audio"
            elif port_type_uri == "http://lv2plug.in/ns/lv2core#CVPort":
                portType = "cv"
            elif port_type_uri == "http://lv2plug.in/ns/ext/atom#AtomPort":
                portType = "atom"

        if not (portDir or portType):
            continue

        if portType == "audio":
            if portDir == "input":
                info['hardware']['audio']['ins'] += 1
            else:
                info['hardware']['audio']['outs'] += 1

        elif portType == "atom":
            if portDir == "input":
                info['hardware']['midi']['ins'] += 1
            else:
                info['hardware']['midi']['outs'] += 1

        elif portType == "cv":
            if portDir == "input":
                info['hardware']['cv']['ins'] += 1
            else:
                info['hardware']['cv']['outs'] += 1

    # plugins
    blocks = plugin.get_value(ns_ingen.block)
    it = blocks.begin()
    while not blocks.is_end(it):
        block = blocks.get(it)
        it = blocks.next(it)

        if block.me is None:
            continue

        protouri1 = lilv.lilv_world_get(world.me, block.me,
                                        ns_lv2core.prototype.me, None)
        protouri2 = lilv.lilv_world_get(world.me, block.me,
                                        ns_ingen.prototype.me, None)

        if protouri1 is not None:
            proto = protouri1
        elif protouri2 is not None:
            proto = protouri2
        else:
            continue

        instance = lilv.lilv_uri_to_path(lilv.lilv_node_as_string(
            block.me)).replace(bundle, "", 1)
        uri = lilv.lilv_node_as_uri(proto)

        enabled = lilv.lilv_world_get(world.me, block.me, ns_ingen.enabled.me,
                                      None)
        minorver = lilv.lilv_world_get(world.me, block.me,
                                       ns_lv2core.minorVersion.me, None)
        microver = lilv.lilv_world_get(world.me, block.me,
                                       ns_lv2core.microVersion.me, None)

        ingenblocks.append({
            "instance":
            instance,
            "uri":
            uri,
            "x":
            lilv.lilv_node_as_float(
                lilv.lilv_world_get(world.me, block.me, ns_ingen.canvasX.me,
                                    None)),
            "y":
            lilv.lilv_node_as_float(
                lilv.lilv_world_get(world.me, block.me, ns_ingen.canvasY.me,
                                    None)),
            "enabled":
            lilv.lilv_node_as_bool(enabled) if enabled is not None else False,
            "minorVersion":
            lilv.lilv_node_as_int(minorver) if minorver else 0,
            "microVersion":
            lilv.lilv_node_as_int(microver) if microver else 0,
        })

    info['connections'] = ingenarcs
    info['plugins'] = ingenblocks

    return info
Exemplo n.º 21
0
# Make a list of all installed bundles
for p in PLUGINS:
    bundles = lilv.lilv_plugin_get_data_uris(p.me)

    it = lilv.lilv_nodes_begin(bundles)
    while not lilv.lilv_nodes_is_end(bundles, it):
        bundle = lilv.lilv_nodes_get(bundles, it)
        it     = lilv.lilv_nodes_next(bundles, it)

        if bundle is None:
            continue
        if not lilv.lilv_node_is_uri(bundle):
            continue

        bundle = os.path.dirname(lilv.lilv_uri_to_path(lilv.lilv_node_as_uri(bundle)))

        if not bundle.endswith(os.sep):
            bundle += os.sep

        if bundle not in BUNDLES:
            BUNDLES.append(bundle)

class NS(object):
    def __init__(self, base, world=W):
        self.base = base
        self.world = world
        self._cache = {}

    def __getattr__(self, attr):
        if attr.endswith("_"):
Exemplo n.º 22
0
    def __init__(self, world, plugin, useAbsolutePath=True):
        self.world = world
        self.plugin = plugin
        self.useAbsolutePath = useAbsolutePath

        self.ns_doap = NS(world, lilv.LILV_NS_DOAP)
        self.ns_lv2core = NS(world, lilv.LILV_NS_LV2)
        self.ns_rdfs = NS(world, lilv.LILV_NS_RDFS)
        self.ns_rdf = NS(world, lilv.LILV_NS_RDF)

        self.ns_morph = NS(world, "http://lv2plug.in/ns/ext/morph#")
        self.ns_pset = NS(world, "http://lv2plug.in/ns/ext/presets#")
        self.ns_mod = NS(world, "http://moddevices.com/ns/mod#")
        self.ns_modgui = NS(world, "http://moddevices.com/ns/modgui#")

        self.errors = []
        self.warnings = []

        self.bundleuri = self.plugin.get_bundle_uri().as_string()
        self.bundle = lilv.lilv_uri_to_path(self.bundleuri)

        self.author = self.generate_author(world, plugin, self.bundleuri)

        self.uri = self.generate_uri()
        self.name = self.generate_name()

        self.binary = self.generate_binary(self.bundle)
        self.brand = self.generate_brand(self.author)
        self.label = self.generate_label()
        self.theLicense = self.generate_license()
        self.comment = self.generate_comment()

        self.version, self.minorVersion, self.microVersion = \
            self.generate_version_data()

        self.stability = self.generate_stability(self.minorVersion,
                                                 self.microVersion)

        self.bundles = self.generate_bundles()

        self.ports = self.generate_ports()

        self.data = {
            'uri': self.uri,
            'name': self.name,
            'binary': self.binary,
            'brand': self.brand,
            'label': self.label,
            'license': self.theLicense,
            'comment': self.comment,
            'category': get_category(plugin.get_value(self.ns_rdf.type_)),
            'microVersion': self.microVersion,
            'minorVersion': self.minorVersion,
            'version': self.version,
            'stability': self.stability,
            'author': self.author,
            'bundles': self.bundles,
            'gui': None,  # gui,
            'ports': self.ports,
            'presets': [],  # presets,
            'errors': self.errors,
            'warnings': self.warnings,
        }
Exemplo n.º 23
0
def get_pedalboards(asDictionary):
    global W, PLUGINS

    # define needed namespaces
    rdf = NS(W, lilv.LILV_NS_RDF)
    rdfs = NS(W, lilv.LILV_NS_RDFS)
    pset = NS(W, "http://lv2plug.in/ns/ext/presets#")
    modpedal = NS(W, "http://moddevices.com/ns/modpedal#")

    # fill in presets for a plugin
    def get_presets(p):
        presets = p.get_related(pset.Preset)

        def get_preset_data(preset):
            W.load_resource(preset.me)
            label = W.find_nodes(preset.me, rdfs.label.me,
                                 None).get_first().as_string()
            return {'uri': preset.as_string(), 'label': label}

        return list(LILV_FOREACH(presets, get_preset_data))

    # check each plugin for a pedalboard type
    if asDictionary:
        pedalboards = {}
    else:
        pedalboards = []

    for pedalboard in PLUGINS:
        # check if the plugin is a pedalboard
        def fill_in_type(node):
            return node.as_string()

        plugin_types = [
            i for i in LILV_FOREACH(pedalboard.get_value(rdf.type_),
                                    fill_in_type)
        ]

        if "http://moddevices.com/ns/modpedal#Pedalboard" not in plugin_types:
            continue

        # ready
        pedalboard = {
            'bundlepath':
            lilv.lilv_uri_to_path(pedalboard.get_bundle_uri().as_string()),
            'name':
            pedalboard.get_name().as_string(),
            'uri':
            pedalboard.get_uri().as_string(),
            'screenshot':
            lilv.lilv_uri_to_path(
                pedalboard.get_value(
                    modpedal.screenshot).get_first().as_string() or ""),
            'thumbnail':
            lilv.lilv_uri_to_path(
                pedalboard.get_value(
                    modpedal.thumbnail).get_first().as_string() or ""),
            'width':
            pedalboard.get_value(modpedal.width).get_first().as_int(),
            'height':
            pedalboard.get_value(modpedal.height).get_first().as_int(),
            'presets':
            get_presets(pedalboard)
        }

        if asDictionary:
            pedalboards[pedalboard['uri']] = pedalboard
        else:
            pedalboards.append(pedalboard)

    return pedalboards
Exemplo n.º 24
0
def remove_bundle_to_lilv_world(bundlepath, returnPlugins=False):
    global W, BUNDLES, PLUGINS, PLUGNFO, PLUGNFOk

    # lilv wants the last character as the separator
    if not bundlepath.endswith(os.sep):
        bundlepath += os.sep

    # stop now if bundle is not loaded
    if bundlepath not in BUNDLES:
        return [] if returnPlugins else False

    # In case returnPlugins is used
    removedPlugins = []

    # remove from loaded list
    BUNDLES.remove(bundlepath)

    # remove all plugins that are present on that bundle
    for p in PLUGINS:
        uri = p.get_uri().as_uri()

        if uri not in PLUGNFOk:
            continue

        bundles = lilv.lilv_plugin_get_data_uris(p.me)

        it = lilv.lilv_nodes_begin(bundles)
        while not lilv.lilv_nodes_is_end(bundles, it):
            bundle = lilv.lilv_nodes_get(bundles, it)
            it = lilv.lilv_nodes_next(bundles, it)

            if bundle is None:
                continue
            if not lilv.lilv_node_is_uri(bundle):
                continue

            bundle = os.path.dirname(
                lilv.lilv_uri_to_path(lilv.lilv_node_as_uri(bundle)))

            if not bundle.endswith(os.sep):
                bundle += os.sep

            if bundlepath != bundle:
                continue

            PLUGNFOk.remove(uri)
            PLUGNFO.pop(uri)

            if returnPlugins:
                removedPlugins.append(uri)

    # convert bundle string into a lilv node
    bundlenode = lilv.lilv_new_file_uri(W.me, None, bundlepath)

    # unload the bundle
    lilv.lilv_world_unload_bundle(W.me, bundlenode)

    # free bundlenode, no longer needed
    lilv.lilv_node_free(bundlenode)

    # refresh lilv plugins
    PLUGINS = W.get_all_plugins()

    return removedPlugins if returnPlugins else True