atom
type: Specification
name: LV2 Atom
shortdesc: A generic value container and several data types.
license: isc
release:
  revision: 0.5
  created: 2012-02-18
maintainer: David Robillard
documentation: This extension defines a generic container for data, called an Atom, and several basic Atom types which can be used to express structured data. Atoms are (with one exception) Plain Old Data (POD), which means they can be easily copied generically (e.g. using memcpy), and are suitable for use in high-performance and real-time code. 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. Similarly, plugins (such as routers, delays, or data stores) can meaningfully process atoms of a type unknown to them. Atoms can and should be used anywhere values of various types must be stored or transmitted. This extension defines port types, atom:ValuePort and atom:MessagePort, which contain Atoms. The atom:Sequence type in conjunction with atom:MessagePort is intended to replace the LV2 event extension. The types defined in this extension should be powerful enough to express almost any structure. Implementations SHOULD build structures out of the types provided here, rather than define new binary formats (e.g. use atom:Object rather than a new C struct type). New binary formats are an implementation burden which harms interoperabilty, and should only be defined where absolutely necessary. Implementing this extension requires a facility for mapping URIs to integers, such as the LV2 URID extension.

C type
type: Property
type: DatatypeProperty
domain: Class
range: string
comment: The identifier for a C type describing the in-memory representation of an instance of this class.

Atom
type: Class
C type: LV2_Atom
documentation: Abstract base class for all atoms. An LV2_Atom has a 32-bit type and size followed by a body of size bytes. Atoms MUST be 64-bit aligned. All concrete Atom types (subclasses of this class) MUST define a precise binary layout for their body. The type field is the URI of an Atom type mapped to an integer. Implementations SHOULD gracefully ignore, or pass through, atoms with unknown types. All atoms are POD by definition except references, which as a special case 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. Though this extension reserves the type 0 for references, the details of reference handling are currently unspecified. A future revision of this extension, or a different extension, may define how to use non-POD data and references. Implementations MUST NOT send references to another implementation unless the receiver is explicitly known to support references (e.g. by supporting a feature). The atom with both type and size 0 is null, which is not considered a Reference.

Bang
type: Class
subclass of: Atom
comment: Generic activity or trigger, with no body.

Number
type: Class
subclass of: Atom

Signed 32-bit integer
type: Class
subclass of: Number
C type: LV2_Atom_Int32

Signed 64-bit integer
type: Class
subclass of: Number
C type: LV2_Atom_Int64

32-bit IEEE-754 floating point number
type: Class
subclass of: Number
C type: LV2_Atom_Float

64-bit IEEE-754 floating point number
type: Class
subclass of: Number
C type: LV2_Atom_Double

Boolean
type: Class
subclass of: Atom
C type: LV2_Atom_Bool
comment: An Int32 where 0 is false and any other value is true.

String
type: Class
subclass of: Atom
C type: LV2_Atom_String
documentation: A UTF-8 encoded string. The body of an LV2_Atom_String is a C string in UTF-8 encoding, i.e. an array of bytes (uint8_t) terminated with a NULL byte ('\0'). This type can be used for free-form strings, but in most cases it is better to use atom:Literal since this supports a language tag or datatype. Implementations SHOULD NOT use atom:String unless translating the string does not make sense and the string has no meaningful datatype.

String Literal
type: Class
subclass of: Atom
C type: LV2_Atom_Literal
documentation: A UTF-8 encoded string literal, with an optional datatype or language. This type is compatible with rdf:Literal and is capable of expressing a string in any language or a value of any type. A Literal has a datatype and lang followed by string data in UTF-8 encoding. The length of the string data in bytes is size - sizeof(LV2_Atom_Literal), including the terminating NULL character. The lang field SHOULD be a URI of the form <http://lexvo.org/id/term/LANG> where LANG is an ISO 693-2 or ISO 693-3 language code. A Literal may have a datatype OR a lang, but never both. For example, a Literal can be "Hello" in English: void set_to_hello_in_english(LV2_Atom_Literal* lit) { lit->atom.type = map(expand("atom:Literal")); lit->atom.size = 14; lit->datatype = 0; lit->lang = map("http://lexvo.org/id/term/en"); memcpy(LV2_ATOM_CONTENTS(LV2_Atom_Literal, lit), "Hello", sizeof("Hello")); // Assumes enough space } or a Turtle string: void set_to_turtle_string(LV2_Atom_Literal* lit, const char* ttl) { lit->atom.type = map(expand("atom:Literal")); lit->atom.size = 64; lit->datatype = map("http://www.w3.org/2008/turtle#turtle"); lit->lang = 0; memcpy(LV2_ATOM_CONTENTS(LV2_Atom_Literal, lit), ttl, strlen(ttl) + 1); // Assumes enough space }

File path string
type: Class
subclass of: String
documentation: A local file path string. This is identical in format to atom:String, except the string is a path. Since the ability to distinguish paths from plain strings is often necessary, paths MUST NOT be transmitted as atom:String.

URI string
type: Class
subclass of: String
documentation: A URI string. This is identical in format to atom:String, except the string is a URI. This is useful when a URI is needed but mapping is inappropriate. Since the ability to distinguish URIs from plain strings is often necessary, URIs MUST NOT be transmitted as atom:String. This is not strictly a URI, since UTF-8 is allowed. Escaping and related issues issues are the host's responsibility.

Integer ID mapped from a URI
type: Class
subclass of: Atom
C type: LV2_Atom_ID
documentation: An unsigned 32-bit integer mapped from a URI (e.g. with LV2_URID_Map).

Vector
type: Class
subclass of: Atom
C type: LV2_Atom_Vector
documentation: A homogeneous series of atom bodies with equivalent type and size. An LV2_Atom_Vector is a 32-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: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: struct VectorOf42Floats { uint32_t type; // map(expand("atom:Vector")) uint32_t size; // sizeof(LV2_Atom_Vector) + (42 * sizeof(float); uint32_t elem_count; // 42 uint32_t elem_type; // map(expand("atom:Float")) float elems[32]; }; 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.

Tuple
type: Class
subclass of: Atom
documentation: A series of Atoms with varying type and size. The body of a Tuple is simply a series of complete atoms, each aligned to 64 bits.

Property
type: Class
subclass of: Atom
C type: LV2_Atom_Property
documentation: A property of an atom:Object. An LV2_Atom_Property has a URID key and context, and an Atom value. This corresponds to an RDF Property, where the key is the predicate and the value is the object. The context field can be used to specify a different context for each property, where this is useful. Otherwise, it may be 0.

Object
type: Class
subclass of: Atom
C type: LV2_Atom_Object
documentation: An Object is an atom with a set of properties. This corresponds to an RDF Resource, and can be thought of as a dictionary with URID keys. An LV2_Atom_Object has a uint32_t id and uint32_t type, followed by a series of atom:Property bodies (without headers, i.e. LV2_Atom_Property_Body). The LV2_Atom_Object::type field is semantically equivalent to a property with key rdf:type, but is included in the structure to allow for fast dispatch. This is an abstract Atom type, an Object is always either a atom:Resource or a atom:Blank.

Resource
type: Class
subclass of: Object
C type: LV2_Atom_Object
documentation: An atom:Object where the id field is a URID, i.e. an Object with a URI.

Blank
type: Class
subclass of: Object
C type: LV2_Atom_Object
documentation: An atom:Object where the LV2_Atom_Object::id is a blank node ID (NOT a URI). The ID of a Blank is valid only within the context the Blank appears in. For ports this is the context of the associated run() call, i.e. all ports share the same context so outputs can contain IDs that correspond to IDs of blanks in the input.

Time Unit
type: Class
documentation: A unit for atom:Event time stamps.

Audio frames
type: Class
subclass of: Time Unit
documentation: Time in audio frames. Converting this to absolute time depends on the sample rate. When this is the stamp unit for an atom:Sequence, the events in that sequence have LV2_Atom_Audio_Time stamps (event.time.audio)

Beats
type: Class
subclass of: Time Unit
documentation: Time in beats. Converting this to absolute time depends on the tempo. When this is the stamp unit for an atom:Sequence, the events in that sequence have a double stamp (event.time.beats).

Event
type: Class
C type: LV2_Atom_Event
documentation: An atom with a time stamp header prepended, typically an element of an atom:Sequence. Note this is not an Atom type.

Sequence
type: Class
subclass of: Atom
C type: LV2_Atom_Sequence
documentation: A sequence of atom:Event, i.e. a series of time-stamped Atoms.

Atom Port
type: Class
subclass of: Port
documentation: A port which contains an lv2:Atom. Ports of this type are connected to an LV2_Atom_Port_Buffer, which contains a pointer to the port's Atom contents, as well as other metadata (such as capacity, for output ports with variably sized types). The host MUST set all fields of LV2_Atom_Port_Buffer to appropriate values before calling the plugin's run method. LV2_Atom_Port_Buffer::capacity must be set to the available space for the body of LV2_Atom_Port_Buffer::data, i.e. the maximum possible value for its size field, which does not include the LV2_Atom header. This is an abstract port type with incomplete semantics which can not be used directly as a port type. Atom ports should be either a atom:ValuePort or a atom:MessagePort. Before calling a method on a 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 and size 0).

Value Port
type: Class
subclass of: Atom Port
documentation: An AtomPort that contains a persistent value. A value is time-independent and may be used numerous times. A ValuePort is pure in the sense that it may affect output but MUST NOT affect persistent plugin state in any externally visible way. If a plugin has fixed values for all inputs, 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 of that port corresponds to a single set of values for all ValuePort outputs. If the plugin saves state other than port values (e.g. using the LV2 State extension), changing only the value of a ValuePort input MUST NOT change that state. In other words, value port changes MUST NOT trigger a state change that requires a save. Value ports are essentially purely functional ports: if a plugin has only value ports, that plugin is purely functional. Hosts may elect to cache output and avoid calling run() if the output is already known according to these rules.

Message Port
type: Class
subclass of: Atom Port
documentation: An AtomPort that contains transient data which is consumed or sent. The Atom contained in a MessagePort is time-dependent and 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 event which is reacted to once (not a value which is computed with any number of times).

buffer type
type: Property
domain: Atom Port
documentation: Indicates that an AtomPort may be connected to a certain Atom type. A port MAY support several buffer types. The host MUST NOT connect a port to an Atom with a type not explicitly listed with this property. The value of this property MUST be a sub-class of atom:Atom. For example, an input port that is connected directly to an LV2_Atom_Double value is described like so: <plugin> lv2:port [ a lv2:InputPort , atom:ValuePort ; atom:bufferType atom:Double ; ] . Note this property only indicates the atom types a port may be directly connected to, it is not recursive. If a port can be connected to a collection, use atom:supports to indicate which element types are understood. If a port supports heterogeneous collections (collections that can contain several types of elements at once), implementations MUST gracefully handle any types that are present in the collection, even if those types are not explicitly supported.

supports
type: Property
documentation: Indicates that a particular Atom type is supported. This property is defined loosely, it may be used to indicate that anything supports an Atom type, wherever that may be useful. It applies recursively where collections are involved. In particular, this property can be used to describe which event types are supported by a port. For example, a port that receives MIDI events is described like so: <plugin> lv2:port [ a lv2:InputPort , atom:MessagePort ; atom:bufferType atom:Sequence ; atom:supports midi:MidiEvent ; ] .

eventTransfer
type: PortProtocol
documentation: Transfer of individual events. Useful as the format for a LV2_UI_Write_Function, or the port_protocol for LV2_PUI_Host_Descriptor::write_port(). This protocol applies to ports which contain events, usually in an atom:Sequence. The host must transfer each individual event to the recipient. The format of the received data is an LV2_Atom, there is no timestamp header.