/* * Copyright (C) 2026 Linux Studio Plugins Project * (C) 2026 Vladimir Sadovnikov * * This file is part of lsp-runtime-lib * Created on: 14 мар. 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 namespace lsp { namespace io { static constexpr size_t BITSTREAM_BUFSZ = sizeof(umword_t) * 8; static constexpr size_t BITSTREAM_BUFSZ32 = sizeof(uint32_t) * 8; InBitStream::InBitStream() { pIS = NULL; nWrapFlags = 0; nBuffer = 0; nBits = 0; } InBitStream::~InBitStream() { do_close(); } status_t InBitStream::wrap(FILE *fd, bool close) { if (pIS != NULL) return set_error(STATUS_BAD_STATE); 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 = wrap(ofs, WRAP_CLOSE | WRAP_DELETE); if (res != STATUS_OK) { ofs->close(); delete ofs; } return res; } status_t InBitStream::wrap_native(fhandle_t fd, bool close) { if (pIS != NULL) return set_error(STATUS_BAD_STATE); 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 = wrap(ofs, WRAP_CLOSE | WRAP_DELETE); if (res != STATUS_OK) { ofs->close(); delete ofs; } return res; } status_t InBitStream::wrap(File *fd, size_t flags) { if (pIS != NULL) return set_error(STATUS_BAD_STATE); 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 = wrap(ofs, WRAP_CLOSE | WRAP_DELETE); if (res != STATUS_OK) { ofs->close(); delete ofs; } return res; } status_t InBitStream::open(const char *path) { if (pIS != NULL) return set_error(STATUS_BAD_STATE); status_t res; InFileStream *ofs = new InFileStream(); if (ofs == NULL) return set_error(STATUS_NO_MEM); if ((res = ofs->open(path)) == STATUS_OK) res = wrap(ofs, WRAP_CLOSE | WRAP_DELETE); if (res != STATUS_OK) { ofs->close(); delete ofs; } return res; } status_t InBitStream::open(const LSPString *path) { if (pIS != NULL) return set_error(STATUS_BAD_STATE); status_t res; InFileStream *ofs = new InFileStream(); if (ofs == NULL) return set_error(STATUS_NO_MEM); if ((res = ofs->open(path)) == STATUS_OK) res = wrap(ofs, WRAP_CLOSE | WRAP_DELETE); if (res != STATUS_OK) { ofs->close(); delete ofs; } return res; } status_t InBitStream::open(const Path *path) { if (pIS != NULL) return set_error(STATUS_BAD_STATE); status_t res; InFileStream *ofs = new InFileStream(); if (ofs == NULL) return set_error(STATUS_NO_MEM); if ((res = ofs->open(path)) == STATUS_OK) res = wrap(ofs, WRAP_CLOSE | WRAP_DELETE); if (res != STATUS_OK) { ofs->close(); delete ofs; } return res; } status_t InBitStream::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); // Store pointers pIS = is; nWrapFlags = flags; nBuffer = 0; nBits = 0; return set_error(STATUS_OK); } status_t InBitStream::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 = 0; nBuffer = 0; nBits = 0; return res; } status_t InBitStream::close() { return set_error(do_close()); } ssize_t InBitStream::read(void *dst, size_t count) { ssize_t nread = bread(dst, count * 8); if (nread < 0) return nread; // Need to unget something? if (nread & 7) { uint8_t *p = reinterpret_cast(dst); unread(p[nread >> 3], nread & 7); } return nread >> 3; } ssize_t InBitStream::bread(void *buf, size_t bits) { if (pIS == NULL) return -set_error(STATUS_CLOSED); uint8_t *dst = reinterpret_cast(buf); size_t nread = 0; while (nread < bits) { size_t to_read = lsp_min(bits - nread, 8u); ssize_t n = readv(dst++, to_read); if (n < 0) { if (nread > 0) break; set_error(status_t(-n)); return n; } nread += n; if (n < 8) break; } set_error(STATUS_OK); return nread; } wssize_t InBitStream::bskip(wsize_t amount) { if (pIS == NULL) return -set_error(STATUS_CLOSED); wsize_t skipped = 0; // Simple skip? if (amount <= nBits) { nBuffer <<= amount; nBits -= amount; return amount; } else { skipped = nBits; nBits = 0; amount -= skipped; } // Can skip bytes? wssize_t bytes = amount >> 3; while (bytes > 0) { wssize_t n = pIS->skip(bytes); if (n < 0) { if (skipped > 0) break; set_error(status_t(-n)); return n; } bytes -= n; skipped += n << 3; amount -= n << 3; } // Tail left? if (amount > 0) { umword_t v; ssize_t n = readv(&v, amount); if ((n < 0) && (skipped <= 0)) { set_error(status_t(-n)); return n; } } set_error(STATUS_OK); return skipped; } ssize_t InBitStream::readb(bool *value) { status_t res; if (pIS == NULL) return -set_error(STATUS_CLOSED); // Fill buffer with new data if ((res = fill()) != STATUS_OK) return -set_error(res); *value = nBuffer >> (BITSTREAM_BUFSZ - 1); nBuffer <<= 1; --nBits; set_error(STATUS_OK); return 1; } ssize_t InBitStream::readv(uint8_t *value, size_t bits) { umword_t v; ssize_t n = readv(&v, bits); if (n > 0) *value = uint8_t(v); return n; } ssize_t InBitStream::readv(uint16_t *value, size_t bits) { umword_t v; ssize_t n = readv(&v, bits); if (n > 0) *value = uint16_t(v); return n; } ssize_t InBitStream::readv(uint32_t *value, size_t bits) { if (pIS == NULL) return -set_error(STATUS_CLOSED); size_t nread = 0; status_t res; uint32_t v = 0; while (nread < bits) { // Fill buffer with new data if ((res = fill()) != STATUS_OK) { if (nread > 0) break; return -set_error(res); } // Estimate number of bits to read const size_t to_read= lsp_min(nBits, bits - nread); uint32_t x = uint32_t(nBuffer >> (BITSTREAM_BUFSZ - to_read)); v = (to_read < BITSTREAM_BUFSZ32) ? uint32_t((v << to_read) | x) : x; nBuffer <<= to_read; nBits -= to_read; nread += to_read; } *value = v; set_error(STATUS_OK); return nread; } ssize_t InBitStream::readv(uint64_t *value, size_t bits) { if (pIS == NULL) return -set_error(STATUS_CLOSED); size_t nread = 0; status_t res; uint64_t v = 0; while (nread < bits) { // Fill buffer with new data if ((res = fill()) != STATUS_OK) { if (nread > 0) break; return -set_error(res); } // Estimate number of bits to read size_t to_read = lsp_min(nBits, bits - nread); v = (to_read < BITSTREAM_BUFSZ) ? (v << to_read) | (nBuffer >> (BITSTREAM_BUFSZ - to_read)) : nBuffer; nBuffer <<= to_read; nBits -= to_read; nread += to_read; } *value = v; set_error(STATUS_OK); return nread; } void InBitStream::unread(umword_t v, size_t bits) { if (bits < BITSTREAM_BUFSZ) v <<= BITSTREAM_BUFSZ - bits; nBuffer = (nBuffer >> bits) | v; nBits += bits; } status_t InBitStream::fill() { if (nBits > 0) return STATUS_OK; nBuffer = 0; ssize_t n = pIS->read(&nBuffer, sizeof(umword_t)); if (n <= 0) return status_t(-n); nBits = n << 3; nBuffer = BE_TO_CPU(nBuffer); return STATUS_OK; } } /* namespace io */ } /* namespace lsp */