atom
type: Specification
name: LV2 Atom
shortdesc: A generic value container and several data types.
license: isc
created: 2007-00-00
developer: me
release:
  revision: 1.1
  blame: me
  changeset:
    item: Fix implicit conversions in forge.h that are invalid in C++11.
    item: Fix lv2_atom_object_next() on 32-bit platforms.
release:
  revision: 1.0
  created: 2012-04-17
  file-release: lv2-1.0.0.tar.bz2
  blame: me
  changeset:
    item: Initial release.
documentation: This specification defines a generic container for data, called an Atom, and several basic Atom types which can be used to express structured data. An atom:Atom is (with one exception) Plain Old Data (POD), which means it can be copied generically (e.g. using a simple memcpy), and is suitable for use in real-time code. The purpose of Atoms is to allow implementations that process and/or transmit data to be independent of that data's type. For example, plugins that mutually understand a type can be used together in a host that does not understand that type, because the host's required facilities are generic. Similarly, plugins (such as routers, delays, or data structures) 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. The port type atom:AtomPort can be used to transmit atoms via ports. The atom:Sequence type in an atom:AtomPort replaces 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. Serialisation An Atom type primarily defines a binary format (i.e. a C data type) for use at runtime. However, each Atom type also has a standard serialisation format which SHOULD be used wherever an atom needs to be expressed as a string or in Turtle. Thus, this specification not only defines binary data types for plugins to use, but a complete data model with a portable RDF-compatible serialisation. This is useful for inter-process communication as well as saving state.

C type
type: Property
type: DatatypeProperty
type: FunctionalProperty
domain: Class
range: Symbol
comment: The identifier for a C type describing the binary representation of an Atom of this type.

String type
type: Property
type: ObjectProperty
type: FunctionalProperty
domain: Class
range: Datatype
documentation: The type to be used when representing an Atom of this type as a string (e.g. in XML or RDF). Typically an XML Schema Datatype URI.

Atom
type: Class
C type: LV2_Atom
documentation: Abstract base class for all atoms. An LV2_Atom has a 32-bit size and type 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 pass through, or ignore, 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.

Chunk of memory
type: Class
subclass of: Atom
String type: base64Binary
documentation: A chunk of memory with undefined contents. This type is used to indicate a certain amount of space is available. For example, output ports with a variably sized type are connected to a Chunk so the plugin knows the size of the buffer available for writing. The use of a Chunk should be constrained to a local scope, since interpreting it is impossible without context. However, if serialised to RDF, a Chunk may be represented directly as an xsd:base64Binary string, e.g.: [] eg:someChunk "vu/erQ=="^^xsd:base64Binary .

Number
type: Class
subclass of: Atom

Signed 32-bit integer
type: Class
subclass of: Number
C type: LV2_Atom_Int
String type: int

Signed 64-bit integer
type: Class
subclass of: Number
C type: LV2_Atom_Long
String type: long

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

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

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

String
type: Class
subclass of: Atom
C type: LV2_Atom_String
String type: 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 is for free-form strings, but SHOULD NOT be used for typed data or text in any language. Use atom:Literal 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 rdfs: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/iso639-3/LANG> or <http://lexvo.org/id/iso639-1/LANG> where LANG is a 3-character ISO 693-3 language code, or a 2-character ISO 693-1 language code, respectively. 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->body.datatype = 0; lit->body.lang = map("http://lexvo.org/id/iso639-1/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->body.datatype = map("http://www.w3.org/2008/turtle#turtle"); lit->body.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
String type: anyURI
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, for example with temporary or relative URIs. 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 are the host's responsibility.

Integer ID mapped from a URI
type: Class
subclass of: Atom
C type: LV2_Atom_URID
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 child_size and child_type followed by size / child_size atom bodies. For example, an atom:Vector containing 42 elements of type atom:Float: struct VectorOf42Floats { uint32_t size; // sizeof(LV2_Atom_Vector_Body) + (42 * sizeof(float); uint32_t type; // map(expand("atom:Vector")) uint32_t child_size; // sizeof(float) uint32_t child_type; // map(expand("atom:Float")) float elems[42]; }; Note that it is possible to construct a valid Atom for each element of the vector, even by an implementation which does not understand child_type. If serialised to RDF, a Vector SHOULD have the form: eg:someVector a atom:Vector ; atom:childType atom:Int ; rdf:value ( "1"^^xsd:int "2"^^xsd:int "3"^^xsd:int "4"^^xsd:int ) .

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. If serialised to RDF, a Tuple SHOULD have the form: eg:someVector a atom:Tuple ; rdf:value ( "1"^^xsd:int "3.5"^^xsd:float "etc" ) .

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. Properties generally only exist as part of an atom:Object. Accordingly, they will typically be represented directly as properties in RDF (see atom:Object). If this is not possible, they may be expressed as partial reified statements, e.g.: eg:someProperty rdf:predicate eg:theKey ; rdf:object eg:theValue .

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. If serialised to RDF, an Object SHOULD be represented directly as a resource, e.g.: eg:someObject eg:firstPropertyKey "first property value" ; eg:secondPropertyKey "first loser" ; eg:andSoOn "and so on" .

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.

Sound
type: Class
subclass of: Vector
C type: LV2_Atom_Sound
documentation: An atom:Vector of atom:Float which represents an audio waveform. The format is the same as the buffer format for lv2:AudioPort (except the size may be arbitrary). An atom:Sound inherently depends on the sample rate, which is assumed to be known from context. Because of this, directly serialising an atom:Sound is probably a bad idea, use a standard format like WAV instead.

Frame time
type: Property
type: DatatypeProperty
type: FunctionalProperty
range: decimal
documentation: Time stamp in audio frames. Typically used for events.

Beat time
type: Property
type: DatatypeProperty
type: FunctionalProperty
range: decimal
documentation: Time stamp in beats. Typically used for events.

Event
type: Class
C type: LV2_Atom_Event
documentation: An atom with a time stamp prefix, 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. LV2_Atom_Sequence_Body.unit describes the time unit for the contained atoms. If the unit is known from context (e.g. run() stamps are always audio frames), this field may be zero. Otherwise, it SHOULD be either units:frame or units:beat, in which case ev.time.frames or ev.time.beats is valid, respectively. If serialised to RDF, a Sequence has a similar form to atom:Vector, but for brevity the elements may be assumed to be atom:Event, e.g.: eg:someSequence a atom:Sequence ; rdf:value ( [ atom:frameTime 1 ; rdf:value "901A01"^^midi:MidiEvent ] [ atom:frameTime 3 ; rdf:value "902B02"^^midi:MidiEvent ] ) .

Atom Port
type: Class
subclass of: Port
documentation: A port which contains an atom:Atom. Ports of this type are connected to an LV2_Atom with a type specified by atom:bufferType. Output ports with a variably sized type MUST be initialised by the host before every run() to an atom:Chunk with size set to the available space. The plugin reads this size to know how much space is available for writing. In all cases, the plugin MUST write a complete atom (including header) to outputs. However, to be robust, hosts SHOULD initialise output ports to a safe sentinel (e.g. the null Atom) before calling run().

Buffer type
type: Property
type: ObjectProperty
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:AtomPort ; atom:bufferType atom:Double ; ] . This property only describes the types a port may be directly connected to. It says nothing about the expected contents of containers. For that, use atom:supports.

Child type
type: Property
type: ObjectProperty
comment: The type of a container's children.

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 expected by a port. For example, a port that receives MIDI events is described like so: <plugin> lv2:port [ a lv2:InputPort , atom:AtomPort ; atom:bufferType atom:Sequence ; atom:supports midi:MidiEvent ; ] .

eventTransfer
type: PortProtocol
documentation: Transfer of individual events in a port buffer. Useful as the format for a LV2UI_Write_Function. 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.

atomTransfer
type: PortProtocol
documentation: Transfer of the complete atom in a port buffer. Useful as the format for a LV2UI_Write_Function. This protocol applies to atom ports. The host must transfer the complete atom contained in the port, including header.