Debian Codegraph @

modules/lsp-runtime-lib/src/main/protocol/osc/forge.cpp

raw
1 /*
2 * Copyright (C) 2025 Linux Studio Plugins Project <https://lsp-plug.in/>
3 * (C) 2025 Vladimir Sadovnikov <[email protected]>
4 *
5 * This file is part of lsp-runtime-lib
6 * Created on: 29 мая 2019 г.
7 *
8 * lsp-runtime-lib is free software: you can redistribute it and/or modify
9 * it under the terms of the GNU Lesser General Public License as published by
10 * the Free Software Foundation, either version 3 of the License, or
11 * any later version.
12 *
13 * lsp-runtime-lib is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU Lesser General Public License for more details.
17 *
18 * You should have received a copy of the GNU Lesser General Public License
19 * along with lsp-runtime-lib. If not, see <https://www.gnu.org/licenses/>.
20 */
21
22 #define __LSP_PROTOCOL_OSC_IMPL
23
24 #include <lsp-plug.in/protocol/osc.h>
25 #include <lsp-plug.in/protocol/midi.h>
26 #include <lsp-plug.in/common/endian.h>
27 #include <lsp-plug.in/common/debug.h>
28 #include <lsp-plug.in/stdlib/string.h>
29 #include <lsp-plug.in/stdlib/math.h>
30
31 #include <stdint.h>
32 #include <stdlib.h>
33 #include <stdarg.h>
34
35 namespace lsp
36 {
37 namespace osc
38 {
39 status_t forge_begin_fixed(forge_frame_t *ref, forge_t *forge, void *data, size_t size)
40 {
41 if ((data == NULL) || (ref == NULL) || (forge == NULL))
42 return STATUS_BAD_ARGUMENTS;
43
44 forge->data = reinterpret_cast<uint8_t *>(data);
45 forge->offset = 0;
46 forge->capacity = size;
47 forge->dynamic = false;
48 forge->refs = 1;
49 forge->toff = 0;
50 forge->tsize = 0;
51
52 ref->forge = forge;
53 ref->parent = NULL;
54 ref->child = NULL;
55 ref->type = FRT_ROOT;
56 ref->offset = 0;
57
58 return STATUS_OK;
59 }
60
61 status_t forge_begin_dynamic(forge_frame_t *ref, forge_t *forge, size_t reserve)
62 {
63 if ((ref == NULL) || (forge == NULL))
64 return STATUS_BAD_ARGUMENTS;
65
66 uint8_t *buf = NULL;
67 if (reserve > 0)
68 {
69 if ((buf = reinterpret_cast<uint8_t *>(::malloc(reserve))) == NULL)
70 return STATUS_NO_MEM;
71 }
72
73 forge->data = buf;
74 forge->offset = 0;
75 forge->capacity = reserve;
76 forge->dynamic = true;
77 forge->refs = 1;
78 forge->toff = 0;
79 forge->tsize = 0;
80
81 ref->forge = forge;
82 ref->parent = NULL;
83 ref->child = NULL;
84 ref->type = FRT_ROOT;
85 ref->offset = 0;
86
87 return STATUS_OK;
88 }
89
90 bool forge_check_child(forge_frame_t *child, forge_frame_t *ref)
91 {
92 if (child == NULL)
93 return false;
94
95 for ( ; ref != NULL; ref = ref->parent)
96 if (ref == child)
97 return false;
98
99 return true;
100 }
101
102 status_t forge_check_capacity(forge_t *buf, size_t capacity)
103 {
104 if (capacity <= buf->capacity)
105 return STATUS_OK;
106
107 if (!buf->dynamic)
108 return STATUS_OVERFLOW;
109
110 // Reallocate memory
111 size_t to_alloc = ((capacity << 1) + capacity) >> 1; // capacity * 1.5
112 uint8_t *ptr = reinterpret_cast<uint8_t *>(::realloc(buf->data, to_alloc));
113 if (ptr == NULL)
114 return STATUS_NO_MEM;
115
116 buf->data = ptr;
117 buf->capacity = to_alloc;
118
119 return STATUS_OK;
120 }
121
122 status_t forge_append_bytes(forge_t *buf, const void *data, size_t count)
123 {
124 status_t res = forge_check_capacity(buf, buf->offset + count);
125 if (res != STATUS_OK)
126 return res;
127
128 // Append data to buffer
129 ::memcpy(&buf->data[buf->offset], data, count);
130 buf->offset += count;
131
132 return STATUS_OK;
133 }
134
135 status_t forge_append_padded(forge_t *buf, const void *data, size_t count)
136 {
137 size_t capacity = ((count + sizeof(uint32_t) - 1) >> 2) << 2;
138 status_t res = forge_check_capacity(buf, buf->offset + capacity);
139 if (res != STATUS_OK)
140 return res;
141
142 // Append data to buffer and pad tail with zeros
143 ::memcpy(&buf->data[buf->offset], data, count);
144 buf->offset += count;
145 while (count++ < capacity)
146 buf->data[buf->offset++] = 0;
147
148 return STATUS_OK;
149 }
150
151 status_t forge_parameter(forge_frame_t *ref, forge_param_type_t type, const void *data, size_t count)
152 {
153 if (ref == NULL)
154 return STATUS_BAD_ARGUMENTS;
155 if (ref->child != NULL)
156 return STATUS_BAD_STATE;
157
158 // Should be FRT_MESSAGE to emit parameters
159 if ((ref->type != FRT_MESSAGE) && (ref->type != FRT_ARRAY))
160 return STATUS_BAD_STATE;
161
162 forge_t *buf = ref->forge;
163 size_t capacity = buf->offset;
164
165 // Estimate additional space for tag string
166 size_t old_pad = ((buf->tsize + sizeof(uint32_t) - 1) >> 2);
167 size_t new_pad = ((buf->tsize + sizeof(uint32_t)) >> 2);
168 if (old_pad != new_pad)
169 capacity += sizeof(uint32_t);
170
171 size_t datacap = ((count + sizeof(uint32_t) - 1) >> 2) << 2;
172 capacity += datacap;
173
174 // Ensure that there is enough capacity
175 status_t res = forge_check_capacity(buf, capacity);
176 if (res != STATUS_OK)
177 return res;
178
179 // Need to insert some space for parameter tags?
180 if (old_pad != new_pad)
181 {
182 size_t aoff = buf->toff + (old_pad << 2);
183 uint8_t *ptr = &buf->data[aoff];
184
185 ::memmove(&ptr[sizeof(uint32_t)], ptr, buf->offset - aoff);
186 ptr[0] = 0;
187 ptr[1] = 0;
188 ptr[2] = 0;
189 ptr[3] = 0;
190
191 buf->offset += sizeof(uint32_t);
192 }
193
194 // Append type tag
195 buf->data[buf->toff + buf->tsize - 1] = uint8_t(type);
196 ++ buf->tsize;
197
198 // Append data to buffer and pad tail with zeros
199 if (count > 0)
200 {
201 ::memcpy(&buf->data[buf->offset], data, count);
202 buf->offset += count;
203 while (count++ < datacap)
204 buf->data[buf->offset++] = 0;
205 }
206
207 return STATUS_OK;
208 }
209
210 status_t forge_begin_bundle(forge_frame_t *child, forge_frame_t *ref, uint64_t tag)
211 {
212 if ((ref == NULL) || (!forge_check_child(child, ref)))
213 return STATUS_BAD_ARGUMENTS;
214 if ((ref->child != NULL) || (ref->forge == NULL))
215 return STATUS_BAD_STATE;
216
217 status_t res;
218 forge_t *buf = ref->forge;
219 ssize_t offset = buf->offset;
220
221 if (ref->type == FRT_BUNDLE)
222 {
223 // Append bundle header
224 sized_bundle_header_t hdr;
225 hdr.size = 0;
226 hdr.sig = BUNDLE_SIG;
227 hdr.tag = CPU_TO_BE(tag);
228
229 res = forge_append_bytes(buf, &hdr, sizeof(hdr));
230 if (res != STATUS_OK)
231 return res;
232 }
233 else if (ref->type == FRT_ROOT)
234 {
235 // Disallow multiple bundles
236 if (buf->offset > 0)
237 return STATUS_BAD_STATE;
238
239 // Append bundle header
240 bundle_header_t hdr;
241 hdr.sig = BUNDLE_SIG;
242 hdr.tag = CPU_TO_BE(tag);
243
244 res = forge_append_bytes(buf, &hdr, sizeof(hdr));
245 if (res != STATUS_OK)
246 return res;
247 }
248 else
249 return STATUS_BAD_STATE;
250
251 // Link and initialize child frame
252 ref->child = child;
253
254 child->forge = buf;
255 child->parent = ref;
256 child->child = NULL;
257 child->type = FRT_BUNDLE;
258 child->offset = offset;
259 ++ buf->refs;
260
261 return STATUS_OK;
262 }
263
264 status_t forge_begin_message(forge_frame_t *child, forge_frame_t *ref, const char *address)
265 {
266 return forge_begin_message(child, ref, NULL, address);
267 }
268
269 status_t forge_begin_message(forge_frame_t *child, forge_frame_t *ref, const char *prefix, const char *address)
270 {
271 if ((ref == NULL) || (address == NULL) || (!forge_check_child(child, ref)))
272 return STATUS_BAD_ARGUMENTS;
273 if ((ref->child != NULL) || (ref->forge == NULL))
274 return STATUS_BAD_STATE;
275
276 // Need to reserve space for size?
277 status_t res;
278 forge_t *buf = ref->forge;
279 ssize_t offset = buf->offset;
280
281 if (ref->type == FRT_BUNDLE)
282 {
283 res = forge_append_bytes(buf, &BUNDLE_SIZE, sizeof(BUNDLE_SIZE));
284 if (res != STATUS_OK)
285 return res;
286 }
287 else if (ref->type == FRT_ROOT)
288 {
289 // Disallow multiple messages
290 if (buf->offset > 0)
291 return STATUS_BAD_STATE;
292 }
293 else
294 return STATUS_BAD_STATE;
295
296 // Append message prefix
297 if (prefix != NULL)
298 {
299 res = forge_append_bytes(buf, prefix, ::strlen(prefix));
300 if (res != STATUS_OK)
301 return res;
302 }
303
304 // Append message string
305 res = forge_append_padded(buf, address, ::strlen(address) + 1);
306 if (res != STATUS_OK)
307 return res;
308
309 // Append type string (should be always present)
310 buf->toff = buf->offset;
311 buf->tsize = 2; // ',' + '\0'
312
313 res = forge_append_bytes(buf, &EMPTY_PARAMS, sizeof(EMPTY_PARAMS));
314 if (res != STATUS_OK)
315 return res;
316
317 // Link and initialize child frame
318 ref->child = child;
319
320 child->forge = buf;
321 child->parent = ref;
322 child->child = NULL;
323 child->type = FRT_MESSAGE;
324 child->offset = offset;
325 ++ buf->refs;
326
327 return STATUS_OK;
328 }
329
330 status_t forge_message(forge_frame_t *ref, const char *address, const char *params...)
331 {
332 va_list args;
333 va_start(args, params);
334 status_t res = forge_messagev(ref, address, params, args);
335 va_end(args);
336 return res;
337 }
338
339 status_t forge_messagev(forge_frame_t *ref, const char *address, const char *params, va_list args)
340 {
341 forge_frame_t message;
342 status_t res = forge_begin_message(&message, ref, address);
343 if (res != STATUS_OK)
344 return res;
345
346 ssize_t recursive = 0;
347
348 if (params != NULL)
349 {
350 for (const char *fmt=params; *fmt != '\0'; ++fmt)
351 {
352 switch (*fmt)
353 {
354 case FPT_INT32:
355 res = forge_int32(&message, va_arg(args, int32_t));
356 break;
357 case FPT_FLOAT32:
358 {
359 float v = float(va_arg(args, double));
360 res = (isinf(v)) ? forge_inf(&message) : forge_float32(&message, v);
361 break;
362 }
363 case FPT_OSC_STRING:
364 {
365 const char *str = va_arg(args, const char *);
366 res = (str != NULL) ? forge_string(&message, str) : forge_null(&message);
367 break;
368 }
369 case FPT_INT64:
370 res = forge_int64(&message, va_arg(args, int64_t));
371 break;
372 case FPT_OSC_TIMETAG:
373 res = forge_time_tag(&message, va_arg(args, uint64_t));
374 break;
375 case FPT_DOUBLE64:
376 {
377 double v = va_arg(args, double);
378 res = (isinf(v)) ? forge_inf(&message) : forge_double64(&message, v);
379 break;
380 }
381 case FPT_TYPE:
382 {
383 const char *str = va_arg(args, const char *);
384 res = (str != NULL) ? forge_type(&message, str) : forge_null(&message);
385 break;
386 }
387 case FPT_ASCII_CHAR:
388 res = forge_ascii(&message, char(va_arg(args, int)));
389 break;
390 case FPT_RGBA_COLOR:
391 res = forge_rgba(&message, va_arg(args, uint32_t));
392 break;
393 case FPT_TRUE:
394 case FPT_FALSE:
395 res = forge_bool(&message, bool(va_arg(args, int)));
396 break;
397 case FPT_NULL:
398 res = forge_null(&message);
399 break;
400 case FPT_INF:
401 res = forge_inf(&message);
402 break;
403
404 case FPT_ARRAY_START:
405 res = forge_parameter(&message, FPT_ARRAY_START, NULL, 0);
406 if (res == STATUS_OK)
407 ++recursive;
408 break;
409 case FPT_ARRAY_END:
410 res = forge_parameter(&message, FPT_ARRAY_END, NULL, 0);
411 if (res == STATUS_OK)
412 {
413 if (--recursive < 0)
414 res = STATUS_BAD_FORMAT;
415 }
416 break;
417
418 case FPT_OSC_BLOB:
419 {
420 size_t size = va_arg(args, size_t);
421 const void *ptr = va_arg(args, const void *);
422 res = forge_blob(&message, ptr, size);
423 break;
424 }
425
426 case FPT_MIDI_MESSAGE:
427 res = STATUS_NOT_SUPPORTED;
428 break;
429
430 default:
431 res = STATUS_BAD_FORMAT;
432 break;
433 }
434
435 if (res != STATUS_OK)
436 break;
437 }
438 }
439
440 if ((res == STATUS_OK) && (recursive != 0))
441 res = STATUS_BAD_FORMAT;
442
443 if (res == STATUS_OK)
444 res = forge_end(&message);
445 else
446 forge_end(&message);
447
448 return res;
449 }
450
451 status_t forge_begin_array(forge_frame_t *child, forge_frame_t *ref)
452 {
453 if ((ref == NULL) || (!forge_check_child(child, ref)))
454 return STATUS_BAD_ARGUMENTS;
455 if ((ref->child != NULL) || (ref->forge == NULL))
456 return STATUS_BAD_STATE;
457 if ((ref->type != FRT_MESSAGE) && (ref->type != FRT_ARRAY))
458 return STATUS_BAD_STATE;
459
460 // Forge array start
461 status_t res = forge_parameter(ref, FPT_ARRAY_START, NULL, 0);
462 if (res != STATUS_OK)
463 return res;
464
465 // Initialize child
466 ref->child = child;
467
468 child->forge = ref->forge;
469 child->parent = ref;
470 child->child = NULL;
471 child->type = FRT_ARRAY;
472 child->offset = 0;
473 ++ ref->forge->refs;
474
475 return STATUS_OK;
476 }
477
478 status_t forge_int32(forge_frame_t *ref, int32_t value)
479 {
480 int32_t x = CPU_TO_BE(value);
481 return forge_parameter(ref, FPT_INT32, &x, sizeof(x));
482 }
483
484 status_t forge_float32(forge_frame_t *ref, float value)
485 {
486 float x = CPU_TO_BE(value);
487 return forge_parameter(ref, FPT_FLOAT32, &x, sizeof(x));
488 }
489
490 status_t forge_string(forge_frame_t *ref, const char *s)
491 {
492 return forge_parameter(ref, FPT_OSC_STRING, s, ::strlen(s) + 1);
493 }
494
495 status_t forge_blob(forge_frame_t *ref, const void *data, size_t bytes)
496 {
497 if (ref == NULL)
498 return STATUS_BAD_ARGUMENTS;
499 if (ref->child != NULL)
500 return STATUS_BAD_STATE;
501
502 // Should be FRT_MESSAGE to emit parameters
503 if ((ref->type != FRT_MESSAGE) && (ref->type != FRT_ARRAY))
504 return STATUS_BAD_STATE;
505
506 uint32_t len = CPU_TO_BE(uint32_t(bytes));
507 status_t res = forge_append_bytes(ref->forge, &len, sizeof(len));
508 if (res == STATUS_OK)
509 res = forge_parameter(ref, FPT_OSC_BLOB, data, bytes);
510
511 return res;
512 }
513
514 status_t forge_int64(forge_frame_t *ref, int64_t value)
515 {
516 int64_t x = CPU_TO_BE(value);
517 return forge_parameter(ref, FPT_INT64, &x, sizeof(x));
518 }
519
520 status_t forge_double64(forge_frame_t *ref, double value)
521 {
522 double x = CPU_TO_BE(value);
523 return forge_parameter(ref, FPT_DOUBLE64, &x, sizeof(x));
524 }
525
526 status_t forge_time_tag(forge_frame_t *ref, uint64_t value)
527 {
528 uint64_t x = CPU_TO_BE(value);
529 return forge_parameter(ref, FPT_OSC_TIMETAG, &x, sizeof(x));
530 }
531
532 status_t forge_type(forge_frame_t *ref, const char *s)
533 {
534 return forge_parameter(ref, FPT_TYPE, s, ::strlen(s) + 1);
535 }
536
537 status_t forge_symbol(forge_frame_t *ref, const char *s)
538 {
539 return forge_parameter(ref, FPT_TYPE, s, ::strlen(s) + 1);
540 }
541
542 status_t forge_ascii(forge_frame_t *ref, char c)
543 {
544 // Needs clarification: OSC spec says "an ascii character, sent as 32 bits"
545 // Do we need to send a single byte and pad it to 4 bytes, or convert byte to 32-bit
546 // value and send it? More probable variant is the second
547 //uint8_t x = uint8_t(c);
548 uint32_t x = CPU_TO_BE(uint32_t(c & 0xff));
549 return forge_parameter(ref, FPT_ASCII_CHAR, &x, sizeof(x));
550 }
551
552 status_t forge_rgba(forge_frame_t *ref, const uint32_t rgba)
553 {
554 uint32_t x = CPU_TO_BE(rgba);
555 return forge_parameter(ref, FPT_RGBA_COLOR, &x, sizeof(x));
556 }
557
558 status_t forge_midi(forge_frame_t *ref, const midi::event_t *event)
559 {
560 uint8_t x[4];
561 ssize_t n = midi::encode(x, event);
562 if (n < 0)
563 return status_t(-n);
564 return forge_parameter(ref, FPT_MIDI_MESSAGE, &x, n);
565 }
566
567 status_t forge_midi_raw(forge_frame_t *ref, const void *event, size_t bytes)
568 {
569 if ((bytes <= 0) || (bytes > 3))
570 return STATUS_BAD_ARGUMENTS;
571 return forge_parameter(ref, FPT_MIDI_MESSAGE, event, bytes);
572 }
573
574 status_t forge_bool(forge_frame_t *ref, bool value)
575 {
576 return forge_parameter(ref, (value) ? FPT_TRUE : FPT_FALSE, NULL, 0);
577 }
578
579 status_t forge_null(forge_frame_t *ref)
580 {
581 return forge_parameter(ref, FPT_NULL, NULL, 0);
582 }
583
584 status_t forge_inf(forge_frame_t *ref)
585 {
586 return forge_parameter(ref, FPT_INF, NULL, 0);
587 }
588
589 status_t forge_end(forge_frame_t *ref)
590 {
591 if ((ref == NULL) || (ref->child != NULL))
592 return STATUS_BAD_STATE;
593
594 forge_t *buf = ref->forge;
595 if (buf == NULL)
596 return STATUS_BAD_STATE;
597
598 status_t res = STATUS_OK;
599
600 switch (ref->type)
601 {
602 case FRT_ROOT:
603 if (buf->refs <= 0)
604 return STATUS_BAD_STATE;
605 --buf->refs;
606 return STATUS_OK;
607
608 case FRT_ARRAY:
609 if (ref->parent == NULL)
610 return STATUS_BAD_STATE;
611 res = forge_parameter(ref, FPT_ARRAY_END, NULL, 0);
612 --buf->refs;
613 break;
614
615 case FRT_BUNDLE:
616 case FRT_MESSAGE:
617 if (ref->parent == NULL)
618 return STATUS_BAD_STATE;
619
620 // Need to commit size to header?
621 if (ref->parent->type == FRT_BUNDLE)
622 {
623 union {
624 uint8_t *u8;
625 uint32_t *u32;
626 } xptr;
627
628 const uint32_t size = uint32_t(buf->offset - ref->offset - sizeof(uint32_t));
629 xptr.u8 = &buf->data[ref->offset];
630 *(xptr.u32) = CPU_TO_BE(size);
631 }
632 --buf->refs;
633 break;
634
635 default:
636 return STATUS_CORRUPTED;
637 }
638
639 // Unlink frame
640 ref->parent->child = NULL;
641 ref->forge = NULL;
642 ref->parent = NULL;
643 ref->type = FRT_UNKNOWN;
644 ref->offset = -1;
645
646 return res;
647 }
648
649 status_t forge_close(packet_t *packet, forge_t *forge)
650 {
651 if ((forge == NULL) || (packet == NULL))
652 return STATUS_BAD_ARGUMENTS;
653 if ((forge->refs > 0) || (forge->data == NULL))
654 return STATUS_BAD_STATE;
655
656 packet->size = forge->offset;
657 packet->data = forge->data;
658
659 forge->data = NULL;
660 forge->dynamic = false;
661 forge->capacity = 0;
662 forge->offset = 0;
663
664 return STATUS_OK;
665 }
666
667 status_t forge_destroy(forge_t *forge)
668 {
669 if (forge == NULL)
670 return STATUS_BAD_ARGUMENTS;
671 if ((forge->dynamic) && (forge->data != NULL))
672 ::free(forge->data);
673
674 forge->data = NULL;
675 forge->dynamic = false;
676 forge->capacity = 0;
677 forge->offset = 0;
678 forge->refs = 0;
679 forge->toff = 0;
680 forge->tsize = 0;
681
682 return STATUS_OK;
683 }
684
685 void forge_free(void *ptr)
686 {
687 if (ptr != NULL)
688 ::free(ptr);
689 }
690
691 } /* namespace osc */
692 } /* namespace lsp */
693
694