Lilv 0.14.2

lilv 0.14.2 has been released. Lilv is a C library to make the use of LV2 plugins as simple as possible for applications. For more information, see http://drobilla.net/software/lilv.

Changes:

  • Fix dynmanifest support

Lilv 0.14.0

lilv 0.14.0 has been released. Lilv is a C library to make the use of LV2 plugins as simple as possible for applications. For more information, see http://drobilla.net/software/lilv.

Changes:

  • Add lilv_plugin_get_extension_data
  • Use path variables in pkgconfig files
  • Install man page to DATADIR (e.g. PREFIX/share/man, not PREFIX/man)
  • Make Lilv::uri_to_path static inline (fix linking errors)
  • Use correct URI for dcterms:replaces (for hiding old plugins): "http://purl.org/dc/terms/replaces"
  • Fix compilation on BSD
  • Only load dynmanifest libraries once per bundle, not once per plugin
  • Fix lilv_world_find_nodes to work with wildcard subjects
  • Add lilv_plugin_get_related to get resources related to plugins that are not directly rdfs:seeAlso linked (e.g. presets)
  • Add lilv_world_load_resource for related resources (e.g. presets)
  • Print presets in lv2info
  • Remove locale smashing kludges and use new serd functions for converting nodes to/from numbers.
  • Add LilvState API for handling plugin state. This makes it simple to save and restore plugin state both in memory and on disk, as well as save presets in a host-sharable way since the disk format is identical to the LV2 presets format.
  • Update old references to lv2_list (now lv2ls)
  • Support compilation as C++ under MSVC++.
  • Remove use of wordexp.
  • Add lilv_plugin_get_port_by_designation() and lilv_port_get_index() as an improved generic alternative to lilv_plugin_get_latency_port_index().
  • Add lilv_plugin_get_project() and get author information from project if it is not given directly on the plugin.

Suil 0.6.0

suil 0.6.0 has been released. Suil is a library for loading and wrapping LV2 plugin UIs. For more information, see http://drobilla.net/software/suil.

Changes:

  • Use path variables in pkgconfig files
  • Add support for embedding X11 UIs (ui:X11UI)
  • Support new LV2 UI features automatically if provided by host

Sratom 0.2.0

sratom 0.2.0 has been released. Sratom is a library for serialising LV2 atoms to/from RDF, particularly the Turtle syntax. For more information, see http://drobilla.net/software/sratom.


LV2 1.0.0

The first unified LV2 release, LV2 1.0.0, is out.

This release merges the previous lv2core package with all the official extension packages, as well as example plugins, lv2specgen, and additional data. From a developer point of view, the biggest change is that all LV2 API headers can be used by simply checking for the single pkg-config package "lv2" (for compatibility the previous "lv2core" package is still installed). Implementations are encouraged to abandon the "copy paste headers" practice and depend on this package instead.

With this release, several new extensions have become stable that together greatly increase the power of LV2: atom, log, parameters, patch, port-groups, port-props, resize-port, state, time, worker.

Documentation and more detailed change logs

Download LV2 1.0.0


Sord 0.8.0

sord 0.8.0 has been released. Sord is a lightweight C library for storing RDF statements in memory. For more information, see http://drobilla.net/software/sord.

Changes:

  • Use path variables in pkgconfig files
  • Install man page to DATADIR (e.g. PREFIX/share/man, not PREFIX/man)
  • Tolerate serd passing NULL nodes to reader callback (serd 0.6.0)
  • Fix comparison of typed literals
  • Take advantage of interning in sord_node_equals()
  • Support compilation as C++ under MSVC++.
  • Add sord_iter_get_node()
  • Refuse to intern relative URIs in sord_new_uri*()
  • Add sord_new_relative_uri()
  • Add SordInserter for writing to a model via Serd sink functions.
  • Add convenient sord_search(), sord_ask(), and sord_count()
  • Add sord_validate tool for validating data against RDF/OWL schemas

Serd 0.14.0

serd 0.14.0 has been released. Serd is a lightweight C library for RDF syntax which supports reading and writing Turtle and NTriples. For more information, see http://drobilla.net/software/serd.

Changes:

  • Use path variables in pkgconfig files
  • Install man page to DATADIR (e.g. PREFIX/share/man, not PREFIX/man)
  • Tolerate invalid characters in string literals by replacing with the Unicode replacement character
  • Report reason for failure to open file in serdi
  • Improve write performance by doing bulk writes for unescaped substrings
  • Add SerdBulkSink for writing bulk output and corresponding serdi -B option
  • Add serdi -f option to prevent URI qualification
  • Remove use of multi-byte peek (readahead) and use exactly 1 page for read buffer (instead of 2)
  • Handle a quote as the last character of a long string literal in the writer (by escaping it) rather than the reader, to avoid writing Turtle other tools fail to parse.
  • Add serd_strtod(), serd_node_new_decimal(), and serd_node_new_integer() for locale-independent numeric node parsing/serialising.
  • Add serd_file_sink for easy writing to a FILE* stream.
  • Add serd_chunk_sink for easy writing to a string.
  • Escape ASCII control characters in output (e.g. fix problems with string literals that start with a backspace)
  • Improve URI resolution to cover most of the abnormal cases from RFC3986
  • Support file://localhost/foo URIs in serd_uri_to_path()
  • Support Windows file://c:/foo URIs in serd_uri_to_path() on all platforms
  • Add serd_node_new_blob and serd_base64_decode for handling arbitrary binary data via base64 encoding.
  • Support compilation as C++ under MSVC++.
  • Implement pretty-printing for collections.
  • Parse collections iteratively in O(1) space.
  • Report read error if both "genid" and "docid" IDs are found in the same document, to prevent silent merging of distinct blank nodes.
  • Handle files and strings that start with a UTF-8 Byte Order Mark.
  • Add serd_writer_get_env().
  • Add serd_node_new_file_uri() and serd_file_uri_parse() and implement proper URI to/from path hex escaping, etc.
  • Add serd_uri_serialise_relative() for making URIs relative to a base where possible (by chopping a common prefix and adding dot segments).
  • Make URIs serialised by the writer properly escape characters.
  • Add serd_writer_set_root_uri() and corresponding -r option to serdi to enable writing URIs with up references (../).
  • Resolve dot segments in serd_uri_resolve() instead of at write time.
  • Add serd_reader_set_default_graph() for reading a file as a named graph.

LV2 atom and state serialisation

I have been working on full round-trip serialisation for everything in the LV2 Atom extension (which also applies for implementing state). I am doing this as a small library with a simple API, with the goal that it be simple to include in any project.

svn co http://svn.drobilla.net/lad/trunk/sratom

Currently this only writes (using Serd), I still need to move the reading stuff into it (which will probably use a model and thus require using Sord).

The Atom extension defines a simple data model for use in LV2 plugins and hosts (or elsewhere). The general Big Idea here is to have a smallish set of primitive types, a few collections, and out of that one can build arbitrarily complex structures. Everything (including containers) is a simple and compact chunk of POD data, but serialises to/from (a subset of) RDF, so it can nicely be described in a plugin's Turtle file, among other advantages.

An easy to adopt serialisation API is important to making these advantages a reality for many implementations, so I have decided to provide one before marking these extensions stable. It also serves as a nice test case with complete coverage. Here is an example of an Atom that contains every currently defined Atom type, as well as MIDI, serialised to Turtle by sratom:

[]
    rdf:value [
        a eg:Object ;
        eg:one "1"^^xsd:int ;
        eg:two "2"^^xsd:long ;
        eg:three "3.0"^^xsd:float ;
        eg:four "4.0"^^xsd:double ;
        eg:true true ;
        eg:false false ;
        eg:path </foo/bar> ;
        eg:uri eg:value ;
        eg:urid eg:value ;
        eg:string "hello" ;
        eg:langlit "bonjour"@fra ;
        eg:typelit "value"^^eg:Type ;
        eg:blank [
            a eg:Object ;
        ] ;
        eg:tuple [
            a atom:Tuple ;
            rdf:value (
                "foo"
                true
            ) ;
        ] ;
        eg:vector [
            a atom:Vector ;
            rdf:value (
                "1"^^xsd:int
                "2"^^xsd:int
                "3"^^xsd:int
                "4"^^xsd:int
            ) ;
        ] ;
        eg:seq [
            a atom:Sequence ;
            rdf:value (
                [
                    atom:frameTime 1 ;
                    rdf:value "901A01"^^midi:MidiEvent ;
                ] [
                    atom:frameTime 3 ;
                    rdf:value "902B02"^^midi:MidiEvent ;
                ]
            ) ;
        ] ;
    ] .

I anticipate/intend for all plugin control to happen via such messages, since this approach has a few important qualities:

  1. Typically no need to define new binary formats for things (and be held back waiting for others to implement them).
  2. Everything has a portable serialization for free (meaning network transparency, saving/loading, and for developers or power users the ability to dump any message to see what is going on).
  3. The convention is to use "objects" (resources, i.e. things with properties) as messages, which are inherently extensible. No "oops I needed to add a parameter so now compatibility is broken".
  4. Easy to bind to other languages or syntaxes, so e.g. Python or browser-based UI frameworks should be possible.
  5. Any RDF vocabulary can be used, meaning millions of well-defined and documented predicates ("keys") are available right now (though it is perfectly okay to create one-off objects - compatibility with RDF is a benefit, not a burden).

The atom extension includes an API that makes it relatively simple to build such objects in C, so plugins can write them directly to an output port or a ring buffer. See the "forge" API in the Atom extension for details. There are also iterators for all the collections and a "get" function for objects to make reading data simple.

Just in case it's not crystal clear, the above is only the external representation of the corresponding atom. At run-time, an atom (i.e. what plugins work with) is just a blob of data with an integer type and size header. 100% of the API provided for reading and writing atoms is real-time safe and suitable for use in an audio processing thread.

For an example, see the LV2 sampler example, which has a UI that loads samples via such messages. It currently works in Jalv, Ardour support is coming soon. This is the way forward for more powerful LV2 plugin control, and hopefully will end the worrying practice of abusing direct instance access to provide such functionality.

This work isn't finished yet, but the important parts are done and not likely to change significantly. I am interested in hearing any developer feedback, feel free to comment on this post or at the LV2 mailing list.


Lilv 0.5.0

lilv 0.5.0 has been released. Lilv is a C library to make the use of LV2 plugins as simple as possible for applications. For more information, see http://drobilla.net/software/lilv.

Changes:

  • Remove glib dependency
  • Add lv2core as a pkg-config dependency (for lv2.h header include)
  • Obey prefix when installing bash completion script
  • Support integer minimum, maximum, and default port values in lilv_plugin_get_port_ranges_float
  • Add ability to build static library

Serd 0.5.0

serd 0.5.0 has been released. Serd is a lightweight C library for RDF syntax which supports reading and writing Turtle and NTriples. For more information, see http://drobilla.net/software/serd.

Changes:

  • Fix pretty printing of successive blank descriptions, i.e. "] , ["
  • Avoid writing illegal Turtle names as a result of URI qualifying
  • Gracefully handle NULL reader sinks
  • Add serd_strerror
  • Add serd_env_set_prefix_from_strings for convenience
  • Fix erroneously equal SERD_ERR_BAD_SYNTAX and SERD_ERR_BAD_ARG
  • Add ability to build static library

« Page 8 / 12 »