/* * Copyright (C) 2025 Linux Studio Plugins Project * (C) 2025 Vladimir Sadovnikov * * This file is part of lsp-runtime-lib * Created on: 29 мая 2019 г. * * lsp-runtime-lib is free software: you can redistribute it and/or modify * it under the terms of the GNU Lesser General Public License as published by * the Free Software Foundation, either version 3 of the License, or * any later version. * * lsp-runtime-lib is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public License * along with lsp-runtime-lib. If not, see . */ #define __LSP_PROTOCOL_OSC_IMPL #include #include #include #include #include #include #include #include #include namespace lsp { namespace osc { status_t forge_begin_fixed(forge_frame_t *ref, forge_t *forge, void *data, size_t size) { if ((data == NULL) || (ref == NULL) || (forge == NULL)) return STATUS_BAD_ARGUMENTS; forge->data = reinterpret_cast(data); forge->offset = 0; forge->capacity = size; forge->dynamic = false; forge->refs = 1; forge->toff = 0; forge->tsize = 0; ref->forge = forge; ref->parent = NULL; ref->child = NULL; ref->type = FRT_ROOT; ref->offset = 0; return STATUS_OK; } status_t forge_begin_dynamic(forge_frame_t *ref, forge_t *forge, size_t reserve) { if ((ref == NULL) || (forge == NULL)) return STATUS_BAD_ARGUMENTS; uint8_t *buf = NULL; if (reserve > 0) { if ((buf = reinterpret_cast(::malloc(reserve))) == NULL) return STATUS_NO_MEM; } forge->data = buf; forge->offset = 0; forge->capacity = reserve; forge->dynamic = true; forge->refs = 1; forge->toff = 0; forge->tsize = 0; ref->forge = forge; ref->parent = NULL; ref->child = NULL; ref->type = FRT_ROOT; ref->offset = 0; return STATUS_OK; } bool forge_check_child(forge_frame_t *child, forge_frame_t *ref) { if (child == NULL) return false; for ( ; ref != NULL; ref = ref->parent) if (ref == child) return false; return true; } status_t forge_check_capacity(forge_t *buf, size_t capacity) { if (capacity <= buf->capacity) return STATUS_OK; if (!buf->dynamic) return STATUS_OVERFLOW; // Reallocate memory size_t to_alloc = ((capacity << 1) + capacity) >> 1; // capacity * 1.5 uint8_t *ptr = reinterpret_cast(::realloc(buf->data, to_alloc)); if (ptr == NULL) return STATUS_NO_MEM; buf->data = ptr; buf->capacity = to_alloc; return STATUS_OK; } status_t forge_append_bytes(forge_t *buf, const void *data, size_t count) { status_t res = forge_check_capacity(buf, buf->offset + count); if (res != STATUS_OK) return res; // Append data to buffer ::memcpy(&buf->data[buf->offset], data, count); buf->offset += count; return STATUS_OK; } status_t forge_append_padded(forge_t *buf, const void *data, size_t count) { size_t capacity = ((count + sizeof(uint32_t) - 1) >> 2) << 2; status_t res = forge_check_capacity(buf, buf->offset + capacity); if (res != STATUS_OK) return res; // Append data to buffer and pad tail with zeros ::memcpy(&buf->data[buf->offset], data, count); buf->offset += count; while (count++ < capacity) buf->data[buf->offset++] = 0; return STATUS_OK; } status_t forge_parameter(forge_frame_t *ref, forge_param_type_t type, const void *data, size_t count) { if (ref == NULL) return STATUS_BAD_ARGUMENTS; if (ref->child != NULL) return STATUS_BAD_STATE; // Should be FRT_MESSAGE to emit parameters if ((ref->type != FRT_MESSAGE) && (ref->type != FRT_ARRAY)) return STATUS_BAD_STATE; forge_t *buf = ref->forge; size_t capacity = buf->offset; // Estimate additional space for tag string size_t old_pad = ((buf->tsize + sizeof(uint32_t) - 1) >> 2); size_t new_pad = ((buf->tsize + sizeof(uint32_t)) >> 2); if (old_pad != new_pad) capacity += sizeof(uint32_t); size_t datacap = ((count + sizeof(uint32_t) - 1) >> 2) << 2; capacity += datacap; // Ensure that there is enough capacity status_t res = forge_check_capacity(buf, capacity); if (res != STATUS_OK) return res; // Need to insert some space for parameter tags? if (old_pad != new_pad) { size_t aoff = buf->toff + (old_pad << 2); uint8_t *ptr = &buf->data[aoff]; ::memmove(&ptr[sizeof(uint32_t)], ptr, buf->offset - aoff); ptr[0] = 0; ptr[1] = 0; ptr[2] = 0; ptr[3] = 0; buf->offset += sizeof(uint32_t); } // Append type tag buf->data[buf->toff + buf->tsize - 1] = uint8_t(type); ++ buf->tsize; // Append data to buffer and pad tail with zeros if (count > 0) { ::memcpy(&buf->data[buf->offset], data, count); buf->offset += count; while (count++ < datacap) buf->data[buf->offset++] = 0; } return STATUS_OK; } status_t forge_begin_bundle(forge_frame_t *child, forge_frame_t *ref, uint64_t tag) { if ((ref == NULL) || (!forge_check_child(child, ref))) return STATUS_BAD_ARGUMENTS; if ((ref->child != NULL) || (ref->forge == NULL)) return STATUS_BAD_STATE; status_t res; forge_t *buf = ref->forge; ssize_t offset = buf->offset; if (ref->type == FRT_BUNDLE) { // Append bundle header sized_bundle_header_t hdr; hdr.size = 0; hdr.sig = BUNDLE_SIG; hdr.tag = CPU_TO_BE(tag); res = forge_append_bytes(buf, &hdr, sizeof(hdr)); if (res != STATUS_OK) return res; } else if (ref->type == FRT_ROOT) { // Disallow multiple bundles if (buf->offset > 0) return STATUS_BAD_STATE; // Append bundle header bundle_header_t hdr; hdr.sig = BUNDLE_SIG; hdr.tag = CPU_TO_BE(tag); res = forge_append_bytes(buf, &hdr, sizeof(hdr)); if (res != STATUS_OK) return res; } else return STATUS_BAD_STATE; // Link and initialize child frame ref->child = child; child->forge = buf; child->parent = ref; child->child = NULL; child->type = FRT_BUNDLE; child->offset = offset; ++ buf->refs; return STATUS_OK; } status_t forge_begin_message(forge_frame_t *child, forge_frame_t *ref, const char *address) { return forge_begin_message(child, ref, NULL, address); } status_t forge_begin_message(forge_frame_t *child, forge_frame_t *ref, const char *prefix, const char *address) { if ((ref == NULL) || (address == NULL) || (!forge_check_child(child, ref))) return STATUS_BAD_ARGUMENTS; if ((ref->child != NULL) || (ref->forge == NULL)) return STATUS_BAD_STATE; // Need to reserve space for size? status_t res; forge_t *buf = ref->forge; ssize_t offset = buf->offset; if (ref->type == FRT_BUNDLE) { res = forge_append_bytes(buf, &BUNDLE_SIZE, sizeof(BUNDLE_SIZE)); if (res != STATUS_OK) return res; } else if (ref->type == FRT_ROOT) { // Disallow multiple messages if (buf->offset > 0) return STATUS_BAD_STATE; } else return STATUS_BAD_STATE; // Append message prefix if (prefix != NULL) { res = forge_append_bytes(buf, prefix, ::strlen(prefix)); if (res != STATUS_OK) return res; } // Append message string res = forge_append_padded(buf, address, ::strlen(address) + 1); if (res != STATUS_OK) return res; // Append type string (should be always present) buf->toff = buf->offset; buf->tsize = 2; // ',' + '\0' res = forge_append_bytes(buf, &EMPTY_PARAMS, sizeof(EMPTY_PARAMS)); if (res != STATUS_OK) return res; // Link and initialize child frame ref->child = child; child->forge = buf; child->parent = ref; child->child = NULL; child->type = FRT_MESSAGE; child->offset = offset; ++ buf->refs; return STATUS_OK; } status_t forge_message(forge_frame_t *ref, const char *address, const char *params...) { va_list args; va_start(args, params); status_t res = forge_messagev(ref, address, params, args); va_end(args); return res; } status_t forge_messagev(forge_frame_t *ref, const char *address, const char *params, va_list args) { forge_frame_t message; status_t res = forge_begin_message(&message, ref, address); if (res != STATUS_OK) return res; ssize_t recursive = 0; if (params != NULL) { for (const char *fmt=params; *fmt != '\0'; ++fmt) { switch (*fmt) { case FPT_INT32: res = forge_int32(&message, va_arg(args, int32_t)); break; case FPT_FLOAT32: { float v = float(va_arg(args, double)); res = (isinf(v)) ? forge_inf(&message) : forge_float32(&message, v); break; } case FPT_OSC_STRING: { const char *str = va_arg(args, const char *); res = (str != NULL) ? forge_string(&message, str) : forge_null(&message); break; } case FPT_INT64: res = forge_int64(&message, va_arg(args, int64_t)); break; case FPT_OSC_TIMETAG: res = forge_time_tag(&message, va_arg(args, uint64_t)); break; case FPT_DOUBLE64: { double v = va_arg(args, double); res = (isinf(v)) ? forge_inf(&message) : forge_double64(&message, v); break; } case FPT_TYPE: { const char *str = va_arg(args, const char *); res = (str != NULL) ? forge_type(&message, str) : forge_null(&message); break; } case FPT_ASCII_CHAR: res = forge_ascii(&message, char(va_arg(args, int))); break; case FPT_RGBA_COLOR: res = forge_rgba(&message, va_arg(args, uint32_t)); break; case FPT_TRUE: case FPT_FALSE: res = forge_bool(&message, bool(va_arg(args, int))); break; case FPT_NULL: res = forge_null(&message); break; case FPT_INF: res = forge_inf(&message); break; case FPT_ARRAY_START: res = forge_parameter(&message, FPT_ARRAY_START, NULL, 0); if (res == STATUS_OK) ++recursive; break; case FPT_ARRAY_END: res = forge_parameter(&message, FPT_ARRAY_END, NULL, 0); if (res == STATUS_OK) { if (--recursive < 0) res = STATUS_BAD_FORMAT; } break; case FPT_OSC_BLOB: { size_t size = va_arg(args, size_t); const void *ptr = va_arg(args, const void *); res = forge_blob(&message, ptr, size); break; } case FPT_MIDI_MESSAGE: res = STATUS_NOT_SUPPORTED; break; default: res = STATUS_BAD_FORMAT; break; } if (res != STATUS_OK) break; } } if ((res == STATUS_OK) && (recursive != 0)) res = STATUS_BAD_FORMAT; if (res == STATUS_OK) res = forge_end(&message); else forge_end(&message); return res; } status_t forge_begin_array(forge_frame_t *child, forge_frame_t *ref) { if ((ref == NULL) || (!forge_check_child(child, ref))) return STATUS_BAD_ARGUMENTS; if ((ref->child != NULL) || (ref->forge == NULL)) return STATUS_BAD_STATE; if ((ref->type != FRT_MESSAGE) && (ref->type != FRT_ARRAY)) return STATUS_BAD_STATE; // Forge array start status_t res = forge_parameter(ref, FPT_ARRAY_START, NULL, 0); if (res != STATUS_OK) return res; // Initialize child ref->child = child; child->forge = ref->forge; child->parent = ref; child->child = NULL; child->type = FRT_ARRAY; child->offset = 0; ++ ref->forge->refs; return STATUS_OK; } status_t forge_int32(forge_frame_t *ref, int32_t value) { int32_t x = CPU_TO_BE(value); return forge_parameter(ref, FPT_INT32, &x, sizeof(x)); } status_t forge_float32(forge_frame_t *ref, float value) { float x = CPU_TO_BE(value); return forge_parameter(ref, FPT_FLOAT32, &x, sizeof(x)); } status_t forge_string(forge_frame_t *ref, const char *s) { return forge_parameter(ref, FPT_OSC_STRING, s, ::strlen(s) + 1); } status_t forge_blob(forge_frame_t *ref, const void *data, size_t bytes) { if (ref == NULL) return STATUS_BAD_ARGUMENTS; if (ref->child != NULL) return STATUS_BAD_STATE; // Should be FRT_MESSAGE to emit parameters if ((ref->type != FRT_MESSAGE) && (ref->type != FRT_ARRAY)) return STATUS_BAD_STATE; uint32_t len = CPU_TO_BE(uint32_t(bytes)); status_t res = forge_append_bytes(ref->forge, &len, sizeof(len)); if (res == STATUS_OK) res = forge_parameter(ref, FPT_OSC_BLOB, data, bytes); return res; } status_t forge_int64(forge_frame_t *ref, int64_t value) { int64_t x = CPU_TO_BE(value); return forge_parameter(ref, FPT_INT64, &x, sizeof(x)); } status_t forge_double64(forge_frame_t *ref, double value) { double x = CPU_TO_BE(value); return forge_parameter(ref, FPT_DOUBLE64, &x, sizeof(x)); } status_t forge_time_tag(forge_frame_t *ref, uint64_t value) { uint64_t x = CPU_TO_BE(value); return forge_parameter(ref, FPT_OSC_TIMETAG, &x, sizeof(x)); } status_t forge_type(forge_frame_t *ref, const char *s) { return forge_parameter(ref, FPT_TYPE, s, ::strlen(s) + 1); } status_t forge_symbol(forge_frame_t *ref, const char *s) { return forge_parameter(ref, FPT_TYPE, s, ::strlen(s) + 1); } status_t forge_ascii(forge_frame_t *ref, char c) { // Needs clarification: OSC spec says "an ascii character, sent as 32 bits" // Do we need to send a single byte and pad it to 4 bytes, or convert byte to 32-bit // value and send it? More probable variant is the second //uint8_t x = uint8_t(c); uint32_t x = CPU_TO_BE(uint32_t(c & 0xff)); return forge_parameter(ref, FPT_ASCII_CHAR, &x, sizeof(x)); } status_t forge_rgba(forge_frame_t *ref, const uint32_t rgba) { uint32_t x = CPU_TO_BE(rgba); return forge_parameter(ref, FPT_RGBA_COLOR, &x, sizeof(x)); } status_t forge_midi(forge_frame_t *ref, const midi::event_t *event) { uint8_t x[4]; ssize_t n = midi::encode(x, event); if (n < 0) return status_t(-n); return forge_parameter(ref, FPT_MIDI_MESSAGE, &x, n); } status_t forge_midi_raw(forge_frame_t *ref, const void *event, size_t bytes) { if ((bytes <= 0) || (bytes > 3)) return STATUS_BAD_ARGUMENTS; return forge_parameter(ref, FPT_MIDI_MESSAGE, event, bytes); } status_t forge_bool(forge_frame_t *ref, bool value) { return forge_parameter(ref, (value) ? FPT_TRUE : FPT_FALSE, NULL, 0); } status_t forge_null(forge_frame_t *ref) { return forge_parameter(ref, FPT_NULL, NULL, 0); } status_t forge_inf(forge_frame_t *ref) { return forge_parameter(ref, FPT_INF, NULL, 0); } status_t forge_end(forge_frame_t *ref) { if ((ref == NULL) || (ref->child != NULL)) return STATUS_BAD_STATE; forge_t *buf = ref->forge; if (buf == NULL) return STATUS_BAD_STATE; status_t res = STATUS_OK; switch (ref->type) { case FRT_ROOT: if (buf->refs <= 0) return STATUS_BAD_STATE; --buf->refs; return STATUS_OK; case FRT_ARRAY: if (ref->parent == NULL) return STATUS_BAD_STATE; res = forge_parameter(ref, FPT_ARRAY_END, NULL, 0); --buf->refs; break; case FRT_BUNDLE: case FRT_MESSAGE: if (ref->parent == NULL) return STATUS_BAD_STATE; // Need to commit size to header? if (ref->parent->type == FRT_BUNDLE) { union { uint8_t *u8; uint32_t *u32; } xptr; const uint32_t size = uint32_t(buf->offset - ref->offset - sizeof(uint32_t)); xptr.u8 = &buf->data[ref->offset]; *(xptr.u32) = CPU_TO_BE(size); } --buf->refs; break; default: return STATUS_CORRUPTED; } // Unlink frame ref->parent->child = NULL; ref->forge = NULL; ref->parent = NULL; ref->type = FRT_UNKNOWN; ref->offset = -1; return res; } status_t forge_close(packet_t *packet, forge_t *forge) { if ((forge == NULL) || (packet == NULL)) return STATUS_BAD_ARGUMENTS; if ((forge->refs > 0) || (forge->data == NULL)) return STATUS_BAD_STATE; packet->size = forge->offset; packet->data = forge->data; forge->data = NULL; forge->dynamic = false; forge->capacity = 0; forge->offset = 0; return STATUS_OK; } status_t forge_destroy(forge_t *forge) { if (forge == NULL) return STATUS_BAD_ARGUMENTS; if ((forge->dynamic) && (forge->data != NULL)) ::free(forge->data); forge->data = NULL; forge->dynamic = false; forge->capacity = 0; forge->offset = 0; forge->refs = 0; forge->toff = 0; forge->tsize = 0; return STATUS_OK; } void forge_free(void *ptr) { if (ptr != NULL) ::free(ptr); } } /* namespace osc */ } /* namespace lsp */