at.atmosynth.patch
Schema Diff
+5 -0
Compatibility Analysis
Backward Compatible
Backward compatible. 2 non-breaking changes.
Non-Breaking Changes (2)
- AddedVertex AddedVertex { vertex_id: "at.atmosynth.patch:body.concertPitch" }
- AddedEdge AddedEdge { src: "at.atmosynth.patch:body", tgt: "at.atmosynth.patch:body.concertPitch", kind: "prop", name: Some("concertPitch") }
Migration Guidance
Added Elements
AddedVertex { vertex_id: "at.atmosynth.patch:body.concertPitch" }
Additional Notes
- Non-breaking: AddedEdge { src: "at.atmosynth.patch:body", tgt: "at.atmosynth.patch:body.concertPitch", kind: "prop", name: Some("concertPitch") }
1
1
{
2
2
"$type": "com.atproto.lexicon.schema",
3
3
"defs": {
4
4
"alternatePattern": {
5
5
"description": "One of the loops after the first on a sequencer. It has its own length and its own notes, and shares the grid written beside the first.",
6
6
"properties": {
7
7
"bars": {
8
8
"description": "How long this loop is, in bars of the patch's time signature.",
9
9
"maximum": 8,
10
10
"minimum": 1,
11
11
"type": "integer"
12
12
},
13
13
"events": {
14
14
"description": "The notes in this loop.",
15
15
"items": {
16
16
"ref": "#noteEvent",
17
17
"type": "ref"
18
18
},
19
19
"maxLength": 2048,
20
20
"type": "array"
21
21
},
22
22
"name": {
23
23
"description": "What the creator called this loop. Optional permanently: a loop that says nothing is called by its place.",
24
24
"maxGraphemes": 32,
25
25
"maxLength": 320,
26
26
"minLength": 1,
27
27
"type": "string"
28
28
}
29
29
},
30
30
"required": [
31
31
"bars"
32
32
],
33
33
"type": "object"
34
34
},
35
35
"connection": {
36
36
"description": "An audio connection between two module instances, naming the declared ports at each end.",
37
37
"properties": {
38
38
"from": {
39
39
"ref": "#outputRef",
40
40
"type": "ref"
41
41
},
42
42
"to": {
43
43
"ref": "#inputRef",
44
44
"type": "ref"
45
45
}
46
46
},
47
47
"required": [
48
48
"from",
49
49
"to"
50
50
],
51
51
"type": "object"
52
52
},
53
53
"glide": {
54
54
"description": "How one sequencer's notes slide into one another. Its presence is the switch: an instance carrying it slides, and one carrying nothing does not. The speed is written one of two ways, and which field is present says which — a duration, or a note value at the player's tempo, so a slide that is a sixteenth long stays a sixteenth when the song is played faster. A slide moves one note to the next, so a loop with a glide plays one note at a time.",
55
55
"properties": {
56
56
"fromLast": {
57
57
"description": "Whether a note struck after a rest slides in from the note before it. Absent is yes, so every note of the loop slides; false is fingered portamento, where only a note held over the next one slides into it and a note after a rest starts where it means to.",
58
58
"type": "boolean"
59
59
},
60
60
"ms": {
61
61
"description": "How long a note takes to reach the next, in milliseconds.",
62
62
"maximum": 5000,
63
63
"minimum": 1,
64
64
"type": "integer"
65
65
},
66
66
"rate": {
67
67
"description": "Or: how long, as a note value at the tempo. The same vocabulary the grid is written in.",
68
68
"knownValues": [
69
69
"bar",
70
70
"1/2",
71
71
"1/4",
72
72
"1/8",
73
73
"1/16",
74
74
"1/32",
75
75
"1/64",
76
76
"1/128"
77
77
],
78
78
"type": "string"
79
79
}
80
80
},
81
81
"type": "object"
82
82
},
83
83
"inputRef": {
84
84
"properties": {
85
85
"audioInput": {
86
86
"maxLength": 64,
87
87
"minLength": 1,
88
88
"type": "string"
89
89
},
90
90
"instanceId": {
91
91
"maxLength": 64,
92
92
"minLength": 1,
93
93
"type": "string"
94
94
}
95
95
},
96
96
"required": [
97
97
"instanceId",
98
98
"audioInput"
99
99
],
100
100
"type": "object"
101
101
},
102
102
"inputRoute": {
103
103
"description": "One note source wired into the input of a sequencer or a note range. Notes arriving at a sequencer's are what it records, and what it passes on to the instances it plays unless its instance says `thru: false`; notes arriving at a note range's are passed on where they fall inside its range.",
104
104
"properties": {
105
105
"from": {
106
106
"description": "The note output these notes leave: a keyboard's, a sequencer's or a note range's.",
107
107
"ref": "#noteOutputRef",
108
108
"type": "ref"
109
109
},
110
110
"instanceId": {
111
111
"description": "The sequencer or the note range, at its input.",
112
112
"maxLength": 64,
113
113
"minLength": 1,
114
114
"type": "string"
115
115
}
116
116
},
117
117
"required": [
118
118
"from",
119
119
"instanceId"
120
120
],
121
121
"type": "object"
122
122
},
123
123
"lane": {
124
124
"description": "One automation lane: a line drawn over a whole number of bars, counted from the downbeat the loops share and going round at its own length, so a point in bar 3 of a four-bar lane is heard in bar 3 of every four.",
125
125
"properties": {
126
126
"bars": {
127
127
"description": "How long this lane is, in bars of the patch's time signature.",
128
128
"maximum": 64,
129
129
"minimum": 1,
130
130
"type": "integer"
131
131
},
132
132
"name": {
133
133
"description": "What the creator called this lane. Optional permanently: a lane that says nothing is called by its place.",
134
134
"maxGraphemes": 32,
135
135
"maxLength": 320,
136
136
"minLength": 1,
137
137
"type": "string"
138
138
},
139
139
"points": {
140
140
"description": "The points, in order of `at`, one to a tick. Before the first point the lane is at the first point's value and after the last at the last's; a lane with no points is at nothing.",
141
141
"items": {
142
142
"ref": "#lanePoint",
143
143
"type": "ref"
144
144
},
145
145
"maxLength": 512,
146
146
"type": "array"
147
147
},
148
148
"resolution": {
149
149
"description": "The grid this lane's points are drawn and snapped to. It is a guide and not a part of what is played: changing it moves no point already written. Optional permanently: absent is sixteenths.",
150
150
"ref": "#resolution",
151
151
"type": "ref"
152
152
}
153
153
},
154
154
"required": [
155
155
"bars"
156
156
],
157
157
"type": "object"
158
158
},
159
159
"lanePoint": {
160
160
"description": "One point of an automation lane: a value at a moment.",
161
161
"properties": {
162
162
"at": {
163
163
"description": "The tick of the lane this point is at, counted from its start at 96 ticks to the beat, and less than the lane's length.",
164
164
"minimum": 0,
165
165
"type": "integer"
166
166
},
167
167
"hold": {
168
168
"description": "Whether the value is held until the next point, which is jumped to, rather than travelled to in a straight line. Optional permanently: absent is a straight line, and only `true` is written.",
169
169
"type": "boolean"
170
170
},
171
171
"value": {
172
172
"description": "The value here, a number from 0 to 1 written as its decimal text, as every number in this description that need not be whole is.",
173
173
"type": "string"
174
174
}
175
175
},
176
176
"required": [
177
177
"at",
178
178
"value"
179
179
],
180
180
"type": "object"
181
181
},
182
182
"lineage": {
183
183
"description": "The patch this one was forked from, and its creator. Preserved even when the source is later deleted.",
184
184
"properties": {
185
185
"creatorDid": {
186
186
"format": "did",
187
187
"type": "string"
188
188
},
189
189
"patchId": {
190
190
"maxLength": 128,
191
191
"type": "string"
192
192
},
193
193
"uri": {
194
194
"format": "at-uri",
195
195
"type": "string"
196
196
}
197
197
},
198
198
"required": [
199
199
"uri",
200
200
"creatorDid"
201
201
],
202
202
"type": "object"
203
203
},
204
204
"main": {
205
205
"description": "A patch, held in its creator's own repository.",
206
206
"key": "tid",
207
207
"record": {
208
208
"properties": {
209
+
"concertPitch": {
210
+
"description": "The frequency A4 sounds at in this patch, in hertz, from 380 to 500, written as its decimal text — \"432\", \"415.3\" — as every number in this description that need not be whole is. Every note's frequency is tuned against it, which is what an oscillator a module does not drive itself and a module's note signal play at. A sample is not retuned: its own reference pitch is a note rather than a frequency, and it plays as recorded. Optional permanently: a patch that says nothing is tuned to 440, which is what every patch written before the field existed says.",
211
+
"maxLength": 32,
212
+
"type": "string"
213
+
},
209
214
"connections": {
210
215
"items": {
211
216
"ref": "#connection",
212
217
"type": "ref"
213
218
},
214
219
"type": "array"
215
220
},
216
221
"createdAt": {
217
222
"format": "datetime",
218
223
"type": "string"
219
224
},
220
225
"description": {
221
226
"maxLength": 3000,
222
227
"type": "string"
223
228
},
224
229
"descriptionVersion": {
225
230
"description": "Version of the patch description this record follows.",
226
231
"minimum": 1,
227
232
"type": "integer"
228
233
},
229
234
"forkedFrom": {
230
235
"ref": "#lineage",
231
236
"type": "ref"
232
237
},
233
238
"inputRouting": {
234
239
"description": "What reaches the input of each sequencer, each note range, each transpose, each pitch assignment and each one-shot: which note sources a sequencer hears, to record from and — unless it says otherwise (`thru`) — to pass on to whatever it plays; which a note range hears, to pass on what falls inside its range (`noteRange`); which a transpose or a pitch assignment hears, to pass on at another pitch (`transpose`, `assignedNote`); and which a one-shot hears, to pass on lasting one length (`noteLength`). A sequencer with nothing wired here records nothing, and the others pass nothing on. Optional permanently: a patch that says nothing has nothing wired into any of them, which is what every patch written before the input existed says.",
235
240
"items": {
236
241
"ref": "#inputRoute",
237
242
"type": "ref"
238
243
},
239
244
"type": "array"
240
245
},
241
246
"midiRouting": {
242
247
"description": "The note plane: which note inputs receive note events, and from which note source — a sequencer, or the player's keys and MIDI devices. \"MIDI\" is the historical name; what travels here is notes, whatever produced them.",
243
248
"items": {
244
249
"ref": "#midiRoute",
245
250
"type": "ref"
246
251
},
247
252
"type": "array"
248
253
},
249
254
"moduleInstances": {
250
255
"items": {
251
256
"ref": "#moduleInstance",
252
257
"type": "ref"
253
258
},
254
259
"type": "array"
255
260
},
256
261
"name": {
257
262
"maxLength": 200,
258
263
"minLength": 1,
259
264
"type": "string"
260
265
},
261
266
"output": {
262
267
"description": "Which instance reaches the audio output.",
263
268
"ref": "#outputRef",
264
269
"type": "ref"
265
270
},
266
271
"patternRouting": {
267
272
"description": "The song plane: which sequencers and automation blocks each arranger or scenes block chooses the loops or lanes of. A sequencer or an automation block has one pattern input, so it appears here at most once. Optional permanently: a patch that says nothing has no arranger in it, and every sequencer plays the loop it names as active and every automation block the lane.",
268
273
"items": {
269
274
"ref": "#patternRoute",
270
275
"type": "ref"
271
276
},
272
277
"type": "array"
273
278
},
274
279
"tags": {
275
280
"description": "Freely created tags, lower-cased on write so one hashtag matches one set of patches.",
276
281
"items": {
277
282
"maxLength": 128,
278
283
"type": "string"
279
284
},
280
285
"type": "array"
281
286
},
282
287
"tempo": {
283
288
"description": "The tempo this patch was written at, in beats per minute, a beat being a quarter note whatever the time signature says. It is what a sequenced patch counts its bars against, so a patch that plays itself arrives at the speed its creator meant. It seeds the player's own tempo rather than replacing it: how fast a visitor plays is still theirs, and moving it moves everything counting against it. Optional permanently — a patch that says nothing is played at whatever tempo the player already had.",
284
289
"maximum": 300,
285
290
"minimum": 20,
286
291
"type": "integer"
287
292
},
288
293
"timeSignature": {
289
294
"description": "How many of which note one bar of this patch is. Every length here counted in bars — a loop, a section, an automation lane — is counted in this bar, so a loop of four bars is twelve beats in 3/4. Optional permanently: a patch that says nothing is in 4/4, which is what every patch written before the field existed says.",
290
295
"ref": "#timeSignature",
291
296
"type": "ref"
292
297
},
293
298
"types": {
294
299
"description": "Zero or more of the ten fixed types. A patch may carry several.",
295
300
"items": {
296
301
"knownValues": [
297
302
"Lead",
298
303
"Pad",
299
304
"Bass",
300
305
"Plucked",
301
306
"Percussion",
302
307
"Keys",
303
308
"Brass",
304
309
"Strings",
305
310
"Vocal",
306
311
"SFX"
307
312
],
308
313
"type": "string"
309
314
},
310
315
"type": "array"
311
316
}
312
317
},
313
318
"required": [
314
319
"descriptionVersion",
315
320
"name",
316
321
"description",
317
322
"moduleInstances",
318
323
"createdAt"
319
324
],
320
325
"type": "object"
321
326
},
322
327
"type": "record"
323
328
},
324
329
"midiControl": {
325
330
"description": "One MIDI control change bound to one of the module's exposed parameters. The controller's 0 to 127 sweeps the parameter across the range the module declares — along the parameter's scale, so a logarithmic one moves by equal ratios — or across the part of it this binding names with from and to; where the module declares a closed value set instead, it sweeps across those values in order. A control is read from every input on every channel, like every other MIDI message here: there is nothing to configure.",
326
331
"properties": {
327
332
"controller": {
328
333
"description": "The control change number. Five are spoken for by MIDI itself and cannot be bound: 64, the sustain pedal, and 6, 38, 100 and 101, which carry registered-parameter traffic.",
329
334
"maximum": 127,
330
335
"minimum": 0,
331
336
"type": "integer"
332
337
},
333
338
"from": {
334
339
"description": "The value the control reaches at 0, in the parameter's own units and as its decimal form. Given with to or not at all; neither is the parameter's whole declared range. A value outside that range is read as the nearer end of it.",
335
340
"maxLength": 200,
336
341
"type": "string"
337
342
},
338
343
"parameter": {
339
344
"description": "The id of the exposed parameter this control moves. One parameter is moved by at most one controller; one controller may move several parameters.",
340
345
"maxLength": 64,
341
346
"minLength": 1,
342
347
"type": "string"
343
348
},
344
349
"to": {
345
350
"description": "The value the control reaches at 127, as from is at 0. It may be below from, which is a control that turns the parameter down as it is turned up.",
346
351
"maxLength": 200,
347
352
"type": "string"
348
353
}
349
354
},
350
355
"required": [
351
356
"parameter",
352
357
"controller"
353
358
],
354
359
"type": "object"
355
360
},
356
361
"midiRoute": {
357
362
"description": "Where one instance's notes come from. `instanceId` and `midiInput` name the note input they arrive at; `from` names the note output they leave. \"MIDI\" in these names is historical: a route carries note events from any note source, a sequencer as much as a MIDI device. **A route with no `from` comes from the player** — the on-screen keys, the computer keyboard and every MIDI device at once — which is what every route written before note sources existed says, and what it goes on saying.",
358
363
"properties": {
359
364
"from": {
360
365
"description": "The note output these notes leave. Absent where they come from the player.",
361
366
"ref": "#noteOutputRef",
362
367
"type": "ref"
363
368
},
364
369
"instanceId": {
365
370
"maxLength": 64,
366
371
"minLength": 1,
367
372
"type": "string"
368
373
},
369
374
"midiInput": {
370
375
"description": "The note input, one of the module's `midiInputs`, these notes arrive at. It receives note events from any note source; \"MIDI\" is the historical name.",
371
376
"maxLength": 64,
372
377
"minLength": 1,
373
378
"type": "string"
374
379
}
375
380
},
376
381
"required": [
377
382
"instanceId",
378
383
"midiInput"
379
384
],
380
385
"type": "object"
381
386
},
382
387
"moduleInstance": {
383
388
"description": "One use of one module version. A patch may use the same module more than once; each instance is separately addressable and carries its own parameter values and slot fills.",
384
389
"properties": {
385
390
"assignedNote": {
386
391
"description": "The one note this instance passes every note on at, whichever note arrived, where its module is a pitch assignment: a MIDI note number (60 is middle C). Only the pitch changes: each note still starts and stops when it did, at the strength it was played with. It lives here, in the patch, for the reason a note range does: which pitch a pad plays its sound at is a decision about this use of the module. Absent on every instance whose module is not a pitch assignment, and on one that passes every note at its own pitch.",
387
392
"maximum": 127,
388
393
"minimum": 0,
389
394
"type": "integer"
390
395
},
391
396
"enabled": {
392
397
"description": "Whether this instance does its work. An instance that is switched off makes no sound of its own, and anything reaching its audio inputs leaves its audio outputs unaltered. Optional permanently: an instance that says nothing is on, which is what every record written before this field existed says.",
393
398
"type": "boolean"
394
399
},
395
400
"glide": {
396
401
"description": "Whether the notes this instance plays slide into one another, and how. It lives here, in the patch, beside the unison and for the unison's reason: how a line slides is a decision about this use of the module, and forks with the patch. The player's own glide is a setting of their browser and says nothing about this one, so a loop written to slide slides for everyone who opens the patch, and a loop that does not is never made monophonic by the player's. Optional permanently: an instance that says nothing has no glide, which is what every record written before this field existed says.",
397
402
"ref": "#glide",
398
403
"type": "ref"
399
404
},
400
405
"instanceId": {
401
406
"maxLength": 64,
402
407
"minLength": 1,
403
408
"type": "string"
404
409
},
405
410
"lane": {
406
411
"description": "Which of `lanes` plays, counting the first as zero. Choosing a lane is an edit like choosing a sequencer's loop, so it is written here, and the patch opens on it. Optional permanently: absent is the first, and a reader plays one past the last as the last.",
407
412
"maximum": 7,
408
413
"minimum": 0,
409
414
"type": "integer"
410
415
},
411
416
"lanes": {
412
417
"description": "The automation lanes this instance holds, where its module is an automation block: each a whole number of bars of values from nothing to one, played in time with the loops. One plays at a time, as one of a sequencer's loops does, and an arranger or a scenes block wired to the block's pattern input chooses which. It lives here, in the patch, for the reason a pattern does: what is played is a decision about this use of the module. Absent on every instance whose module is not an automation block.",
413
418
"items": {
414
419
"ref": "#lane",
415
420
"type": "ref"
416
421
},
417
422
"maxLength": 8,
418
423
"type": "array"
419
424
},
420
425
"midiControls": {
421
426
"description": "Which MIDI control changes move this instance's parameters while it is played. A binding lives here, in the patch, because which knob moves what is a decision about this use of the module and not about the module.",
422
427
"items": {
423
428
"ref": "#midiControl",
424
429
"type": "ref"
425
430
},
426
431
"type": "array"
427
432
},
428
433
"module": {
429
434
"ref": "#moduleRef",
430
435
"type": "ref"
431
436
},
432
437
"name": {
433
438
"description": "What the creator called this instance, so that two uses of one module — a sequencer playing the bass beside one playing the chords — are told apart by what each does. It lives here, in the patch, because what a use of a module is for is a decision about this use and not about the module. Optional permanently: an instance that says nothing is called by its module's name, which is what every record written before an instance could be named says.",
434
439
"maxGraphemes": 32,
435
440
"maxLength": 320,
436
441
"minLength": 1,
437
442
"type": "string"
438
443
},
439
444
"noteLength": {
440
445
"description": "How many milliseconds every note this instance passes on lasts, where its module is a one-shot, however briefly or long whatever played it held it: a pad tapped in front of a drum plays the drum's whole hit. When the length is up the note is let go of and its sound follows its own release. Only how long a note lasts changes: each still starts when it was struck, at its own pitch and the strength it was played with. It lives here, in the patch, for the reason a note range does. Absent on every instance whose module is not a one-shot; on a one-shot, absent is 100 milliseconds.",
441
446
"maximum": 10000,
442
447
"minimum": 1,
443
448
"type": "integer"
444
449
},
445
450
"notePattern": {
446
451
"description": "The pattern this instance loops, where its module is a sequencer. It lives here, in the patch, for the reason a sample slot fill and a control binding do: what is played is a decision about this use of the module, and writing one never touches the module's record. Absent on every instance whose module is not a sequencer.",
447
452
"ref": "#notePattern",
448
453
"type": "ref"
449
454
},
450
455
"noteRange": {
451
456
"description": "Which notes this instance passes on, where its module is a note range. It lives here, in the patch, for the reason a pattern does: which pad or which half of a keyboard plays which sound is a decision about this use of the module, and forks with the patch. Absent on every instance whose module is not a note range, and on one that passes every note.",
452
457
"ref": "#noteRange",
453
458
"type": "ref"
454
459
},
455
460
"parameterValues": {
456
461
"items": {
457
462
"ref": "#parameterValue",
458
463
"type": "ref"
459
464
},
460
465
"type": "array"
461
466
},
462
467
"position": {
463
468
"description": "Where the creator placed this instance in the patch's arrangement, so the arrangement travels with the patch and a fork inherits it. Optional permanently, and the only field in either description that exists for presentation.",
464
469
"ref": "#position",
465
470
"type": "ref"
466
471
},
467
472
"sampleSlotFills": {
468
473
"description": "Samples this instance supplies for the module's declared slots. A fill lives here, in the patch, so writing one never touches the module.",
469
474
"items": {
470
475
"ref": "#sampleSlotFill",
471
476
"type": "ref"
472
477
},
473
478
"type": "array"
474
479
},
475
480
"scene": {
476
481
"description": "Which of `scenes` is playing, counting the first as zero. Choosing a scene is an edit like choosing a sequencer's loop, so it is written here, and the patch opens on it. Optional permanently: absent is the first, and a reader plays one past the last as the last.",
477
482
"maximum": 25,
478
483
"minimum": 0,
479
484
"type": "integer"
480
485
},
481
486
"sceneLaunch": {
482
487
"description": "When a scene chosen on this instance takes over, and where the loops it names start. Optional permanently: absent is on the next bar, from their first step.",
483
488
"ref": "#sceneLaunch",
484
489
"type": "ref"
485
490
},
486
491
"scenes": {
487
492
"description": "The scenes this instance switches between, where its module is a scenes block: which loop each sequencer wired to it plays in each. It lives here for the reason a song does. Absent on every instance whose module is not a scenes block.",
488
493
"items": {
489
494
"ref": "#scene",
490
495
"type": "ref"
491
496
},
492
497
"maxLength": 26,
493
498
"type": "array"
494
499
},
495
500
"song": {
496
501
"description": "The song this instance plays, where its module is an arranger: which loop each sequencer wired to it plays, section by section. It lives here, in the patch, for the reason a pattern does: what is played is a decision about this use of the module. Absent on every instance whose module is not an arranger.",
497
502
"ref": "#song",
498
503
"type": "ref"
499
504
},
500
505
"thru": {
501
506
"description": "Whether the notes reaching this instance's input are passed on to whatever it plays, where its module is a sequencer: a keyboard wired into it is then heard through it as well as recorded by it. It lives here, in the patch, because what a sequencer passes on is part of how the patch sounds. Optional permanently: an instance that says nothing passes them on, and only `false` is ever written.",
502
507
"type": "boolean"
503
508
},
504
509
"transpose": {
505
510
"description": "How many semitones this instance moves every note it passes on, where its module is a transpose: twelve is an octave up, and a negative number is down. A note moved past the lowest or the highest MIDI note is not passed on. It lives here, in the patch, for the reason a note range does. Absent on every instance whose module is not a transpose, and on one that moves nothing.",
506
511
"maximum": 127,
507
512
"minimum": -127,
508
513
"type": "integer"
509
514
},
510
515
"unison": {
511
516
"description": "How many voices each note this instance plays is sounded by, detuned narrowly against each other and centred on the note. It lives here, in the patch, for the reason the pattern above it does: how a loop is voiced is a decision about this use of the module. The player's own unison is a setting of their browser and says nothing about this one, so a loop written thick stays thick for everyone who opens the patch. Optional permanently: an instance that says nothing plays one voice per note, which is what every record written before this field existed says.",
512
517
"maximum": 6,
513
518
"minimum": 1,
514
519
"type": "integer"
515
520
},
516
521
"voiceScope": {
517
522
"description": "Whether this instance is built once for each sounding note or once for the whole patch. One of the two, always: the choice is made when the module is added, from what the module is, and is the creator's to move afterwards. There is no third value and no leaving it out — an instance that said nothing left the answer to be worked out afresh every time the patch was played, which is a decision nobody could see and nobody could change.",
518
523
"enum": [
519
524
"perNote",
520
525
"perPatch"
521
526
],
522
527
"type": "string"
523
528
}
524
529
},
525
530
"required": [
526
531
"instanceId",
527
532
"module",
528
533
"voiceScope"
529
534
],
530
535
"type": "object"
531
536
},
532
537
"moduleRef": {
533
538
"description": "A pin to one exact published version of a module. Resolving it fetches that record, whoever authored it.",
534
539
"properties": {
535
540
"authorDid": {
536
541
"format": "did",
537
542
"type": "string"
538
543
},
539
544
"moduleId": {
540
545
"maxLength": 128,
541
546
"minLength": 1,
542
547
"type": "string"
543
548
},
544
549
"versionKey": {
545
550
"description": "The pinned version's record key, which is also the `versionKey` that version carries. A reader fetches the module record at this key.",
546
551
"maxLength": 128,
547
552
"minLength": 1,
548
553
"type": "string"
549
554
}
550
555
},
551
556
"required": [
552
557
"moduleId",
553
558
"versionKey",
554
559
"authorDid"
555
560
],
556
561
"type": "object"
557
562
},
558
563
"noteEvent": {
559
564
"description": "One note struck at one moment of the loop, held from it, and struck as hard and as often as it says. It is written one of two ways: a note written now says the tick it is at and how many ticks it is held for, and a note written while the grid was part of what a note was says the step of that grid and how many of those steps it was held for. Both are read; the first is written.",
560
565
"properties": {
561
566
"at": {
562
567
"description": "The tick of the loop this note is struck at, counted from its start at 96 ticks to the beat. Ticks rather than steps of the grid, because a note is at a moment and the grid is a guide over it: 96 is divided exactly by every grid this description offers, so a note keeps its moment however the grid is changed.",
563
568
"minimum": 0,
564
569
"type": "integer"
565
570
},
566
571
"hold": {
567
572
"description": "How many ticks this note is held for. Counted in ticks rather than in seconds for the reason the start is: a phrase written at 90 is the same phrase, held notes and all, at 140. A note is cut off by the loop's end and by the next note of its own pitch, since the same pitch overlapping itself is one voice rather than two.",
568
573
"minimum": 1,
569
574
"type": "integer"
570
575
},
571
576
"length": {
572
577
"description": "How many steps of the grid this note is held for, where its start is written as a step. Absent is one, which is what every pattern written before notes had a length says.",
573
578
"minimum": 1,
574
579
"type": "integer"
575
580
},
576
581
"note": {
577
582
"description": "The MIDI note number. 60 is middle C.",
578
583
"maximum": 127,
579
584
"minimum": 0,
580
585
"type": "integer"
581
586
},
582
587
"probability": {
583
588
"description": "How likely this note is to be struck each time the loop comes round, in percent, asked afresh on every pass. Optional permanently: a note that says nothing is struck every time, which is what every pattern written before a note could say otherwise says, and a certain note writes no field. Nought is not offered, for the reason a velocity of nought is not.",
584
589
"maximum": 100,
585
590
"minimum": 1,
586
591
"type": "integer"
587
592
},
588
593
"step": {
589
594
"description": "Which step of the grid this note is on, counted from the start of the loop. The older way of saying where a note is, read from every pattern published before a note carried a tick and written by none.",
590
595
"minimum": 0,
591
596
"type": "integer"
592
597
},
593
598
"velocity": {
594
599
"description": "How hard this note is struck, on the MIDI scale. It is part of what is played rather than how it is listened to — a phrase is written with its accents in it, and a loop where every note lands identically is a loop nobody wrote. Optional permanently: a note that says nothing is struck at 100, which is what every pattern written before a note could say says, and a note struck at 100 writes no field. Nought is not offered, since a note that could never be heard is a note taken off the loop rather than one written onto it.",
595
600
"maximum": 127,
596
601
"minimum": 1,
597
602
"type": "integer"
598
603
}
599
604
},
600
605
"required": [
601
606
"note"
602
607
],
603
608
"type": "object"
604
609
},
605
610
"noteOutputRef": {
606
611
"properties": {
607
612
"instanceId": {
608
613
"maxLength": 64,
609
614
"minLength": 1,
610
615
"type": "string"
611
616
},
612
617
"noteOutput": {
613
618
"maxLength": 64,
614
619
"minLength": 1,
615
620
"type": "string"
616
621
}
617
622
},
618
623
"required": [
619
624
"instanceId",
620
625
"noteOutput"
621
626
],
622
627
"type": "object"
623
628
},
624
629
"notePattern": {
625
630
"description": "The loops one sequencer holds, and the grid they are written on. A loop is a whole number of bars and the notes in it are counted in ticks of the beat, so a pattern means the same thing at any tempo — what a tick is worth in seconds is the player's tempo's business and not the pattern's. The first loop is written here, where a pattern has always been written; any after it are alternates.",
626
631
"properties": {
627
632
"active": {
628
633
"description": "Which loop is played, counting the one written here as zero. Absent is the first. It is in the record because it is what a visitor opening the patch hears — unlike stopping a loop, which is how a browser is listening and is written nowhere. Every loop counts from the same downbeat and wraps at its own length whether or not it is the one being heard, so switching between them reveals where the other had got to rather than starting it.",
629
634
"minimum": 0,
630
635
"type": "integer"
631
636
},
632
637
"alternates": {
633
638
"description": "The loops after the first. Absent while the sequencer holds a single pattern, which is what every sequencer written before there could be more than one says.",
634
639
"items": {
635
640
"ref": "#alternatePattern",
636
641
"type": "ref"
637
642
},
638
643
"maxLength": 7,
639
644
"type": "array"
640
645
},
641
646
"bars": {
642
647
"description": "How long the first loop is, in bars of the patch's time signature (`timeSignature`), which is 4/4 where it says none. Each loop keeps its own length: one may be four bars and the next five.",
643
648
"maximum": 8,
644
649
"minimum": 1,
645
650
"type": "integer"
646
651
},
647
652
"events": {
648
653
"description": "The notes in the first loop. A moment carrying no note is a rest; a note starting outside the loop's length is not played.",
649
654
"items": {
650
655
"ref": "#noteEvent",
651
656
"type": "ref"
652
657
},
653
658
"maxLength": 2048,
654
659
"type": "array"
655
660
},
656
661
"name": {
657
662
"description": "What the creator called the first loop. Optional permanently: a loop that says nothing is called by its place, which is what every loop written before a loop could be named says.",
658
663
"maxGraphemes": 32,
659
664
"maxLength": 320,
660
665
"minLength": 1,
661
666
"type": "string"
662
667
},
663
668
"resolution": {
664
669
"description": "The grid every loop on this sequencer is drawn and snapped to. It is a guide and not a part of what is played: it decides where a note being put down lands, and changing it moves nothing already written, so a loop may hold a note no line of the current grid passes through.",
665
670
"ref": "#resolution",
666
671
"type": "ref"
667
672
}
668
673
},
669
674
"required": [
670
675
"bars",
671
676
"resolution"
672
677
],
673
678
"type": "object"
674
679
},
675
680
"noteRange": {
676
681
"description": "The notes a note range passes on: from its lowest to its highest, both included, as MIDI note numbers (60 is middle C). Either end may be left out, and an end left out is open, so a range with only a lowest passes that note and everything above it. The same note at both ends is one key or one pad.",
677
682
"properties": {
678
683
"highest": {
679
684
"description": "The highest note passed on, at or above the lowest. Absent is the highest there is.",
680
685
"maximum": 127,
681
686
"minimum": 0,
682
687
"type": "integer"
683
688
},
684
689
"lowest": {
685
690
"description": "The lowest note passed on. Absent is the lowest there is.",
686
691
"maximum": 127,
687
692
"minimum": 0,
688
693
"type": "integer"
689
694
}
690
695
},
691
696
"type": "object"
692
697
},
693
698
"outputRef": {
694
699
"properties": {
695
700
"audioOutput": {
696
701
"maxLength": 64,
697
702
"minLength": 1,
698
703
"type": "string"
699
704
},
700
705
"instanceId": {
701
706
"maxLength": 64,
702
707
"minLength": 1,
703
708
"type": "string"
704
709
}
705
710
},
706
711
"required": [
707
712
"instanceId",
708
713
"audioOutput"
709
714
],
710
715
"type": "object"
711
716
},
712
717
"parameterValue": {
713
718
"description": "A value for one of the module's exposed parameters, or an explicit fall-back to the module's declared default.",
714
719
"properties": {
715
720
"id": {
716
721
"maxLength": 64,
717
722
"minLength": 1,
718
723
"type": "string"
719
724
},
720
725
"useDefault": {
721
726
"description": "Set where the patch explicitly defers to the module's default rather than recording a value.",
722
727
"type": "boolean"
723
728
},
724
729
"value": {
725
730
"description": "The value this patch sets the parameter to, always as text. A number is its decimal form — \"0.5\", and \"2\" for a whole one — because the ATproto data model has no floating-point type and a string is the only type that carries both a number and a word. Where the module declares a closed set of values instead, this is one of those strings, and a label that looks like a number stays the label it is: the module's own description says which of the two this parameter is.",
726
731
"maxLength": 200,
727
732
"type": "string"
728
733
}
729
734
},
730
735
"required": [
731
736
"id"
732
737
],
733
738
"type": "object"
734
739
},
735
740
"patternRoute": {
736
741
"description": "One sequencer whose loops, or one automation block whose lanes, an arranger or a scenes block chooses.",
737
742
"properties": {
738
743
"from": {
739
744
"description": "The arranger, or the scenes block.",
740
745
"maxLength": 64,
741
746
"minLength": 1,
742
747
"type": "string"
743
748
},
744
749
"instanceId": {
745
750
"description": "The sequencer or automation block, at its pattern input.",
746
751
"maxLength": 64,
747
752
"minLength": 1,
748
753
"type": "string"
749
754
}
750
755
},
751
756
"required": [
752
757
"from",
753
758
"instanceId"
754
759
],
755
760
"type": "object"
756
761
},
757
762
"position": {
758
763
"properties": {
759
764
"x": {
760
765
"type": "integer"
761
766
},
762
767
"y": {
763
768
"type": "integer"
764
769
}
765
770
},
766
771
"required": [
767
772
"x",
768
773
"y"
769
774
],
770
775
"type": "object"
771
776
},
772
777
"resolution": {
773
778
"description": "One note value, as a length and what that length is multiplied by. The same vocabulary the player's own musical time is counted in.",
774
779
"properties": {
775
780
"unit": {
776
781
"description": "Three of them into the time of two, or not. Absent is normal. A dotted grid is not offered: it does not divide a bar evenly, so it would leave a pattern whose steps do not line up with its own loop.",
777
782
"knownValues": [
778
783
"normal",
779
784
"triplet"
780
785
],
781
786
"type": "string"
782
787
},
783
788
"value": {
784
789
"description": "The note value one step is worth. `bar` is one bar of the patch's time signature; every other value is a note, the same length in any bar.",
785
790
"knownValues": [
786
791
"bar",
787
792
"1/2",
788
793
"1/4",
789
794
"1/8",
790
795
"1/16",
791
796
"1/32",
792
797
"1/64",
793
798
"1/128"
794
799
],
795
800
"type": "string"
796
801
}
797
802
},
798
803
"required": [
799
804
"value"
800
805
],
801
806
"type": "object"
802
807
},
803
808
"sampleSlotFill": {
804
809
"properties": {
805
810
"blob": {
806
811
"accept": [
807
812
"audio/wav"
808
813
],
809
814
"maxSize": 2097152,
810
815
"type": "blob"
811
816
},
812
817
"ownerDid": {
813
818
"format": "did",
814
819
"type": "string"
815
820
},
816
821
"slotId": {
817
822
"maxLength": 64,
818
823
"minLength": 1,
819
824
"type": "string"
820
825
}
821
826
},
822
827
"required": [
823
828
"slotId",
824
829
"blob",
825
830
"ownerDid"
826
831
],
827
832
"type": "object"
828
833
},
829
834
"scene": {
830
835
"description": "One scene: which loop each sequencer wired to the scenes block plays while it is the scene playing. It lasts until another scene is chosen.",
831
836
"properties": {
832
837
"loops": {
833
838
"description": "Which loop each sequencer plays in this scene. A sequencer wired to the scenes block with no entry here rests while it plays.",
834
839
"items": {
835
840
"ref": "#sectionLoop",
836
841
"type": "ref"
837
842
},
838
843
"maxLength": 64,
839
844
"type": "array"
840
845
},
841
846
"name": {
842
847
"description": "What the creator called this scene. Optional permanently: a scene that says nothing is called by its letter.",
843
848
"maxGraphemes": 32,
844
849
"maxLength": 320,
845
850
"minLength": 1,
846
851
"type": "string"
847
852
}
848
853
},
849
854
"type": "object"
850
855
},
851
856
"sceneLaunch": {
852
857
"description": "When a scene chosen takes over, and where its loops start.",
853
858
"properties": {
854
859
"quantize": {
855
860
"description": "Where a scene chosen takes over: `none` at once, or on the next beat, bar, two bars or four bars of the patch's time signature — a beat being the note its lower number names — counted from the downbeat the loops count from. Optional permanently: absent is `bar`.",
856
861
"knownValues": [
857
862
"none",
858
863
"beat",
859
864
"bar",
860
865
"2bars",
861
866
"4bars"
862
867
],
863
868
"type": "string"
864
869
},
865
870
"restart": {
866
871
"description": "Whether the loops a scene names start from their first step where it takes over, or carry on from where they already were. Optional permanently: absent is from their first step, so only `false` is written.",
867
872
"type": "boolean"
868
873
}
869
874
},
870
875
"type": "object"
871
876
},
872
877
"section": {
873
878
"description": "One section of a song: how long it is, and which loop each arranged sequencer plays for that long.",
874
879
"properties": {
875
880
"bars": {
876
881
"description": "How long this section is, in bars of the patch's time signature.",
877
882
"maximum": 64,
878
883
"minimum": 1,
879
884
"type": "integer"
880
885
},
881
886
"loops": {
882
887
"description": "Which loop each sequencer plays for this section. A sequencer wired to the arranger with no entry here rests for the section.",
883
888
"items": {
884
889
"ref": "#sectionLoop",
885
890
"type": "ref"
886
891
},
887
892
"maxLength": 64,
888
893
"type": "array"
889
894
},
890
895
"name": {
891
896
"description": "What the creator called this section. Optional permanently: a section that says nothing is called by its place.",
892
897
"maxGraphemes": 32,
893
898
"maxLength": 320,
894
899
"minLength": 1,
895
900
"type": "string"
896
901
}
897
902
},
898
903
"required": [
899
904
"bars"
900
905
],
901
906
"type": "object"
902
907
},
903
908
"sectionLoop": {
904
909
"properties": {
905
910
"instanceId": {
906
911
"description": "The sequencer, or the automation block.",
907
912
"maxLength": 64,
908
913
"minLength": 1,
909
914
"type": "string"
910
915
},
911
916
"loop": {
912
917
"description": "Which of the sequencer's loops it plays, counting the one its pattern writes first as zero, or which of the automation block's lanes. One it does not hold is played as its last.",
913
918
"maximum": 7,
914
919
"minimum": 0,
915
920
"type": "integer"
916
921
}
917
922
},
918
923
"required": [
919
924
"instanceId",
920
925
"loop"
921
926
],
922
927
"type": "object"
923
928
},
924
929
"song": {
925
930
"description": "An arranger's song: sections played one after another from its first beat. Each section starts every loop it names from that loop's first step, and lets go of whatever is still sounding when it ends, so a loop shorter than its section repeats and one longer is cut off.",
926
931
"properties": {
927
932
"end": {
928
933
"description": "What happens when the last section ends: `stop` leaves the sequencers it arranges silent, `loop` plays the song again from its first section, and `hold` keeps playing the last section. Optional permanently: absent is `stop`.",
929
934
"knownValues": [
930
935
"stop",
931
936
"loop",
932
937
"hold"
933
938
],
934
939
"type": "string"
935
940
},
936
941
"sections": {
937
942
"description": "The sections, in the order they are played.",
938
943
"items": {
939
944
"ref": "#section",
940
945
"type": "ref"
941
946
},
942
947
"maxLength": 64,
943
948
"type": "array"
944
949
}
945
950
},
946
951
"type": "object"
947
952
},
948
953
"timeSignature": {
949
954
"description": "A time signature as it is printed over a stave: how many beats one bar holds, over the note a beat is. The tempo counts quarter notes whatever the lower number is; what the two decide is how long a bar is, and so where every bar line falls.",
950
955
"properties": {
951
956
"denominator": {
952
957
"description": "The note a beat is: 2 a half, 4 a quarter, 8 an eighth, 16 a sixteenth. The lower number.",
953
958
"enum": [
954
959
2,
955
960
4,
956
961
8,
957
962
16
958
963
],
959
964
"type": "integer"
960
965
},
961
966
"numerator": {
962
967
"description": "How many beats one bar holds: the upper number.",
963
968
"maximum": 32,
964
969
"minimum": 1,
965
970
"type": "integer"
966
971
}
967
972
},
968
973
"required": [
969
974
"numerator",
970
975
"denominator"
971
976
],
972
977
"type": "object"
973
978
}
974
979
},
975
980
"description": "A synth patch: which modules it uses, how they are wired, what their parameters are set to, and how it is played. A patch plus the module records it pins is everything needed to reproduce it.",
976
981
"id": "at.atmosynth.patch",
977
982
"lexicon": 1
978
983
}