/* * Copyright (C) 2025 Linux Studio Plugins Project * (C) 2025 Vladimir Sadovnikov * * This file is part of lsp-runtime-lib * Created on: 26 июл. 2025 г. * * 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 . */ #include #include #include #include namespace lsp { namespace obj { static const uint8_t event_codes[] = { CEV_VERTEX3, // 0x00 CEV_NORMAL3, // 0x01 CEV_FACE_N, // 0x02 CEV_FACE, // 0x03 CEV_TEXCOORD2, // 0x08 CEV_FACE_NF, // 0x09 CEV_FACE_TNF, // 0x0a CEV_OBJECT, // 0x0b CEV_FACE_T, // 0x18 CEV_FACE_TN, // 0x19 CEV_PVERTEX3, // 0x1a CEV_LINE, // 0x1b CEV_LINE_T, // 0x38 CEV_POINT, // 0x39 CEV_VERTEX2, // 0x3a CEV_NORMAL2, // 0x3b CEV_VERTEX4, // 0x78 CEV_PVERTEX2, // 0x79 CEV_PVERTEX4, // 0x7a CEV_NORMAL4, // 0x7b CEV_TEXCOORD1, // 0xf8 CEV_TEXCOORD3, // 0xf9 CEV_EOF, // 0xfa CEV_EOF, // 0xfb }; static inline float bin_to_float(int32_t v) { union { float f32; int32_t i32; } cvt; cvt.i32 = v; return cvt.f32; } static inline int32_t zigzag_decode(uint32_t value) { return (int32_t(value) >> 1) ^ -(int32_t(value) & 1); } Decompressor::Decompressor() { vFloatBuf = NULL; nFloatHead = 0; nFloatSize = 0; nFloatCap = 0; nFloatBits = 0; nLastEvent = compressed_event_type_t(-1); } Decompressor::~Decompressor() { clear_state(); } void Decompressor::clear_state() { if (vFloatBuf != NULL) { free(vFloatBuf); vFloatBuf = NULL; } } status_t Decompressor::parse_file(IObjHandler *handler, const char *path) { clear_state(); status_t res = sStream.open(path); if (res == STATUS_OK) res = parse_data(handler); res = update_status(res, sStream.close()); clear_state(); return res; } status_t Decompressor::parse_file(IObjHandler *handler, const LSPString *path) { clear_state(); status_t res = sStream.open(path); if (res == STATUS_OK) res = parse_data(handler); res = update_status(res, sStream.close()); clear_state(); return res; } status_t Decompressor::parse_file(IObjHandler *handler, const io::Path *path) { clear_state(); status_t res = sStream.open(path); if (res == STATUS_OK) res = parse_data(handler); res = update_status(res, sStream.close()); clear_state(); return res; } status_t Decompressor::parse_data(IObjHandler *handler, io::IInStream *is, size_t flags) { clear_state(); status_t res = sStream.wrap(is, flags); if (res == STATUS_OK) res = parse_data(handler); res = update_status(res, sStream.close()); clear_state(); return res; } status_t Decompressor::parse_data(IObjHandler *handler, const void *data, size_t size) { clear_state(); io::InMemoryStream is; is.wrap(data, size); status_t res = sStream.wrap(&is, WRAP_CLOSE); if (res == STATUS_OK) res = parse_data(handler); res = update_status(res, sStream.close()); clear_state(); return res; } status_t Decompressor::parse_header() { compressed_header_t hdr; // Read header ssize_t nread = sStream.read_fully(&hdr, sizeof(compressed_header_t)); if (nread < 0) return status_t(-nread); else if (nread != sizeof(compressed_header_t)) return STATUS_BAD_FORMAT; // Validate header if (hdr.signature != COMPRESSED_SIGNATURE) return STATUS_BAD_FORMAT; if (hdr.version != 0) return STATUS_UNSUPPORTED_FORMAT; if ((hdr.float_bits > MAX_FLOAT_BUF_BITS) || (hdr.float_bits < MIN_FLOAT_BUF_BITS)) return STATUS_CORRUPTED; if ((hdr.pad[0] != 'L') || (hdr.pad[1] != 'S')) return STATUS_BAD_FORMAT; // Check that there is nothing to change const size_t float_cap = 1 << hdr.float_bits; float *ptr = static_cast(malloc(float_cap * sizeof(float))); if (ptr == NULL) return STATUS_NO_MEM; vFloatBuf = ptr; nFloatHead = 0; nFloatSize = 0; nFloatCap = uint32_t(float_cap); nFloatBits = uint32_t(hdr.float_bits); return STATUS_OK; } status_t Decompressor::read_event(compressed_event_type_t *event) { bool b; size_t group = 0; uint32_t cmd = 0; // Check if command has been repeated ssize_t nread = sStream.readb(&b); if (nread != 1) return (nread < 0) ? status_t(-nread) : STATUS_CORRUPTED; if (b) { if (nLastEvent == compressed_event_type_t(-1)) return STATUS_CORRUPTED; *event = nLastEvent; return STATUS_OK; } // Determine group of commands while (true) { nread = sStream.readb(&b); if (nread != 1) return (nread < 0) ? status_t(-nread) : STATUS_CORRUPTED; if (!b) break; ++group; } // Read subcommand identifier nread = sStream.readv(&cmd, 2); if (nread != 2) return (nread < 0) ? status_t(-nread) : STATUS_CORRUPTED; // Convert subcommand + group to event code cmd = uint32_t((group << 2) | cmd); if (cmd >= sizeof(event_codes)) return STATUS_CORRUPTED; nLastEvent = compressed_event_type_t(event_codes[cmd]); *event = nLastEvent; return STATUS_OK; } status_t Decompressor::read_float(float *dst) { // Read index uint32_t index = 0; ssize_t nread = sStream.readv(&index, nFloatBits); if (nread != ssize_t(nFloatBits)) return (nread < 0) ? status_t(-nread) : STATUS_CORRUPTED; // Analyze index const uint32_t base = nFloatHead + nFloatCap - 1; if (index < nFloatSize) { *dst = vFloatBuf[(base - index) % nFloatCap]; if (index > 0) { // Advance position of item one step forward if it is not the first one const uint32_t idx = (base - index) % nFloatCap; lsp::swap(vFloatBuf[idx], vFloatBuf[(idx + 1) % nFloatCap]); } return STATUS_OK; } float value; if (index == nFloatSize) { // Read index of base float nread = sStream.readv(&index, nFloatBits); if (nread != ssize_t(nFloatBits)) return (nread < 0) ? status_t(-nread) : STATUS_CORRUPTED; // Read delta size_t delta = 0; status_t res = read_varint(&delta); if (res != STATUS_OK) return res; // Compute floating-point value int32_t dvalue = zigzag_decode(int32_t(delta)); const int32_t image = vIntBuf[(base - index) % nFloatCap] + dvalue; value = bin_to_float(image); } else { // Read just the floating-point value int32_t image; nread = sStream.readv(&image); if (nread != ssize_t(sizeof(image) * 8)) return (nread < 0) ? status_t(-nread) : STATUS_CORRUPTED; value = bin_to_float(LE_TO_CPU(image)); } // Push item to buffer and return result vFloatBuf[nFloatHead] = value; nFloatHead = (nFloatHead + 1) % nFloatCap; if (nFloatSize < (nFloatCap - 2)) ++nFloatSize; // Return value *dst = value; return STATUS_OK; } status_t Decompressor::read_varint(size_t *dst) { size_t value = 0; size_t shift = 0; uint8_t b; do { ssize_t nread = sStream.readv(&b, 7); if (nread != 7) return (nread < 0) ? status_t(-nread) : STATUS_CORRUPTED; value |= size_t(b & 0x3f) << shift; shift += 6; } while (b & 0x40); *dst = value; return STATUS_OK; } status_t Decompressor::read_varint_icount(size_t *dst) { size_t bits = 3; size_t max = 1 << bits; size_t value = 0; size_t b = 0; size_t shift = 0; while (true) { ssize_t nread = sStream.readv(fixed_int(&b), bits + 1); if (nread != ssize_t(bits + 1)) return (nread < 0) ? status_t(-nread) : STATUS_CORRUPTED; // Decode value value |= (b & (max - 1)) << shift; if (!(b & max)) break; // Update bit count shift += bits; bits += 2; max <<= 2; } *dst = value; return STATUS_OK; } status_t Decompressor::read_indices(index_t *dst, size_t count, bool read) { if (!read) { for (size_t i=0; i(malloc(length * sizeof(char))); if (buf == NULL) return STATUS_NO_MEM; lsp_finally { free(buf); }; // Read UTF-8 sequence ssize_t nread = sStream.read_fully(buf, length); if (nread != ssize_t(length)) return (nread < 0) ? status_t(-nread) : STATUS_CORRUPTED; // Fill string with UTF-8 sequence if (!dst->set_utf8(buf, length)) return STATUS_NO_MEM; return STATUS_OK; } status_t Decompressor::parse_vertex(IObjHandler *handler, size_t coords) { float x = 0.0f, y = 0.0f, z = 0.0f, w = 1.0f; status_t res = read_float(&x); if (res == STATUS_OK) res = read_float(&y); if ((res == STATUS_OK) && (coords > 2)) res = read_float(&z); if ((res == STATUS_OK) && (coords > 3)) res = read_float(&w); if (res == STATUS_OK) res = status_t(handler->add_vertex(x, y, z, w)); return res; } status_t Decompressor::parse_pvertex(IObjHandler *handler, size_t coords) { float x = 0.0f, y = 0.0f, z = 0.0f, w = 1.0f; status_t res = read_float(&x); if (res == STATUS_OK) res = read_float(&y); if ((res == STATUS_OK) && (coords > 2)) res = read_float(&z); if ((res == STATUS_OK) && (coords > 3)) res = read_float(&w); if (res == STATUS_OK) res = status_t(handler->add_param_vertex(x, y, z, w)); return res; } status_t Decompressor::parse_normal(IObjHandler *handler, size_t coords) { float nx = 0.0f, ny = 0.0f, nz = 0.0f, nw = 0.0f; status_t res = read_float(&nx); if (res == STATUS_OK) res = read_float(&ny); if ((res == STATUS_OK) && (coords > 2)) res = read_float(&nz); if ((res == STATUS_OK) && (coords > 3)) res = read_float(&nw); if (res == STATUS_OK) res = status_t(handler->add_normal(nx, ny, nz, nw)); return res; } status_t Decompressor::parse_texcoord(IObjHandler *handler, size_t coords) { float u = 0.0f, v = 0.0f, w = 0.0f; status_t res = read_float(&u); if ((res == STATUS_OK) && (coords > 1)) res = read_float(&v); if ((res == STATUS_OK) && (coords > 2)) res = read_float(&w); if (res == STATUS_OK) res = status_t(handler->add_texture_vertex(u, v, w)); return res; } status_t Decompressor::parse_face(IObjHandler *handler, bool texcoords, bool normals, bool fill) { size_t count = 0; status_t res = read_varint_icount(&count); if (res != STATUS_OK) return res; lltl::darray data; if (!data.reserve(count * 3)) return STATUS_NO_MEM; index_t *vv = data.array(); index_t *vt = &vv[count]; index_t *vn = &vt[count]; if ((res = read_indices(vv, count, true)) != STATUS_OK) return res; if ((res = read_indices(vt, count, texcoords)) != STATUS_OK) return res; if (fill) { size_t index = 0; if ((res = read_varint_icount(&index)) != STATUS_OK) return res; for (size_t i=0; iadd_face(vv, vn, vt, count)); } status_t Decompressor::parse_line(IObjHandler *handler, bool texcoords) { size_t count = 0; status_t res = read_varint_icount(&count); if (res != STATUS_OK) return res; lltl::darray data; if (!data.reserve(count * 2)) return STATUS_NO_MEM; index_t *vv = data.array(); index_t *vt = &vv[count]; if ((res = read_indices(vv, count, true)) != STATUS_OK) return res; if ((res = read_indices(vt, count, texcoords)) != STATUS_OK) return res; return status_t(handler->add_line(vv, vt, count)); } status_t Decompressor::parse_points(IObjHandler *handler) { size_t count = 0; status_t res = read_varint_icount(&count); if (res != STATUS_OK) return res; lltl::darray data; if (!data.reserve(count)) return STATUS_NO_MEM; index_t *vv = data.array(); if ((res = read_indices(vv, count, true)) != STATUS_OK) return res; return status_t(handler->add_points(vv, count)); } status_t Decompressor::parse_object(IObjHandler *handler) { LSPString name; status_t res = read_utf8(&name); if (res != STATUS_OK) return res; return handler->begin_object(&name); } status_t Decompressor::parse_data(IObjHandler *handler) { status_t res = parse_header(); if (res != STATUS_OK) return res; size_t nobj = 0; compressed_event_type_t event; while ((res = read_event(&event)) == STATUS_OK) { if (event == CEV_EOF) break; switch (event) { case CEV_VERTEX2: res = parse_vertex(handler, 2); break; case CEV_VERTEX3: res = parse_vertex(handler, 3); break; case CEV_VERTEX4: res = parse_vertex(handler, 4); break; case CEV_PVERTEX2: res = parse_pvertex(handler, 2); break; case CEV_PVERTEX3: res = parse_pvertex(handler, 3); break; case CEV_PVERTEX4: res = parse_pvertex(handler, 4); break; case CEV_TEXCOORD1: res = parse_texcoord(handler, 1); break; case CEV_TEXCOORD2: res = parse_texcoord(handler, 2); break; case CEV_TEXCOORD3: res = parse_texcoord(handler, 3); break; case CEV_NORMAL2: res = parse_normal(handler, 2); break; case CEV_NORMAL3: res = parse_normal(handler, 3); break; case CEV_NORMAL4: res = parse_normal(handler, 4); break; case CEV_FACE: res = parse_face(handler, false, false, false); break; case CEV_FACE_T: res = parse_face(handler, true, false, false); break; case CEV_FACE_N: res = parse_face(handler, false, true, false); break; case CEV_FACE_NF: res = parse_face(handler, false, true, true); break; case CEV_FACE_TN: res = parse_face(handler, true, true, false); break; case CEV_FACE_TNF: res = parse_face(handler, true, true, true); break; case CEV_LINE: res = parse_line(handler, false); break; case CEV_LINE_T: res = parse_line(handler, true); break; case CEV_POINT: res = parse_points(handler); break; case CEV_OBJECT: if (nobj++) { if ((res = handler->end_object()) != STATUS_OK) return res; } res = parse_object(handler); break; default: return STATUS_CORRUPTED; } } // Post-process data if (res == STATUS_OK) { if (nobj > 0) { if ((res = handler->end_object()) != STATUS_OK) return res; } res = handler->end_of_data(); } return res; } } /* namespace obj */ } /* namespace lsp */