/* * Copyright (C) 2026 Linux Studio Plugins Project * (C) 2026 Vladimir Sadovnikov * * This file is part of lsp-runtime-lib * Created on: 17 янв. 2026 г. * * 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 io { InBufStream::InBufStream(size_t buf_size) { pIS = NULL; vBuffer = NULL; nBufCap = uint32_t(buf_size); nBufHead = 0; nBufOff = 0; nBufSize = 0; nPosition = 0; nWrapFlags = EXT_BUFFERING; } InBufStream::~InBufStream() { do_close(); } inline void InBufStream::clear_buffer() { nBufHead = 0; nBufOff = 0; nBufSize = 0; } status_t InBufStream::do_close() { status_t res = STATUS_OK; // Close file descriptor if (pIS != NULL) { // Perform close if (nWrapFlags & WRAP_CLOSE) res = pIS->close(); if (nWrapFlags & WRAP_DELETE) delete pIS; pIS = NULL; } nWrapFlags &= ~WRAP_FULL; // Free the buffer if (vBuffer != NULL) { free(vBuffer); vBuffer = NULL; } clear_buffer(); return res; } status_t InBufStream::close() { if (pIS == NULL) return STATUS_OK; status_t res = do_close(); return set_error(res); } bool InBufStream::init_buffer() { if (nBufCap <= 0) return false; if (vBuffer == NULL) { vBuffer = static_cast(malloc(nBufCap)); if (vBuffer == NULL) return false; } clear_buffer(); return true; } status_t InBufStream::do_wrap(IInStream *is, size_t flags) { // Obtain the position of the input stream wssize_t pos = is->position(); if (pos < 0) { if (pos != -STATUS_NOT_IMPLEMENTED) return pos; else pos = 0; } // Check buffer capacity if (nBufCap <= 0) return STATUS_BAD_STATE; // Store pointers pIS = is; nWrapFlags = (nWrapFlags & (~uint32_t(WRAP_FULL))) | (uint32_t(flags) & WRAP_FULL); nPosition = pos; return STATUS_OK; } status_t InBufStream::open(const char *path) { if (pIS != NULL) return set_error(STATUS_BAD_STATE); if (!init_buffer()) return set_error(STATUS_NO_MEM); status_t res; InFileStream *ofs = new InFileStream(); if (ofs == NULL) return set_error(STATUS_NO_MEM); if ((res = ofs->open(path)) == STATUS_OK) res = do_wrap(ofs, WRAP_CLOSE | WRAP_DELETE); if (res != STATUS_OK) { ofs->close(); delete ofs; } return set_error(res); } status_t InBufStream::open(const LSPString *path) { if (pIS != NULL) return set_error(STATUS_BAD_STATE); if (!init_buffer()) return set_error(STATUS_NO_MEM); status_t res; InFileStream *ofs = new InFileStream(); if (ofs == NULL) return set_error(STATUS_NO_MEM); if ((res = ofs->open(path)) == STATUS_OK) res = do_wrap(ofs, WRAP_CLOSE | WRAP_DELETE); if (res != STATUS_OK) { ofs->close(); delete ofs; } return set_error(res); } status_t InBufStream::open(const Path *path) { if (pIS != NULL) return set_error(STATUS_BAD_STATE); if (!init_buffer()) return set_error(STATUS_NO_MEM); status_t res; InFileStream *ofs = new InFileStream(); if (ofs == NULL) return set_error(STATUS_NO_MEM); if ((res = ofs->open(path)) == STATUS_OK) res = do_wrap(ofs, WRAP_CLOSE | WRAP_DELETE); if (res != STATUS_OK) { ofs->close(); delete ofs; } return set_error(res); } status_t InBufStream::wrap(FILE *fd, bool close) { if (pIS != NULL) return set_error(STATUS_BAD_STATE); if (!init_buffer()) return set_error(STATUS_NO_MEM); status_t res; InFileStream *ofs = new InFileStream(); if (ofs == NULL) return set_error(STATUS_NO_MEM); if ((res = ofs->wrap(fd, close)) == STATUS_OK) res = do_wrap(ofs, WRAP_CLOSE | WRAP_DELETE); if (res != STATUS_OK) { ofs->close(); delete ofs; } return set_error(res); } status_t InBufStream::wrap_native(fhandle_t fd, bool close) { if (pIS != NULL) return set_error(STATUS_BAD_STATE); if (!init_buffer()) return set_error(STATUS_NO_MEM); status_t res; InFileStream *ofs = new InFileStream(); if (ofs == NULL) return set_error(STATUS_NO_MEM); if ((res = ofs->wrap_native(fd, close)) == STATUS_OK) res = do_wrap(ofs, WRAP_CLOSE | WRAP_DELETE); if (res != STATUS_OK) { ofs->close(); delete ofs; } return set_error(res); } status_t InBufStream::wrap(File *fd, size_t flags) { if (pIS != NULL) return set_error(STATUS_BAD_STATE); if (!init_buffer()) return set_error(STATUS_NO_MEM); status_t res; InFileStream *ofs = new InFileStream(); if (ofs == NULL) return set_error(STATUS_NO_MEM); if ((res = ofs->wrap(fd, flags)) == STATUS_OK) res = do_wrap(ofs, WRAP_CLOSE | WRAP_DELETE); if (res != STATUS_OK) { ofs->close(); delete ofs; } return set_error(res); } status_t InBufStream::wrap(IInStream *is, size_t flags) { if (pIS != NULL) return set_error(STATUS_BAD_STATE); else if (is == NULL) return set_error(STATUS_BAD_ARGUMENTS); if (!init_buffer()) return set_error(STATUS_NO_MEM); return set_error(do_wrap(is, flags)); } void InBufStream::set_buffering(bool enable) { nWrapFlags = lsp_setflag(nWrapFlags, EXT_BUFFERING, enable); } void InBufStream::set_seek_buffering(bool enable) { nWrapFlags = lsp_setflag(nWrapFlags, EXT_SEEK_BUFFERING, enable); } wssize_t InBufStream::avail() { const wssize_t res = pIS->avail(); if (res < 0) return -set_error(status_t(-res)); return res + nBufSize - nBufOff; } // Fixing GCC 16.1 false positive warnings #ifdef COMPILER_GCC #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Warray-bounds" #endif /* COMPILER_GCC */ wssize_t InBufStream::position() { return nPosition + nBufOff; } #ifdef COMPILER_GCC #pragma GCC diagnostic pop #endif /* COMPILER_GCC */ ssize_t InBufStream::read_byte() { if (pIS == NULL) return set_error(STATUS_BAD_STATE); // Check that byte is cached in buffer if (nBufOff < nBufSize) { const uint8_t byte = vBuffer[(nBufHead + nBufOff++) % nBufCap]; set_error(STATUS_OK); return byte; } // Fetch new byte ssize_t res = pIS->read_byte(); if (res < 0) return -set_error(status_t(-res)); // Push byte to buffer if (nWrapFlags & EXT_BUFFERING) { vBuffer[(nBufHead + nBufOff) % nBufCap] = uint8_t(res); if (nBufOff >= nBufHead) { nBufHead = (nBufHead + 1) % nBufCap; ++nPosition; } else nBufSize = ++nBufOff; } else { nPosition += nBufSize + 1; nBufSize = 0; } return res; } wssize_t InBufStream::seek(wsize_t position) { if (pIS == NULL) return set_error(STATUS_BAD_STATE); // Do quick positioning if possible if ((position >= nPosition) && (position <= (nPosition + nBufSize))) { nBufOff = uint32_t(position - nPosition); return position; } // Check that buffering is enabled wssize_t res; if ((nWrapFlags & (EXT_BUFFERING | EXT_SEEK_BUFFERING)) != (EXT_BUFFERING | EXT_SEEK_BUFFERING)) { if ((res = pIS->seek(position)) < 0) return -set_error(-status_t(res)); clear_buffer(); nPosition = res; return res; } // Forward seek? if (position >= nPosition) { res = skip(position - nBufSize + nBufOff); if (res < 0) return res; return this->position(); } // Backward seek const wssize_t start = lsp_max(wssize_t(position) - wssize_t(nBufCap), wssize_t(0)); if ((res = pIS->seek(start)) < 0) return -set_error(-status_t(res)); // Perform read ssize_t nread = pIS->read(vBuffer, nBufCap); if (nread < 0) return -set_error(-status_t(nread)); else if (wsize_t(start + nread) < position) return -set_error(STATUS_CORRUPTED); // Update buffer position nBufHead = 0; nBufOff = uint32_t(position - start); nBufSize = uint32_t(nread); nPosition = start; set_error(STATUS_OK); return position; } ssize_t InBufStream::read(void *dst, size_t count) { if (pIS == NULL) return set_error(STATUS_BAD_STATE); size_t avail, head, split; size_t nread = 0; uint8_t *dptr = static_cast(dst); // Check that bytes are cached in buffer avail = uint32_t(lsp_min(count, size_t(nBufSize - nBufOff))); if (avail > 0) { head = (nBufHead + nBufOff) % nBufCap; if ((head + avail) > nBufCap) { split = nBufCap - head; memcpy(dptr, &vBuffer[head], split); memcpy(&dptr[split], vBuffer, avail - split); } else memcpy(dptr, &vBuffer[head], avail); nBufOff += uint32_t(avail); nread += avail; dptr += avail; } if (nread >= count) { set_error(STATUS_OK); return nread; } // Perform read ssize_t res = pIS->read(dptr, count - nread); if (res < 0) return (nread > 0) ? ssize_t(nread) : -set_error(status_t(-res)); nread += ssize_t(res); // Fill buffer with the data if (nWrapFlags & EXT_BUFFERING) { avail = nBufCap - nBufOff; if (size_t(res) >= nBufCap) { // Need to replace full buffer dptr += res - nBufCap; memcpy(vBuffer, dptr, nBufCap); nPosition = nPosition + nBufSize + res - nBufCap; nBufSize = nBufCap; nBufHead = 0; nBufOff = nBufCap; } else { // Append to the end of buffer avail = lsp_min(size_t(res), size_t(nBufCap)); dptr += res - avail; // Copy data head = (nBufHead + nBufOff) % nBufCap; if ((head + avail) > nBufCap) { split = nBufCap - head; memcpy(&vBuffer[head], dptr, split); memcpy(vBuffer, &dptr[split], avail - split); } else memcpy(&vBuffer[head], dptr, avail); // Update position nBufOff += res; if (nBufOff > nBufCap) { split = nBufOff % nBufCap; nBufHead = (nBufHead + split) % nBufCap; nBufSize = nBufCap; nBufOff = nBufCap; nPosition += split; } else nBufSize = nBufOff; } } else { nPosition += nBufSize + nread; nBufSize = 0; } return nread; } wssize_t InBufStream::skip(wsize_t amount) { if (pIS == NULL) return set_error(STATUS_BAD_STATE); // Do quick skip if possible uint32_t head, split; wsize_t skipped = 0; if (nBufOff < nBufSize) { split = uint32_t(lsp_min(amount, wsize_t(nBufSize - nBufOff))); nBufOff += uint32_t(split); skipped += split; if (skipped >= amount) return skipped; } // Check that buffering is enabled if ((nWrapFlags & (EXT_BUFFERING | EXT_SEEK_BUFFERING)) != (EXT_BUFFERING | EXT_SEEK_BUFFERING)) { wssize_t res = pIS->skip(amount - skipped); if (res < 0) return -set_error(-status_t(res)); nPosition = nPosition + nBufOff + res; clear_buffer(); return res; } // Do buffered skip using underlying read() operations while (skipped < amount) { head = (nBufHead + nBufOff) % nBufCap; split = uint32_t(lsp_min(amount - skipped, wsize_t(nBufCap - head))); ssize_t nread = pIS->read(&vBuffer[head], split); if (nread <= 0) return skipped; nBufOff += uint32_t(nread); if (nBufOff > nBufCap) { split = nBufOff - nBufCap; nBufHead += split; nBufSize = nBufCap; nBufOff = nBufCap; nPosition += split; } else nBufSize = nBufOff; skipped += nread; } return skipped; } } /* namespaec io */ } /* namespace lsp */