Jalv 1.2.0

jalv 1.2.0 has been released. Jalv is a simple but fully featured LV2 host for Jack which exposes plugin ports to Jack, essentially making any LV2 plugin function as a Jack application. For more information, see http://drobilla.net/software/jalv.

Changes:

  • Tune UI update rate and ring size based on JACK rate and MIDI buffer size to handle the handle the maximum message rate the plugin can send.
  • Support lv2:sampleRate control ports.
  • Tolerate loading presets with port values that aren't xsd:decimal
  • Notify plugins of Jack transport changes by sending events (an atom:Blank with properties from the LV2 time extension)
  • Refuse to instantiate plugins which require unsupported features
  • Support LV2 buf-size extension (with all features)
  • Add Gtk3 UI
  • Port to MinGW
  • Fix Jack Session support

Sord 0.10.4

sord 0.10.4 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:

  • Implement better data type validation in sord_validate conformant with the XSD and OWL specifications
  • Fix memory leaks in sord_validate
  • Install sord_validate man page
  • Disable timestamps in HTML documentation for reproducible build

How to define a datatype in RDF

I had to do some digging around to figure out how to define a new Datatype with restrictions in RDF, so I thought it might make a useful post to save someone else the trouble in the future.

RDF datatypes are based on XSD datatypes, which are often used directly. Unfortunately, most implementations simply have the XSD types baked in and do not support or validate new datatype descriptions (though at least sord_validate can). Regardless, it is sometimes necessary to define a datatype with a specific restriction so it can be machine validated. It's a bit tricky to figure out how to do this, since everything is buried in specifications that aren't as triple oriented as they should be. So, here is an example of defining a datatype restricted by regular expression in Turtle, derived from the OWL documentation:

<http://example.org/CSymbol>
    a rdfs:Datatype ;
    rdfs:comment "A symbol in the C programming language" ;
    owl:onDatatype xsd:string ;
    owl:withRestrictions (
        [
            xsd:pattern "[_a-zA-Z][_a-zA-Z0-9]*"
        ]
        ) .

The XSD specification defines several “constraining facets” you can use in this way. See the XSD specification for details, but the most obvious and useful for RDF are: xsd:length, xsd:minLength, xsd:maxLength, xsd:pattern, xsd:maxInclusive, xsd:maxExclusive, xsd:minInclusive, xsd:minExclusive. For example, you can define a numeric type with restricted range like so:

<http://example.org/AnswerishInteger>
    a rdfs:Datatype ;
    rdfs:comment "An integer between 24 and 42 inclusive" ;
    owl:onDatatype xsd:integer ;
    owl:withRestrictions (
        [
            xsd:minInclusive 24
        ] [
            xsd:maxInclusive 42
        ]
    ) .

Defining datatypes in this way and using them as the rdfs:range for properties is a good idea because it describes which values are valid in a machine readable way. This makes it possible for simple generic tools to validate data, ensuring that all literals are valid values for the property they describe.


Lilv 0.14.4

lilv 0.14.4 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:

  • Deprecate old flawed Lilv::Instance constructors
  • Fix documentation for ui_type parameter of lilv_ui_is_supported()
  • Fix crash when lv2info is run with an invalid URI argument
  • Gracefully handle failure to save plugin state and print error message
  • Reduce memory usage (per node)
  • Simpler node implementation always backed by a SordNode
  • Make all 'zix' symbols private to avoid symbol clashes in static builds
  • Add lv2bench utility
  • Fix various hyper-strict warnings
  • Do not require a C++ compiler to build
  • Add option to build utilities as static binaries
  • Upgrade to waf 1.7.2
  • lilvmm.hpp: Make Lilv::Instance handle features and failed instantiations
  • lilvmm.hpp: Add Lilv::Instance::get_handle()
  • lilvmm.hpp: Add Lilv::Instance::get_extension_data()

Sratom 0.4.0

sratom 0.4.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.

Changes:

  • Correctly read objects with several rdf:type properties
  • Support writing Object Atoms as top level descriptions if subject and predicate are not given.
  • Fix various hyper-strict warnings
  • Upgrade to waf 1.7.2

Sord 0.10.0

sord 0.10.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:

  • Add error callback to world for custom error reporting
  • Performance and space (per node) improvements
  • SSE4.2 accelerated hashing for node interning, where available
  • Make all 'zix' symbols private to avoid symbol clashes in static builds
  • Remove problematic "Loaded n statements" output from serdi
  • Strip down API documentation to a single clean page
  • Fix various hyper-strict warnings
  • Do not require a C++ compiler to build
  • Add option to build utilities as static binaries
  • Upgrade to waf 1.7.2
  • sordmm.hpp: Add indices and graphs parameters to Model constructor
  • sordmm.hpp: Remove overzealous URI scheme assertion
  • sordmm.hpp: Correctly handle Sord::Node self-assignment

Serd 0.18.0

serd 0.18.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:

  • Support digits at start of local names as per new Turtle grammar
  • Add incremental read interface suitable for reading from infinite streams
  • Add -e option to serdi to use incremental reading
  • Add error callback to reader and writer for custom error reporting
  • Add -q option to serdi to suppress all non-data output, e.g. errors
  • Reset indent when finishing a write
  • Report write size correctly when invalid UTF-8 is encountered and a replacement character is written
  • Strip down API documentation to a single clean page
  • Fix various hyper-strict warnings
  • Do not require a C++ compiler to build
  • Add option to build utilities as static binaries
  • Upgrade to waf 1.7.2

Benchmarking LV2 plugins

A new utility has been added to Lilv for benchmarking LV2 plugins. As you might expect, it is called lv2bench.

Simple, but useful, lv2bench runs all discovered plugins for a specified number of frames split into a specified block size, and records the time each plugin took to execute. It prints a simple table like this:

Block Samples Time Plugin
512 524288 0.005872 http://calf.sourceforge.net/plugins/Filter
512 524288 0.006461 http://drobilla.net/plugins/blop/amp
512 524288 0.008772 http://calf.sourceforge.net/plugins/Equalizer8Band
512 524288 0.008959 http://drobilla.net/plugins/fomp/autowah

This makes it easy to get a good overall feel for how expensive plugins on the system are relative to each other. Of course, a more expressive view of this information with several parameters would be useful... Robin Gareus to the rescue! Robin made a script currently called lilvplot which does several runs with various parameters and plots the data, which makes the relative performance more clear and shows the variance of a plugin's run time with error bars. This is important information because run-time variance is a good indicator of how real-time appropriate a plugin is.

Here is an example of lilvplot output generated from lv2bench data (as a massive SVG, you may want to open this image in a separate window and zoom in to see the plugin labels): LV2 Benchmark

Both of these tools are very fresh and there are certainly improvements to be made (normalizing the y-axis so it showed where real-time is would be more informative, and lv2bench currently supports very few features), but they already make a useful addition to the LV2 developer's toolkit. I found them useful for evaluating the improvements had by vectorizing the arithmetic plugins in my soon-to-be-released port of blop. It will be interesting to see how things stack up in more thorough runs that include more plugins.


LV2 OpenGL UIs on Windows

I have been working on Suil support for wrapping native Windows plugin UIs in Gtk. Here is a plugin with a Pugl UI embedded in the Gtk version of Jalv:

LV2 OpenGL UI in Windows

Very fresh work, but the basics (display, and mouse/keyboard input) are working well. This work is not actually OpenGL specific, any native Windows UI will work equally well. Apologies for the boring screenshot, this is just my test GL plugin that does nothing. However, it is a working example of a plugin with a portable custom UI; hopefully we'll soon see production plugins with UIs that work equally well across toolkits and platforms.


Suil 0.6.4

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

Changes:

  • Correctly handle resizing for Gtk2 in Qt4
  • Improve documentation

« Page 7 / 12 »