atom
type: Specification
name: LV2 Atom
maintainer: David Robillard
comment: This extension defines a generic format for a typed piece of data, called an "Atom" (e.g. integers, strings, buffers, data structures, etc). Atoms allow LV2 plugins and hosts to communicate, process, serialise, and store values of any type via a generic mechanism (e.g. LV2 ports, events, disk, shared memory, network). Atoms are, with one exception, Plain Old Data (POD) and may be safely copied (e.g. with a simple call to memcpy). Since Atom communication can be implemented generically, plugins that understand some type can be used together in a host that does not understand that type, and plugins (e.g. routers, delays) can process atoms of unknown type. An Atom can be trivially constructed in-place from an Event as defined by the LV2 Event extension. In other words, an Event is simply an Atom with a time stamp header. Atoms SHOULD be used anywhere a "value" needs to be stored or communicated, to allow implementations to be polymorphic and extensible. Atoms (the start of the LV2_Atom header) MUST be 32-bit aligned. Optionally, the host MAY implement blob support. A Blob is a dynamically allocated chunk of memory that (unlike an Atom) is not necessarily POD. Blobs are accessed via a Reference, which is a special case of Atom that always has type = 0, is not POD, and can only be copied using host provided functions. This allows plugins and hosts to work with data of any type at all. Atoms can be communicated in many ways. Since an Atom is the payload of an Event, an EventPort can be used for communicating Atoms in realtime with sub-sample time stamp accuracy. This extension also defines two port types for connecting directly to a single Atom: ValuePort and MessagePort, which both have the same buffer format but different semantics (with respect to how the run() callback interprets the Atom). This extension requires the host to support the LV2 URI Map extension.

Atom
type: Class
comment: Abstract base class for all atoms. An LV2_Atom has a 16-bit type and size followed by a body. All concrete Atom types (subclasses of this class) MUST define a precise binary layout for body. The type field is the URI of a subclass of Atom mapped to an integer using the URI Map extension's LV2_URI_Map_Feature::uri_to_id with map = "http://lv2plug.in/ns/ext/event". If a plugin or host does not understand type, that atom SHOULD be gracefully ignored (though it MAY be copied if it is not a Reference). All atoms are POD by definition except references, which have type = 0. An Atom MUST NOT contain a Reference. It is safe to copy any non-reference Atom with a simple memcpy, even if the implementation does not understand type.

Reference
type: Class
subclass of: Atom
comment: Reference to a Blob. The actual contents of a Reference are opaque and host specific, and must not be copied, serialized, or otherwise interpreted by a plugin, except via functions provided by the host in LV2_Blob_Support. A Reference is a special case of Atom with type = 0. "Null" is the unique Atom with type = 0 and size = 0.

String
type: Class
subclass of: Atom
comment: A UTF-8 encoded string, with an optional language tag. An LV2_Atom_String has an ID lang followed by the string data in UTF-8 encoding. The length of the string data in bytes is size - sizeof(uint32_t), including the terminating NULL character. The lang may be any URI; to describe a human language, use http://lexvo.org/id/term/LANG where LANG is an ISO 693-2 or ISO 693-3 language code. For example, "Hello" in English: struct LV2_Atom { uint16_t type = uri_to_id(atom:String); uint16_t size = 10; } uint32_t lang = uri_to_id("http://lexvo.org/id/term/en"); char str[] = "Hello"; and French: struct LV2_Atom { uint16_t type = uri_to_id(atom:String); uint16_t size = 12; } uint32_t lang = uri_to_id("http://lexvo.org/id/term/fr"); char str[] = "Bonjour"; or a Turtle string: struct LV2_Atom { uint16_t type = uri_to_id(atom:String); uint16_t size = 60; } uint32_t lang = uri_to_id("http://www.w3.org/2008/turtle#turtle"); char str[] = "<http://example.org/foo> a <http://example.org/Thing> ."

Integer ID mapped from a URI
type: Class
subclass of: Atom
comment: An unsigned 32-bit integer mapped from a URI using the URI Map extension's LV2_URI_Map_Feature::uri_to_id with map = NULL.

Integer ID for a blank node
type: Class
subclass of: Atom
comment: An unsigned 32-bit integer identifier for a blank node. A BlankID is only meaningful within a limited scope (e.g. the Atom in which it appears), and MUST NOT be used as a global identifier. In particular, a BlankID is NOT an ID, and can not be mapped to/from a URI.

Vector
type: Class
subclass of: Atom
comment: A homogeneous sequence of atoms with equivalent type and size. An LV2_Atom_Vector is a 16-bit elem_count and elem_type followed by elem_count atom bodies of type elem_type. The element type must be a fixed size Atom type, i.e. the size of each element is the vector's size / elem_count. For example, an atom:Vector containing 42 elements of type atom:Float looks like this in memory: struct LV2_Atom { uint16_t type = uri_to_id(atom:Vector); uint16_t size = sizeof(LV2_Atom) + sizeof(LV2_Atom_Vector) + (42 * sizeof(float); } struct LV2_Vector { uint16_t elem_count = 42; uint16_t elem_type = uri_to_id(atom:Float); } float elem_00; float elem_01; ... float elem_41; Note that it is possible to construct a valid Atom for each element of the vector, even by an implementation which does not understand elem_type. A Vector header is 64-bits, thus the first element of a Vector is 64-bit aligned if the Vector itself is 64-bit aligned.

Tuple
type: Class
subclass of: Atom
comment: A sequence of atoms with varying type and size. The body of a Tuple is simply a sequence of complete atoms, each aligned to 32 bits.

Property of an Object
type: Class
subclass of: Atom
comment: A single property of some Object. An LV2_Atom_Property has an ID key and Atom value.

Object
type: Class
subclass of: Atom
comment: Abstract base class for an "Object", i.e. an Atom with a number of properties. An LV2_Object is an unsigned 32-bit integer context and id followed by a sequence of properties. The context is mapped using the URI Map extension's LV2_URI_Map_Feature::uri_to_id with map = NULL, and may be 0 (the default context). Note this is an abstract class, i.e. no Atom can exist with type = uri_to_id(atom:Object). An Object is either a Resource or a Blank, but the body always has the same binary format. Thus, both named and anonymous objects can be handled with common code using only a 64-bit header for both.

Resource
type: Class
subclass of: Object
comment: An Object where id is the URI of the resource mapped to an ID.

Blank
type: Class
subclass of: Object
comment: An Object where id is the blank node ID of the object, which is only meaningful within a certain limited scope (e.g. the container of the Blank) and MUST NOT be used as a global ID. In particular, id is NOT an ID.

Model
type: Class
subclass of: Atom
comment: A description of a set of objects. In memory, a Model is simply a sequence of objects.

Bang (activity) (size = 0)
type: Class
subclass of: Atom

Byte (size = 1)
type: Class
subclass of: Atom

Signed 32-bit integer
type: Class
subclass of: Atom

Signed 64-bit integer
type: Class
subclass of: Atom

Signed 32-bit integer where 0 is false
type: Class
subclass of: Atom

32-bit IEEE-754 floating point number
type: Class
subclass of: Atom

64-bit IEEE-754 floating point number
type: Class
subclass of: Atom

Blob support
type: Feature
comment: Support for dynamically allocated blobs. If a host supports this feature, it MUST pass a LV2_Feature with URI http://lv2plug.in/ns/ext/atom#blobSupport and data pointing to a LV2_Blob_Support.

Blob
type: Class
comment: Base class for all dynamically allocated blobs. An LV2_Blob ia an opaque pointer to host data. The type and data of a blob can be accessed via host-provided functions in LV2_Blob_Support. The type of a blob can be any URI that describes a data format. Blobs are always allocated by the host, and unlike atoms are not necessarily POD. Blob data MUST NOT be used in any way by an implementation that does not understand that blob type (unlike Atoms, meaningful type-oblivious use of a Blob is impossible).

Atom Port
type: Class
subclass of: Port
comment: A port which contains an Atom. Ports of this type will be connected to a 32-bit aligned LV2_Atom immediately followed by size bytes of data. This is an abstract port type, i.e. a port MUST NOT only be an AtomPort, but must be a more descriptive type that is a subclass of AtomPort which defines the port's semantics (typically ValuePort or MessagePort). Before calling a method on the plugin that writes to an AtomPort output, the host MUST set the size of the Atom in that output to the amount of available memory immediately following the Atom header. The plugin MUST write a valid Atom to that port (leaving it untouched is illegal). If there is no reasonable value to write to the port, the plugin MUST write NULL (the Atom with both type = 0 and size = 0).

Value Port
type: Class
subclass of: Atom Port
comment: An AtomPort that interprets its data as a persistent and time-independent "value". If a plugin has fixed input values for all ports, all ValuePort outputs are also fixed regardless of the number of times the plugin is run. If a plugin has fixed input values for all ports except a ValuePort, each value V of that ValuePort corresponds to a single set of outputs for all ports. If a ValuePort contains a reference then the blob it refers to is constant; plugin MUST NOT modify the blob in any way. Value ports can be thought of as purely functional ports: if a plugin callback has only value ports, then the plugin callback is a pure function.

Message Port
type: Class
subclass of: Atom Port
comment: An AtomPort that "receives", "consumes", "executes", or "sends" its value. The Atom contained in a MessagePort is considered transient and/or time-dependent, and is only valid for a single run invocation. Unlike a ValuePort, a MessagePort may be used to manipulate internal plugin state. Intuitively, a MessagePort contains a "message" or "command" or "event" which is reacted to, NOT a "value" or "signal" (which is computed with).

supports
type: Property
domain: Port
range: Atom
comment: Indicates that a Port supports a certain Atom type. This is distinct from the port type - e.g. the port type ValuePort can hold atoms with many different types. This property is used to describe which Atom types a Port expects to receive or send.