/* * Copyright (C) 2025 Linux Studio Plugins Project * (C) 2025 Vladimir Sadovnikov * * This file is part of lsp-runtime-lib * Created on: 12 февр. 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 #define MARKSEQ_SIZE 0x400 namespace lsp { namespace io { InMarkSequence::InMarkSequence() { pSequence = NULL; nMarkPos = 0; nMarkLen = -1; nMarkMax = 0; pBuf = NULL; nBufCap = 0; bClose = false; } InMarkSequence::~InMarkSequence() { do_close(); } status_t InMarkSequence::wrap(IInSequence *in, bool close) { if (in == NULL) return set_error(STATUS_BAD_ARGUMENTS); if (pSequence != NULL) return set_error(STATUS_BAD_STATE); pSequence = in; bClose = close; clear_mark(); return set_error(STATUS_OK); } status_t InMarkSequence::do_close() { status_t res = STATUS_OK; if ((pSequence != NULL) && (bClose)) res = pSequence->close(); pSequence = NULL; bClose = false; clear_mark(); return res; } status_t InMarkSequence::close() { status_t res = do_close(); return set_error(res); } ssize_t InMarkSequence::grow_buffer(size_t amount) { size_t last = lsp_min(nMarkMax, ssize_t(nMarkPos + amount)); if (last <= nBufCap) return nBufCap - nMarkPos; last = lsp_min(last, size_t(MARKSEQ_SIZE)); size_t cap = lsp_max(last, (nBufCap + (nBufCap >> 1))); lsp_wchar_t *buf = reinterpret_cast(realloc(pBuf, sizeof(lsp_wchar_t) * cap)); if (buf == NULL) return -STATUS_NO_MEM; pBuf = buf; nBufCap = cap; return cap - nMarkPos; } void InMarkSequence::clear_mark() { nMarkPos = 0; nMarkLen = 0; nMarkMax = -1; if (pBuf != NULL) free(pBuf); pBuf = NULL; nBufCap = 0; } ssize_t InMarkSequence::read(lsp_wchar_t *dst, size_t count) { ssize_t nread; if (pSequence == NULL) return -set_error(STATUS_CLOSED); // Simple read if there is no mark set or mark buffer is full if (nMarkMax < 0) { nread = pSequence->read(dst, count); if (nread < 0) set_error(status_t(-nread)); return nread; } // Fetch all pending characters from the buffer size_t total = 0; nread = lsp_min(count, size_t(nMarkLen - nMarkPos)); if (nread > 0) { memcpy(dst, &pBuf[nMarkPos], sizeof(lsp_wchar_t) * nread); nMarkPos += nread; total += nread; dst += nread; if ((count -= nread) <= 0) { set_error(STATUS_OK); return total; } } // Read data to buffer and emit to output while (nMarkPos < nMarkMax) { // Grow buffer ssize_t avail = grow_buffer(MARKSEQ_SIZE); if (avail < 0) return -set_error(STATUS_NO_MEM); if (avail > ssize_t(count)) avail = count; // Read data nread = pSequence->read(&pBuf[nMarkPos], avail); if (nread < 0) { if (total > 0) { set_error(STATUS_OK); return total; } set_error(status_t(-nread)); return nread; } // Copy data and pdate positions memcpy(dst, &pBuf[nMarkPos], sizeof(lsp_wchar_t) * nread); nMarkPos += nread; nMarkLen += nread; total += nread; dst += nread; if ((count -= nread) <= 0) { set_error(STATUS_OK); return total; } } // Reset mark if we are out of buffer and return nread = pSequence->read(dst, count); if (nread > 0) { set_error(STATUS_OK); clear_mark(); return total + nread; } else if (total > 0) { set_error(STATUS_OK); return total; } set_error(status_t(-nread)); return nread; } lsp_swchar_t InMarkSequence::read() { lsp_swchar_t ch; if (pSequence == NULL) return -set_error(STATUS_CLOSED); // Simple read if there is no mark set or mark buffer is full if (nMarkMax < 0) { ch = pSequence->read(); set_error((ch < 0) ? -ch : STATUS_OK); return ch; } // Check that we should read from buffer if (nMarkPos < nMarkLen) { set_error(STATUS_OK); return pBuf[nMarkPos++]; } // Read the character ch = pSequence->read(); if (ch < 0) { set_error(-ch); return ch; } // Reset mark if we are out of buffer and return if (nMarkPos >= nMarkMax) { set_error(STATUS_OK); clear_mark(); return ch; } // Push character to buffer, update counters and return if (grow_buffer(1) < 0) return -set_error(STATUS_NO_MEM); set_error(STATUS_OK); nMarkLen++; pBuf[nMarkPos++] = ch; return ch; } ssize_t InMarkSequence::skip(size_t count) { if (pSequence == NULL) return -set_error(STATUS_CLOSED); // No mark set? if (nMarkMax < 0) { ssize_t res = pSequence->skip(count); set_error((res < 0) ? status_t(-res) : STATUS_OK); return res; } // Skip all pending characters in the buffer size_t skipped = 0; ssize_t step = lsp_min(count, size_t(nMarkLen - nMarkPos)); nMarkPos += step; skipped += step; if ((count -= skipped) <= 0) { set_error(STATUS_OK); return skipped; } // Read data to buffer while (nMarkPos < nMarkMax) { // Grow buffer ssize_t avail = grow_buffer(MARKSEQ_SIZE); if (avail < 0) return -set_error(STATUS_NO_MEM); if (avail > ssize_t(count)) avail = count; // Read data ssize_t nread = pSequence->read(&pBuf[nMarkPos], avail); if (nread < 0) { if (skipped > 0) { set_error(STATUS_OK); return skipped; } set_error(status_t(-nread)); return nread; } // Update positions nMarkPos += nread; nMarkLen += nread; skipped += nread; if ((count -= skipped) <= 0) { set_error(STATUS_OK); return skipped; } } // Reset mark if we are out of buffer and return step = pSequence->skip(count); if (step > 0) { set_error(STATUS_OK); clear_mark(); return skipped + step; } else if (skipped > 0) { set_error(STATUS_OK); return skipped; } set_error(status_t(-step)); return step; } status_t InMarkSequence::mark(ssize_t limit) { if (pSequence == NULL) return set_error(STATUS_CLOSED); else if (limit < 0) return set_error(STATUS_OK); // Clear previous mark nMarkPos = 0; nMarkLen = 0; nMarkMax = limit; return set_error(STATUS_OK); } status_t InMarkSequence::reset() { if (pSequence == NULL) return set_error(STATUS_CLOSED); else if (nMarkMax < 0) return set_error(STATUS_NOT_FOUND); nMarkPos = 0; return set_error(STATUS_OK); } } /* namespace io */ } /* namespace lsp */