/* * Copyright (C) 2025 Linux Studio Plugins Project * (C) 2025 Vladimir Sadovnikov * * This file is part of lsp-runtime-lib * Created on: 23 июл. 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 namespace lsp { namespace obj { typedef struct c_event_t { uint8_t code; uint8_t bits; } c_event_t; static const c_event_t event_codes[] = { { 0x0b, 4 }, // CEV_OBJECT { 0x3a, 6 }, // CEV_VERTEX2 { 0x00, 3 }, // CEV_VERTEX3 { 0x78, 7 }, // CEV_VERTEX4 { 0x79, 7 }, // CEV_PVERTEX2 { 0x1a, 5 }, // CEV_PVERTEX3 { 0x7a, 7 }, // CEV_PVERTEX4 { 0x3b, 6 }, // CEV_NORMAL2 { 0x01, 3 }, // CEV_NORMAL3 { 0x7b, 7 }, // CEV_NORMAL4 { 0xf8, 8 }, // CEV_TEXCOORD1 { 0x08, 4 }, // CEV_TEXCOORD2 { 0xf9, 8 }, // CEV_TEXCOORD3 { 0x03, 3 }, // CEV_FACE { 0x18, 5 }, // CEV_FACE_T { 0x02, 3 }, // CEV_FACE_N { 0x09, 4 }, // CEV_FACE_NF { 0x19, 5 }, // CEV_FACE_TN { 0x0a, 4 }, // CEV_FACE_TNF { 0x1b, 5 }, // CEV_LINE { 0x38, 6 }, // CEV_LINE_T { 0x39, 6 }, // CEV_POINT { 0xfb, 8 }, // CEV_EOF }; static inline int32_t float_to_bin(float v) { union { float f32; int32_t i32; } cvt; cvt.f32 = v; return cvt.i32; } static inline uint32_t zigzag_encode(int32_t value) { return (value >> 31) ^ (value << 1); } Compressor::Compressor() { pOut = NULL; vFloatBuf = NULL; nFloatHead = 0; nFloatSize = 0; nFloatCap = 0; nFloatBits = 0; nLastEvent = -1; nWFlags = 0; } Compressor::~Compressor() { close(); if (vFloatBuf != NULL) { free(vFloatBuf); vFloatBuf = NULL; } } status_t Compressor::do_wrap(io::OutBitStream * & obs, size_t flags) { compressed_header_t hdr; hdr.signature = COMPRESSED_SIGNATURE; hdr.version = 0; hdr.float_bits = uint8_t(nFloatBits); hdr.pad[0] = 'L'; hdr.pad[1] = 'S'; ssize_t written = obs->write(&hdr, sizeof(compressed_header_t)); if (written != sizeof(compressed_header_t)) return STATUS_IO_ERROR; pOut = release_ptr(obs); nFloatHead = 0; nFloatSize = 0; nWFlags = flags; return STATUS_OK; } status_t Compressor::open(const char *path, size_t mode) { if (vFloatBuf == NULL) return STATUS_BAD_STATE; if (pOut != NULL) return STATUS_OPENED; io::OutBitStream *obs = new io::OutBitStream(); if (obs == NULL) return STATUS_NO_MEM; lsp_finally { if (obs != NULL) { obs->close(); delete obs; } }; status_t res = obs->open(path, mode); if (res == STATUS_OK) res = do_wrap(obs); return res; } status_t Compressor::open(const LSPString *path, size_t mode) { if (vFloatBuf == NULL) return STATUS_BAD_STATE; if (pOut != NULL) return STATUS_OPENED; io::OutBitStream *obs = new io::OutBitStream(); if (obs == NULL) return STATUS_NO_MEM; lsp_finally { if (obs != NULL) { obs->close(); delete obs; } }; status_t res = obs->open(path, mode); if (res == STATUS_OK) res = do_wrap(obs); return res; } status_t Compressor::open(const io::Path *path, size_t mode) { if (vFloatBuf == NULL) return STATUS_BAD_STATE; if (pOut != NULL) return STATUS_OPENED; io::OutBitStream *obs = new io::OutBitStream(); if (obs == NULL) return STATUS_NO_MEM; lsp_finally { if (obs != NULL) { obs->close(); delete obs; } }; status_t res = obs->open(path, mode); if (res == STATUS_OK) res = do_wrap(obs); return res; } status_t Compressor::wrap(FILE *fd, bool close) { if (vFloatBuf == NULL) return STATUS_BAD_STATE; if (pOut != NULL) return STATUS_OPENED; io::OutBitStream *obs = new io::OutBitStream(); if (obs == NULL) return STATUS_NO_MEM; lsp_finally { if (obs != NULL) { obs->close(); delete obs; } }; status_t res = obs->wrap(fd, close); if (res == STATUS_OK) res = do_wrap(obs); return res; } status_t Compressor::wrap_native(fhandle_t fd, bool close) { if (vFloatBuf == NULL) return STATUS_BAD_STATE; if (pOut != NULL) return STATUS_OPENED; io::OutBitStream *obs = new io::OutBitStream(); if (obs == NULL) return STATUS_NO_MEM; lsp_finally { if (obs != NULL) { obs->close(); delete obs; } }; status_t res = obs->wrap_native(fd, close); if (res == STATUS_OK) res = do_wrap(obs); return res; } status_t Compressor::wrap(io::File *fd, size_t flags) { if (vFloatBuf == NULL) return STATUS_BAD_STATE; if (pOut != NULL) return STATUS_OPENED; io::OutBitStream *obs = new io::OutBitStream(); if (obs == NULL) return STATUS_NO_MEM; lsp_finally { if (obs != NULL) { obs->close(); delete obs; } }; status_t res = obs->wrap(fd, flags); if (res == STATUS_OK) res = do_wrap(obs); return res; } status_t Compressor::wrap(io::IOutStream *os, size_t flags) { if (vFloatBuf == NULL) return STATUS_BAD_STATE; if (pOut != NULL) return STATUS_OPENED; io::OutBitStream *obs = new io::OutBitStream(); if (obs == NULL) return STATUS_NO_MEM; lsp_finally { if (obs != NULL) { obs->close(); delete obs; } }; status_t res = obs->wrap(os, flags); if (res == STATUS_OK) res = do_wrap(obs); return res; } status_t Compressor::wrap(io::OutBitStream *obs, size_t flags) { if (vFloatBuf == NULL) return STATUS_BAD_STATE; if (pOut != NULL) return STATUS_OPENED; return do_wrap(obs, flags); } status_t Compressor::close() { if (pOut == NULL) return STATUS_OK; // Write End-of-File signature status_t res = write_event(CEV_EOF); if (nWFlags & WRAP_CLOSE) res = update_status(res, pOut->close()); if (nWFlags & WRAP_DELETE) delete pOut; pOut = NULL; return res; } status_t Compressor::set_buffer_size(size_t float_bits) { if ((float_bits > MAX_FLOAT_BUF_BITS) || (float_bits < MIN_FLOAT_BUF_BITS)) return STATUS_INVALID_VALUE; // We can only change buffer size if there is no active operations. if (pOut != NULL) return STATUS_BAD_STATE; // Check that there is nothing to change const size_t float_cap = 1 << float_bits; if (float_cap != nFloatCap) { // Re-allocate data float *ptr = static_cast(realloc(vFloatBuf, float_cap * sizeof(float))); if (ptr == NULL) return STATUS_NO_MEM; vFloatBuf = ptr; } nFloatCap = uint32_t(float_cap); nFloatBits = uint32_t(float_bits); return STATUS_OK; } status_t Compressor::write_event(uint32_t event) { const c_event_t *code = &event_codes[event]; if (nLastEvent == code->code) return pOut->bwrite(true); nLastEvent = code->code; return pOut->writev(code->code, code->bits + 1); } status_t Compressor::write_varint(size_t value) { do { const uint8_t b = (value >= 0x40) ? 0x40 | (value & 0x3f) : value; value >>= 6; status_t res = pOut->writev(b, 7); if (res != STATUS_OK) return res; } while (value > 0); return STATUS_OK; } status_t Compressor::write_varint_icount(size_t value) { size_t bits = 3; size_t max = 1 << bits; do { const size_t b = (value >= max) ? max | (value & (max - 1)) : value; status_t res = pOut->writev(fixed_int(b), bits + 1); if (res != STATUS_OK) return res; // Update count value >>= bits; bits += 2; max <<= 2; } while (value > 0); return STATUS_OK; } status_t Compressor::write_utf8(const char *text) { const size_t bytes = strlen(text); status_t res = write_varint(bytes); if (res == STATUS_OK) { ssize_t written = pOut->write(text, bytes); if (written < 0) return status_t(-written); else if (size_t(written) != bytes) return STATUS_IO_ERROR; } return res; } status_t Compressor::write_float(float value) { // Step 1 // Find index of float in buffer int32_t index = -1; const uint32_t base = nFloatHead + nFloatCap - 1; const int32_t image = float_to_bin(value); for (size_t i=0; i 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]); // We're ready to emit index return pOut->writev(index, nFloatBits); } else if (index == 0) { // We're ready to emit index return pOut->writev(index, nFloatBits); } // Step 2 // Find nearest relative float uint32_t delta = 0x7fffffff; index = -1; for (size_t i=0; i 0x1ffff) || (diff < -0x20000)) continue; // Convert to zigzag representation and compare with previous value for minimization const uint32_t dval = zigzag_encode(diff); if (dval < delta) { index = int32_t(i); delta = dval; break; } } // Emit new floating-point value if we can do an incremental coding status_t res; if (index >= 0) { res = pOut->writev(nFloatSize, nFloatBits); // Indicate that new incremental value has been added if (res == STATUS_OK) res = pOut->writev(index, nFloatBits); // Write index of original floating-point if (res == STATUS_OK) res = write_varint(delta); // Write delta } else { res = pOut->writev(nFloatSize + 1, nFloatBits); // Indicate that new value has been added if (res == STATUS_OK) res = pOut->writev(CPU_TO_LE(image)); } // Push item to buffer vFloatBuf[nFloatHead] = value; nFloatHead = (nFloatHead + 1) % nFloatCap; if (nFloatSize < (nFloatCap - 2)) ++nFloatSize; return res; } status_t Compressor::write_indices(const index_t *value, size_t count) { int32_t delta = int32_t(value[0]); status_t res = write_varint_icount(zigzag_encode(delta)); if (res != STATUS_OK) return res; for (size_t i=1; i= 0) return true; return false; } bool Compressor::has_equal_indices(const index_t *v, size_t count) { for (size_t i=0; iget_utf8(); if (text == NULL) return STATUS_NO_MEM; status_t res = write_event(CEV_OBJECT); if (res == STATUS_OK) res = write_utf8(text); return res; } status_t Compressor::end_object() { if ((pOut == NULL) || (vFloatBuf == NULL)) return STATUS_BAD_STATE; return STATUS_OK; } status_t Compressor::end_of_data() { if ((pOut == NULL) || (vFloatBuf == NULL)) return STATUS_BAD_STATE; return STATUS_OK; } ssize_t Compressor::add_vertex(float x, float y, float z, float w) { if ((pOut == NULL) || (vFloatBuf == NULL)) return STATUS_BAD_STATE; const uint32_t ev = (w != 1.0f) ? CEV_VERTEX4 : (z != 0.0f) ? CEV_VERTEX3 : CEV_VERTEX2; status_t res = write_event(ev); if (res == STATUS_OK) res = write_float(x); if (res == STATUS_OK) res = write_float(y); if ((res == STATUS_OK) && (ev >= CEV_VERTEX3)) res = write_float(z); if ((res == STATUS_OK) && (ev >= CEV_VERTEX4)) res = write_float(w); return res; } ssize_t Compressor::add_param_vertex(float x, float y, float z, float w) { if ((pOut == NULL) || (vFloatBuf == NULL)) return STATUS_BAD_STATE; const uint32_t ev = (w != 1.0f) ? CEV_PVERTEX4 : (z != 0.0f) ? CEV_PVERTEX3 : CEV_PVERTEX2; status_t res = write_event(ev); if (res == STATUS_OK) res = write_float(x); if (res == STATUS_OK) res = write_float(y); if ((res == STATUS_OK) && (ev >= CEV_PVERTEX3)) res = write_float(z); if ((res == STATUS_OK) && (ev >= CEV_PVERTEX4)) res = write_float(w); return res; } ssize_t Compressor::add_normal(float nx, float ny, float nz, float nw) { if ((pOut == NULL) || (vFloatBuf == NULL)) return STATUS_BAD_STATE; if ((pOut == NULL) || (vFloatBuf == NULL)) return STATUS_BAD_STATE; const uint32_t ev = (nw != 0.0f) ? CEV_NORMAL4 : (nz != 0.0f) ? CEV_NORMAL3 : CEV_NORMAL2; status_t res = write_event(ev); if (res == STATUS_OK) res = write_float(nx); if (res == STATUS_OK) res = write_float(ny); if ((res == STATUS_OK) && (ev >= CEV_NORMAL3)) res = write_float(nz); if ((res == STATUS_OK) && (ev >= CEV_NORMAL4)) res = write_float(nw); return res; } ssize_t Compressor::add_texture_vertex(float u, float v, float w) { if ((pOut == NULL) || (vFloatBuf == NULL)) return STATUS_BAD_STATE; const uint32_t ev = (w != 0.0f) ? CEV_TEXCOORD3 : (v != 0.0f) ? CEV_TEXCOORD2 : CEV_TEXCOORD1; status_t res = write_event(ev); if (res == STATUS_OK) res = write_float(u); if ((res == STATUS_OK) && (ev >= CEV_TEXCOORD2)) res = write_float(v); if ((res == STATUS_OK) && (ev >= CEV_TEXCOORD3)) res = write_float(w); return res; } ssize_t Compressor::add_face(const index_t *vv, const index_t *vn, const index_t *vt, size_t n) { if ((pOut == NULL) || (vFloatBuf == NULL)) return STATUS_BAD_STATE; const bool equal_normals= has_equal_indices(vn, n); const bool has_normals = (vn[0] >= 0) || (!equal_normals); const bool has_texcoord = has_nonempty_index(vt, n); const compressed_event_type_t ev = (has_texcoord) ? ((has_normals) ? ((equal_normals) ? CEV_FACE_TNF : CEV_FACE_TN) : CEV_FACE_T) : ((has_normals) ? ((equal_normals) ? CEV_FACE_NF : CEV_FACE_N) : CEV_FACE); status_t res = write_event(ev); if (res == STATUS_OK) res = write_varint_icount(n); if (res == STATUS_OK) res = write_indices(vv, n); if ((res == STATUS_OK) && (has_texcoord)) res = write_indices(vt, n); if ((res == STATUS_OK) && (has_normals)) { if (equal_normals) res = write_varint_icount(vn[0]); // Write the fill index else res = write_indices(vn, n); } return res; } ssize_t Compressor::add_points(const index_t *vv, size_t n) { if ((pOut == NULL) || (vFloatBuf == NULL)) return STATUS_BAD_STATE; const uint32_t ev = CEV_POINT; status_t res = write_event(ev); if (res == STATUS_OK) res = write_varint_icount(n); if (res == STATUS_OK) res = write_indices(vv, n); return res; } ssize_t Compressor::add_line(const index_t *vv, const index_t *vt, size_t n) { if ((pOut == NULL) || (vFloatBuf == NULL)) return STATUS_BAD_STATE; const bool has_texcoord = has_nonempty_index(vt, n); const uint32_t ev = (has_texcoord) ? CEV_LINE_T : CEV_LINE; status_t res = write_event(ev); if (res == STATUS_OK) res = write_varint_icount(n); if (res == STATUS_OK) res = write_indices(vv, n); if ((res == STATUS_OK) && (has_texcoord)) res = write_indices(vt, n); return res; } } /* namespace obj */ } /* namespace lsp */