/*
* Copyright (C) 2025 Linux Studio Plugins Project
* (C) 2025 Vladimir Sadovnikov
*
* This file is part of lsp-runtime-lib
* Created on: 3 мар. 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;
OutBitStream::OutBitStream()
{
pOS = NULL;
nWrapFlags = 0;
nBuffer = 0;
nBits = 0;
}
OutBitStream::~OutBitStream()
{
if (pOS != NULL)
{
do_flush_buffer();
if (nWrapFlags & WRAP_CLOSE)
pOS->close();
if (nWrapFlags & WRAP_DELETE)
delete pOS;
pOS = NULL;
}
nBuffer = 0;
nBits = 0;
}
status_t OutBitStream::close()
{
status_t res = STATUS_OK, tres;
// Close file descriptor
if (pOS != NULL)
{
// Flush buffers
res = flush();
// Perform close
if (nWrapFlags & WRAP_CLOSE)
{
tres = pOS->close();
if (res == STATUS_OK)
res = tres;
}
if (nWrapFlags & WRAP_DELETE)
delete pOS;
pOS = NULL;
}
nWrapFlags = 0;
// Return result
return set_error(res);
}
status_t OutBitStream::open(const char *path, size_t mode)
{
if (pOS != NULL)
return set_error(STATUS_BAD_STATE);
else if (path == NULL)
return set_error(STATUS_BAD_ARGUMENTS);
LSPString tmp;
if (!tmp.set_utf8(path))
return set_error(STATUS_NO_MEM);
return open(&tmp, mode);
}
status_t OutBitStream::open(const LSPString *path, size_t mode)
{
if (pOS != NULL)
return set_error(STATUS_BAD_STATE);
else if (path == NULL)
return set_error(STATUS_BAD_ARGUMENTS);
OutFileStream *f = new OutFileStream();
if (f == NULL)
return set_error(STATUS_NO_MEM);
status_t res = f->open(path, mode);
if (res != STATUS_OK)
{
f->close();
delete f;
return set_error(res);
}
res = wrap(f, WRAP_CLOSE | WRAP_DELETE);
if (res != STATUS_OK)
{
f->close();
delete f;
return set_error(res);
}
return set_error(STATUS_OK);
}
status_t OutBitStream::open(const io::Path *path, size_t mode)
{
return open(path->as_string(), mode);
}
status_t OutBitStream::wrap(FILE *fd, bool close)
{
if (pOS != NULL)
return set_error(STATUS_BAD_STATE);
else if (fd == NULL)
return set_error(STATUS_BAD_ARGUMENTS);
OutFileStream *f = new OutFileStream();
if (f == NULL)
return set_error(STATUS_NO_MEM);
status_t res = f->wrap(fd, close);
if (res != STATUS_OK)
{
f->close();
delete f;
return set_error(res);
}
res = wrap(f, WRAP_CLOSE | WRAP_DELETE);
if (res != STATUS_OK)
{
f->close();
delete f;
}
return set_error(STATUS_OK);
}
status_t OutBitStream::wrap_native(fhandle_t fd, bool close)
{
if (pOS != NULL)
return set_error(STATUS_BAD_STATE);
OutFileStream *f = new OutFileStream();
if (f == NULL)
return set_error(STATUS_NO_MEM);
status_t res = f->wrap_native(fd, close);
if (res != STATUS_OK)
{
f->close();
delete f;
return set_error(res);
}
res = wrap(f, WRAP_CLOSE | WRAP_DELETE);
if (res != STATUS_OK)
{
f->close();
delete f;
}
return set_error(STATUS_OK);
}
status_t OutBitStream::wrap(File *fd, size_t flags)
{
if (pOS != NULL)
return set_error(STATUS_BAD_STATE);
else if (fd == NULL)
return set_error(STATUS_BAD_ARGUMENTS);
OutFileStream *f = new OutFileStream();
if (f == NULL)
return set_error(STATUS_NO_MEM);
status_t res = f->wrap(fd, flags);
if (res != STATUS_OK)
{
f->close();
delete f;
return set_error(res);
}
res = wrap(f, WRAP_CLOSE | WRAP_DELETE);
if (res != STATUS_OK)
{
f->close();
delete f;
}
return set_error(STATUS_OK);
}
status_t OutBitStream::wrap(IOutStream *os, size_t flags)
{
if (pOS != NULL)
return set_error(STATUS_BAD_STATE);
else if (os == NULL)
return set_error(STATUS_BAD_ARGUMENTS);
// Store pointers
pOS = os;
nWrapFlags = flags;
nBuffer = 0;
nBits = 0;
return set_error(STATUS_OK);
}
ssize_t OutBitStream::write(const void *buf, size_t count)
{
if (pOS == NULL)
return -set_error(STATUS_CLOSED);
size_t written = 0;
#ifdef LSP_UNALIGNED_MEMORY_SAFE
// x86 allows unaligned access, write with machine words first
const umword_t *wptr = reinterpret_cast(buf);
size_t blocks = count & (~(sizeof(umword_t) - 1));
for ( ; written < blocks; written += sizeof(umword_t))
{
status_t res = writev(BE_TO_CPU(*(wptr++)), sizeof(umword_t)*8);
if (res != STATUS_OK)
{
set_error(res);
return (written <= 0) ? -res : written;
}
}
buf = wptr;
#endif /* LSP_UNALIGNED_MEMORY_SAFE */
// Write the rest data with bytes
const uint8_t *bptr = reinterpret_cast(buf);
for ( ; written < count; ++written)
{
status_t res = writev(*(bptr++), sizeof(uint8_t) * 8);
if (res != STATUS_OK)
{
set_error(res);
return (written <= 0) ? -res : written;
}
}
return written;
}
ssize_t OutBitStream::bwrite(const void *buf, size_t bits)
{
if (pOS == NULL)
return -set_error(STATUS_CLOSED);
size_t written = 0;
#ifdef LSP_UNALIGNED_MEMORY_SAFE
// x86 allows unaligned memory access, write with machine words first
const umword_t *wptr = reinterpret_cast(buf);
size_t blocks = bits & (~((sizeof(umword_t) << 3) - 1));
for ( ; written < blocks; written += sizeof(umword_t)*8)
{
status_t res = writev(BE_TO_CPU(*(wptr++)), sizeof(umword_t)*8);
if (res != STATUS_OK)
{
set_error(res);
return (written <= 0) ? -res : written;
}
}
buf = wptr;
#endif /* LSP_UNALIGNED_MEMORY_SAFE */
// Write the rest data with bytes
const uint8_t *bptr = reinterpret_cast(buf);
while (written < bits)
{
size_t to_write = lsp_min(sizeof(uint8_t) * 8, bits - written);
status_t res = writev(*(bptr++), to_write);
if (res != STATUS_OK)
{
set_error(res);
return (written <= 0) ? -res : written;
}
written += to_write;
}
return written;
}
status_t OutBitStream::do_flush_buffer()
{
if (nBits == 0)
return set_error(STATUS_OK);
size_t written, bytes;
umword_t buf;
if (nBits == sizeof(umword_t) * 8)
{
buf = CPU_TO_BE(nBuffer);
written = pOS->write(&buf, sizeof(umword_t));
if (written != sizeof(umword_t))
return -set_error(status_t(-written));
}
else
{
uint8_t data[sizeof(umword_t)];
bytes = (nBits + 7) >> 3; // Overall number of bytes to write
buf = nBuffer << (BITSTREAM_BUFSZ - nBits);
size_t s = BITSTREAM_BUFSZ - 8;
for (size_t i=0; i> s;
written = pOS->write(data, bytes);
if (written != bytes)
return -set_error(status_t(-written));
}
nBits = 0;
return set_error(STATUS_OK);
}
status_t OutBitStream::flush()
{
if (pOS == NULL)
return set_error(STATUS_CLOSED);
return do_flush_buffer();
}
status_t OutBitStream::bwrite(bool value)
{
status_t res;
if (pOS == NULL)
return set_error(STATUS_CLOSED);
// Need to flush?
if (nBits >= BITSTREAM_BUFSZ)
{
if ((res = flush()) != STATUS_OK)
return res;
}
nBuffer = (nBuffer << 1) | umword_t(value);
++nBits;
return set_error(STATUS_OK);
}
status_t OutBitStream::writev(uint32_t value, size_t bits)
{
status_t res;
if (pOS == NULL)
return set_error(STATUS_CLOSED);
value <<= BITSTREAM_BUFSZ32 - bits;
while (bits > 0)
{
// Need to flush?
if (nBits >= BITSTREAM_BUFSZ)
{
if ((res = flush()) != STATUS_OK)
return res;
}
size_t avail = lsp_min(bits, BITSTREAM_BUFSZ - nBits);
nBuffer = (avail < BITSTREAM_BUFSZ) ? (nBuffer << avail) | (value >> (BITSTREAM_BUFSZ32 - avail)) : value;
nBits += avail;
bits -= avail;
value <<= avail;
}
return set_error(STATUS_OK);
}
status_t OutBitStream::writev(uint64_t value, size_t bits)
{
status_t res;
#if defined(ARCH_32BIT)
// Need to write high part?
if (bits > BITSTREAM_BUFSZ32)
{
if ((res = writev(uint32_t(value >> BITSTREAM_BUFSZ32), bits - BITSTREAM_BUFSZ32)) != STATUS_OK)
return res;
bits = BITSTREAM_BUFSZ32;
}
// Write low part
return writev(uint32_t(value), bits);
#else
if (pOS == NULL)
return set_error(STATUS_CLOSED);
value <<= (BITSTREAM_BUFSZ - bits);
while (bits > 0)
{
// Need to flush?
if (nBits >= BITSTREAM_BUFSZ)
{
if ((res = flush()) != STATUS_OK)
return res;
}
size_t avail = lsp_min(bits, BITSTREAM_BUFSZ - nBits);
nBuffer = (avail < BITSTREAM_BUFSZ) ? (nBuffer << avail) | (value >> (BITSTREAM_BUFSZ - avail)) : value;
nBits += avail;
bits -= avail;
value <<= avail;
}
return set_error(STATUS_OK);
#endif /* ARCH_32BIT */
}
} /* namespace io */
} /* namespace lsp */