/* * Copyright (C) 2026 Linux Studio Plugins Project * (C) 2026 Vladimir Sadovnikov * * This file is part of lsp-runtime-lib * Created on: 16 мар. 2021 г. * * 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 #define BUFFER_QUANTITY 0x1000 namespace lsp { namespace resource { Decompressor::Decompressor() { sReplay.data = NULL; sReplay.off = 0; sReplay.size = 0; sReplay.cap = 0; sReplay.rep = 0; nOffset = 0; nSize = 0; } Decompressor::~Decompressor() { do_close(); } status_t Decompressor::do_close() { // Destroy compression buffer sBuffer.destroy(); // Destroy replay buffer if (sReplay.data != NULL) free(sReplay.data); // Clear values sReplay.data = NULL; sReplay.off = 0; sReplay.size = 0; sReplay.cap = 0; sReplay.rep = 0; nOffset = 0; nSize = 0; return sIn.close(); } status_t Decompressor::init(const void *data, size_t data_size, size_t decompressed_size, size_t log_buf_sz) { // Create buffer status_t res = sBuffer.init(log_buf_sz); if (res != STATUS_OK) return res; // Create input memory stream io::InMemoryStream *ims = new io::InMemoryStream(data, data_size); if (ims == NULL) return STATUS_NO_MEM; // Wrap input memory stream res = sIn.wrap(ims, WRAP_CLOSE | WRAP_DELETE); if (res != STATUS_OK) { ims->close(); delete ims; } // Update positions nOffset = 0; nSize = decompressed_size; // Clear replay buffer sReplay.off = 0; sReplay.size = 0; sReplay.cap = 0; return res; } status_t Decompressor::read_uint(size_t *out, size_t initial, size_t stepping) { ssize_t res; ssize_t bits = initial; size_t value = 0; bool flag; while (true) { if ((res = sIn.readb(&flag)) != 1) return (res < 0) ? status_t(-res) : STATUS_IO_ERROR; if (!flag) break; value += 1 << bits; bits += stepping; } fixed_size_t v = 0; if ((res = sIn.readv(&v, bits)) != bits) return (res < 0) ? status_t(-res) : STATUS_IO_ERROR; *out = value + size_t(v); return STATUS_OK; } status_t Decompressor::close() { return do_close(); } status_t Decompressor::set_buf(size_t off, size_t count, size_t rep) { // Need to allocate data? if ((sReplay.cap < count) || (sReplay.data == NULL)) { size_t cap = align_size(lsp_max(sReplay.cap + (sReplay.cap >> 1), count), BUFFER_QUANTITY); uint8_t *ptr = reinterpret_cast(realloc(sReplay.data, cap)); if (ptr == NULL) return STATUS_NO_MEM; sReplay.data = ptr; sReplay.cap = cap; } // Copy data to replay buffer status_t res = sBuffer.extract(sReplay.data, off, count); if (res != STATUS_OK) return res; sReplay.off = 0; sReplay.size = count; sReplay.rep = rep; return STATUS_OK; } status_t Decompressor::set_bufc(uint8_t c, size_t rep) { // Need to allocate data? if ((sReplay.cap < 1) || (sReplay.data == NULL)) { uint8_t *ptr = reinterpret_cast(realloc(sReplay.data, BUFFER_QUANTITY)); if (ptr == NULL) return STATUS_NO_MEM; sReplay.data = ptr; sReplay.cap = BUFFER_QUANTITY; } // Copy data to replay buffer sReplay.data[0] = c; sReplay.off = 0; sReplay.size = 1; sReplay.rep = rep; return STATUS_OK; } size_t Decompressor::get_buf(uint8_t *dst, size_t count) { size_t nread = 0; // Check for data available in buffer size_t avail = sReplay.size - sReplay.off; if (avail > 0) { avail = lsp_min(avail, count); memcpy(dst, &sReplay.data[sReplay.off], avail); sReplay.off += avail; dst += avail; nread += avail; if (nread >= count) return nread; } // Now check if there are any repeats available if (sReplay.rep > 0) { avail = lsp_min(sReplay.rep, count - nread); memset(dst, sReplay.data[sReplay.off-1], avail); sReplay.rep -= avail; nread += avail; } return nread; } ssize_t Decompressor::get_bufc() { if (sReplay.off < sReplay.size) return sReplay.data[sReplay.off++]; if (sReplay.rep <= 0) return -STATUS_EOF; --sReplay.rep; return sReplay.data[sReplay.off-1]; } status_t Decompressor::fill_buf() { // Check that data is present in the buffer if ((sReplay.off < sReplay.size) || (sReplay.rep > 0)) return STATUS_OK; status_t res; size_t offset = 0, length = 0, rep = 0, append = 0; uint8_t b; // Read offset if ((res = read_uint(&offset, 5, 5)) != STATUS_OK) return res; if (offset < sBuffer.size()) { // REPLAY BUFFER // Length if ((res = read_uint(&length, 5, 5)) != STATUS_OK) return res; // Repeat if ((res = read_uint(&rep, 0, 4)) != STATUS_OK) return res; // Fill replay buffer with data length += 1; if ((res = set_buf(offset, length, rep)) != STATUS_OK) return res; // Append decompression buffer b = sReplay.data[length - 1]; append = lsp_min(rep, REPEAT_BUF_MAX); sBuffer.append(sReplay.data, length); } else { // EMIT OCTET // Repeat if ((res = read_uint(&rep, 0, 4)) != STATUS_OK) return res; b = offset - sBuffer.size(); append = lsp_min(rep, REPEAT_BUF_MAX) + 1; // Fill replay buffer with data if ((res = set_bufc(b, rep)) != STATUS_OK) return res; } // Append decompression buffer while (append--) sBuffer.append(b); return STATUS_OK; } ssize_t Decompressor::read(void *dst, size_t count) { status_t res; uint8_t *d = reinterpret_cast(dst); size_t nread = 0; while (nread < count) { // Check offset if (nOffset >= nSize) { if (nread <= 0) return -set_error(STATUS_EOF); break; } // Check if data has been read size_t bufrd = get_buf(&d[nread], count - nread); if (bufrd > 0) { nOffset += bufrd; nread += bufrd; continue; } // There is no data in the buffer, try to get new data if ((res = fill_buf()) != STATUS_OK) { if (nread > 0) break; set_error(res); return -res; } } set_error(STATUS_OK); return nread; } ssize_t Decompressor::read_byte() { ssize_t res; if (nOffset >= nSize) return -set_error(STATUS_EOF); do { // Check if data has been read res = get_bufc(); if (res >= 0) { ++nOffset; return res; } } while ((res = fill_buf()) == STATUS_OK); set_error(status_t(res)); return res; } wssize_t Decompressor::position() { return nOffset; } } /* namespace resource */ } /* namespace lsp */