aboutsummaryrefslogtreecommitdiffstats
path: root/lv2/lv2plug.in/ns/ext/atom/atom.ttl
blob: 1254d2d3e77e8b1716a922732638353b0cdede68 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
@prefix atom:  <http://lv2plug.in/ns/ext/atom#> .
@prefix lv2:   <http://lv2plug.in/ns/lv2core#> .
@prefix owl:   <http://www.w3.org/2002/07/owl#> .
@prefix rdf:   <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
@prefix rdfs:  <http://www.w3.org/2000/01/rdf-schema#> .
@prefix ui:    <http://lv2plug.in/ns/extensions/ui#> .
@prefix units: <http://lv2plug.in/ns/extensions/units#> .
@prefix xsd:   <http://www.w3.org/2001/XMLSchema#> .

<http://lv2plug.in/ns/ext/atom>
	a owl:Ontology ;
	rdfs:seeAlso <atom.h> ,
		<util.h> ,
		<forge.h> ,
		<lv2-atom.doap.ttl> ;
	lv2:documentation """
<p>This specification defines a generic container for data, called an
<q>Atom</q>, 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
<code>memcpy</code>), and is suitable for use in real-time code.</p>

<p>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.</p>

<p>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 <a
href="../event/event.html">LV2 event</a> extension.</p>

<p>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 <code>struct</code> type).  New binary formats are an
implementation burden which harms interoperabilty, and should only be defined
where absolutely necessary.</p>

<p>Implementing this extension requires a facility for mapping URIs to
integers, such as the <a href="../urid/urid.html">LV2 URID</a> extension.</p>

<h3>Serialisation</h3>

<p>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.</p>
""" .

atom:cType
	a rdf:Property ,
		owl:DatatypeProperty ,
		owl:FunctionalProperty ;
	rdfs:label "C type" ;
	rdfs:domain rdfs:Class ;
	rdfs:range lv2:Symbol ;
	rdfs:comment """
The identifier for a C type describing the binary representation of an Atom of
this type.
""" .

atom:stringType
	a rdf:Property ,
		owl:ObjectProperty ,
		owl:FunctionalProperty ;
	rdfs:label "string type" ;
	rdfs:domain rdfs:Class ;
	rdfs:range rdfs:Datatype ;
	lv2:documentation """
<p>The type to be used when representing an Atom of this type as a string
(e.g. in XML or RDF).  Typically an <a
href="http://www.w3.org/TR/xmlschema-2/">XML Schema Datatype</a> URI.</p>
""" .

atom:Atom
	a rdfs:Class ;
	rdfs:label "Atom" ;
	atom:cType "LV2_Atom" ;
	lv2:documentation """
<p>Abstract base class for all atoms.  An LV2_Atom has a 32-bit
<code>size</code> and <code>type</code> followed by a body of <code>size</code>
bytes.  Atoms MUST be 64-bit aligned.</p>

<p>All concrete Atom types (subclasses of this class) MUST define a precise
binary layout for their body.</p>

<p>The <code>type</code> field is the URI of an Atom type mapped to an integer.
Implementations SHOULD gracefully pass through, or ignore, atoms with unknown
types.</p>

<p>All atoms are POD by definition except references, which as a special case
have <code>type = 0</code>.  An Atom MUST NOT contain a Reference.  It is safe
to copy any non-reference Atom with a simple <code>memcpy</code>, even if the
implementation does not understand <code>type</code>.  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).</p>

<p>The atom with both <code>type</code> <em>and</em> <code>size</code> 0 is
<q>null</q>, which is not considered a Reference.</p>
""" .

atom:Chunk
	a rdfs:Class ;
	rdfs:subClassOf atom:Atom ;
	rdfs:label "Chunk of memory" ;
	atom:stringType xsd:base64Binary ;
	lv2:documentation """
<p>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.</p>

<p>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.:</p>

<pre class="turtle-code">
[] eg:someChunk "vu/erQ=="^^xsd:base64Binary .
</pre>
""" .

atom:Number
	a rdfs:Class ;
	rdfs:subClassOf atom:Atom ;
	rdfs:label "Number" .

atom:Int
	a rdfs:Class ;
	rdfs:subClassOf atom:Number ;
	rdfs:label "Signed 32-bit integer" ;
	atom:cType "LV2_Atom_Int" ;
	atom:stringType xsd:int .

atom:Long
	a rdfs:Class ;
	rdfs:subClassOf atom:Number ;
	rdfs:label "Signed 64-bit integer" ;
	atom:cType "LV2_Atom_Long" ;
	atom:stringType xsd:long .

atom:Float
	a rdfs:Class ;
	rdfs:subClassOf atom:Number ;
	rdfs:label "32-bit IEEE-754 floating point number" ;
	atom:cType "LV2_Atom_Float" ;
	atom:stringType xsd:float .

atom:Double
	a rdfs:Class ;
	rdfs:subClassOf atom:Number ;
	rdfs:label "64-bit IEEE-754 floating point number" ;
	atom:cType "LV2_Atom_Double" ;
	atom:stringType xsd:double .

atom:Bool
	a rdfs:Class ;
	rdfs:subClassOf atom:Atom ;
	rdfs:label "Boolean" ;
	atom:cType "LV2_Atom_Bool" ;
	atom:stringType xsd:boolean ;
	rdfs:comment "An Int where 0 is false and any other value is true." .

atom:String
	a rdfs:Class ;
	rdfs:subClassOf atom:Atom ;
	rdfs:label "String" ;
	atom:cType "LV2_Atom_String" ;
	atom:stringType xsd:string ;
	lv2:documentation """
<p>A UTF-8 encoded string.</p>

<p>The body of an LV2_Atom_String is a C string in UTF-8 encoding, i.e. an
array of bytes (<code>uint8_t</code>) terminated with a NULL byte
(<code>'\\0'</code>).</p>

<p>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.</p>
""" .

atom:Literal
	a rdfs:Class ;
	rdfs:subClassOf atom:Atom ;
	rdfs:label "String Literal" ;
	atom:cType "LV2_Atom_Literal" ;
	lv2:documentation """
<p>A UTF-8 encoded string literal, with an optional datatype or language.</p>

<p>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
<code>datatype</code> and <code>lang</code> followed by string data in UTF-8
encoding.  The length of the string data in bytes is <code>size -
sizeof(LV2_Atom_Literal)</code>, including the terminating NULL character.  The
<code>lang</code> field SHOULD be a URI of the form
&lt;http://lexvo.org/id/iso639-3/LANG&gt; or
&lt;http://lexvo.org/id/iso639-1/LANG&gt; where LANG is a 3-character ISO 693-3
language code, or a 2-character ISO 693-1 language code, respectively.</p>

<p>A Literal may have a <code>datatype</code> OR a <code>lang</code>, but never
both.</p>

<p>For example, a Literal can be "Hello" in English:</p>
<pre class="c-code">
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
}
</pre>

<p>or a Turtle string:</p>
<pre class="c-code">
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
}
</pre>
""" .

atom:Path
	a rdfs:Class ;
	rdfs:subClassOf atom:String ;
	rdfs:label "File path string" ;
	lv2:documentation """
<p>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.</p>
""" .

atom:URI
	a rdfs:Class ;
	rdfs:subClassOf atom:String ;
	rdfs:label "URI string" ;
	atom:stringType xsd:anyURI ;
	lv2:documentation """
<p>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.</p>

<p>This is not strictly a URI, since UTF-8 is allowed.  Escaping and related
issues are the host's responsibility.</p>
""" .

atom:URID
	a rdfs:Class ;
	rdfs:subClassOf atom:Atom ;
	rdfs:label "Integer ID mapped from a URI" ;
	atom:cType "LV2_Atom_URID" ;
	lv2:documentation """
<p>An unsigned 32-bit integer mapped from a URI (e.g. with LV2_URID_Map).</p>
""" .

atom:Vector
	a rdfs:Class ;
	rdfs:subClassOf atom:Atom ;
	rdfs:label "Vector" ;
	atom:cType "LV2_Atom_Vector" ;
	lv2:documentation """
<p>A homogeneous series of atom bodies with equivalent type and size.</p>

<p>An LV2_Atom_Vector is a 32-bit <code>child_size</code> and
<code>child_type</code> followed by <code>size / child_size</code> atom
bodies.</p>

<p>For example, an atom:Vector containing 42 elements of type atom:Float:</p>
<pre class="c-code">
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];
};
</pre>

<p>Note that it is possible to construct a valid Atom for each element
of the vector, even by an implementation which does not understand
<code>child_type</code>.</p>

<p>If serialised to RDF, a Vector SHOULD have the form:</p>

<pre class="turtle-code">
eg:someVector
     a atom:Vector ;
     atom:childType atom:Int ;
     rdf:value (
         "1"^^xsd:int
         "2"^^xsd:int
         "3"^^xsd:int
         "4"^^xsd:int
     ) .
</pre>
""" .

atom:Tuple
	a rdfs:Class ;
	rdfs:subClassOf atom:Atom ;
	rdfs:label "Tuple" ;
	lv2:documentation """
<p>A series of Atoms with varying <code>type</code> and <code>size</code>.</p>

<p>The body of a Tuple is simply a series of complete atoms, each aligned to
64 bits.</p>

<p>If serialised to RDF, a Tuple SHOULD have the form:</p>

<pre class="turtle-code">
eg:someVector
     a atom:Tuple ;
     rdf:value (
         "1"^^xsd:int
         "3.5"^^xsd:float
         "etc"
     ) .
</pre>

""" .

atom:Property
	a rdfs:Class ;
	rdfs:subClassOf atom:Atom ;
	rdfs:label "Property" ;
	atom:cType "LV2_Atom_Property" ;
	lv2:documentation """
<p>A property of an atom:Object.  An LV2_Atom_Property has a URID
<code>key</code> and <code>context</code>, and an Atom <code>value</code>.
This corresponds to an RDF Property, where the <q>key</q> is the <q>predicate</q>
and the <q>value</q> is the object.</p>

<p>The <code>context</code> field can be used to specify a different context
for each property, where this is useful.  Otherwise, it may be 0.</p>

<p>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.:</p>

<pre class="turtle-code">
eg:someProperty
    rdf:predicate eg:theKey ;
    rdf:object eg:theValue .
</pre>
""" .

atom:Object
	a rdfs:Class ;
	rdfs:subClassOf atom:Atom ;
	rdfs:label "Object" ;
	atom:cType "LV2_Atom_Object" ;
	lv2:documentation """
<p>An <q>Object</q> 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.</p>

<p>An LV2_Atom_Object has a uint32_t <code>id</code> and uint32_t
<code>type</code>, 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.</p>

<p>This is an abstract Atom type, an Object is always either a atom:Resource
or a atom:Blank.</p>

<p>If serialised to RDF, an Object SHOULD be represented directly as a
resource, e.g.:</p>

<pre class="turtle-code">
eg:someObject
    eg:firstPropertyKey "first property value" ;
    eg:secondPropertyKey "first loser" ;
    eg:andSoOn "and so on" .
</pre>
""" .

atom:Resource
	a rdfs:Class ;
	rdfs:subClassOf atom:Object ;
	rdfs:label "Resource" ;
	atom:cType "LV2_Atom_Object" ;
	lv2:documentation """
<p>An atom:Object where the <code>id</code> field is a URID, i.e. an Object
with a URI.</p>
""" .

atom:Blank
	a rdfs:Class ;
	rdfs:subClassOf atom:Object ;
	rdfs:label "Blank" ;
	atom:cType "LV2_Atom_Object" ;
	lv2:documentation """
<p>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.</p>
""" .

atom:Sound
	a rdfs:Class ;
	rdfs:subClassOf atom:Vector ;
	rdfs:label "Sound" ;
	atom:cType "LV2_Atom_Sound" ;
	lv2:documentation """
<p>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.</p>
""" .

atom:frameTime
	a rdf:Property ,
		owl:DatatypeProperty ,
		owl:FunctionalProperty ;
	rdfs:range xsd:decimal ;
	rdfs:label "Frame time" ;
	lv2:documentation """
<p>Time stamp in audio frames.  Typically used for events.</p>
""" .

atom:beatTime
	a rdf:Property ,
		owl:DatatypeProperty ,
		owl:FunctionalProperty ;
	rdfs:range xsd:decimal ;
	rdfs:label "Beat time" ;
	lv2:documentation """
<p>Time stamp in beats.  Typically used for events.</p>
""" .

atom:Event
	a rdfs:Class ;
	rdfs:label "Event" ;
	atom:cType "LV2_Atom_Event" ;
	lv2:documentation """
<p>An atom with a time stamp prefix, typically an element of an atom:Sequence.
Note this is not an Atom type.</p>
""" .

atom:Sequence
	a rdfs:Class ;
	rdfs:subClassOf atom:Atom ;
	rdfs:label "Sequence" ;
	atom:cType "LV2_Atom_Sequence" ;
	lv2:documentation """
<p>A sequence of atom:Event, i.e. a series of time-stamped Atoms.</p>

<p>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.</p>

<p>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.:</p>

<pre class="turtle-code">
eg:someSequence
    a atom:Sequence ;
    rdf:value (
        [
            atom:frameTime 1 ;
            rdf:value "901A01"^^midi:MidiEvent
        ] [
            atom:frameTime 3 ;
            rdf:value "902B02"^^midi:MidiEvent
        ]
    ) .
</pre>
""" .

atom:AtomPort
	a rdfs:Class ;
	rdfs:subClassOf lv2:Port ;
	rdfs:label "Atom Port" ;
	lv2:documentation """
<p>A port which contains an atom:Atom.  Ports of this type are connected to an
LV2_Atom with a type specified by atom:bufferType.</p>

<p>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().</p>
""" .

atom:bufferType
	a rdf:Property ,
		owl:ObjectProperty ;
	rdfs:domain atom:AtomPort ;
	rdfs:label "buffer type" ;
	lv2:documentation """
<p>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:</p>

<pre class="turtle-code">
&lt;plugin&gt;
    lv2:port [
        a lv2:InputPort , atom:AtomPort ;
        atom:bufferType atom:Double ;
    ] .
</pre>

<p>This property only describes the types a port may be <em>directly</em>
connected to.  It says nothing about the expected contents of containers.  For
that, use atom:supports.</p>
""" .

atom:childType
	a rdf:Property ,
		owl:ObjectProperty ;
	rdfs:label "child type" ;
	rdfs:comment "The type of a container's children." .

atom:supports
	a rdf:Property ;
	rdfs:label "supports" ;
	lv2:documentation """
<p>Indicates that a particular Atom type is supported.</p>

<p>This property is defined loosely, it may be used to indicate that anything
<q>supports</q> an Atom type, wherever that may be useful.  It applies
<q>recursively</q> where collections are involved.</p>

<p>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:</p>

<pre class="turtle-code">
&lt;plugin&gt;
    lv2:port [
        a lv2:InputPort , atom:AtomPort ;
        atom:bufferType atom:Sequence ;
        atom:supports midi:MidiEvent ;
    ] .
</pre>
""" .

atom:eventTransfer
	a ui:PortProtocol ;
	rdfs:label "event transfer" ;
	lv2:documentation """
<p>Transfer of individual events in a port buffer.  Useful as the
<code>format</code> for a LV2UI_Write_Function.</p>

<p>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.</p>
""" .

atom:atomTransfer
	a ui:PortProtocol ;
	rdfs:label "atom transfer" ;
	lv2:documentation """
<p>Transfer of the complete atom in a port buffer.  Useful as the
<code>format</code> for a LV2UI_Write_Function.</p>

<p>This protocol applies to atom ports.  The host must transfer the complete
atom contained in the port, including header.</p>
""" .