/*
* Copyright (C) 2025 Linux Studio Plugins Project
* (C) 2025 Vladimir Sadovnikov
*
* This file is part of lsp-runtime-lib
* Created on: 13 мар. 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 resource
{
cbuffer_t::cbuffer_t()
{
data = NULL;
index = NULL;
root = NULL;
head = 0;
length = 0;
cap = 0;
}
cbuffer_t::~cbuffer_t()
{
destroy();
}
status_t cbuffer_t::init(size_t log_capacity)
{
const size_t capacity = 1 << log_capacity;
const size_t dbuf = capacity * sizeof(uint8_t);
const size_t ibuf = capacity * sizeof(uint32_t);
const size_t rbuf = 0x100 * sizeof(uint32_t);
uint8_t *ptr = static_cast(realloc(data, dbuf + ibuf + rbuf));
if (ptr == NULL)
return STATUS_NO_MEM;
data = advance_ptr_bytes(ptr, dbuf);
index = advance_ptr_bytes(ptr, ibuf);
root = advance_ptr_bytes(ptr, rbuf);
head = 0;
length = 0;
cap = uint32_t(capacity);
for (size_t i=0; i < 0x100; ++i)
root[i] = -1;
return STATUS_OK;
}
void cbuffer_t::destroy()
{
if (data != NULL)
free(data);
data = NULL;
index = NULL;
root = NULL;
head = 0;
length = 0;
cap = 0;
}
void cbuffer_t::append(const void *src, size_t count)
{
const uint8_t *v = static_cast(src);
if (count >= cap)
{
// Cleanup root index and reset head
for (size_t i=0; i<0x100; ++i)
root[i] = -1;
length = 0;
head = 0;
// Append tail only
v += count - cap;
count = cap;
}
// Fill the buffer
const size_t mask = cap - 1;
const size_t ohead = head;
head = (head + count) & mask;
if (head < ohead)
{
const size_t split = cap - ohead;
memcpy(&data[ohead], v, split * sizeof(uint8_t));
memcpy(&data[0], &v[split], (count - split) * sizeof(uint8_t));
}
else
memcpy(&data[ohead], v, count * sizeof(uint8_t));
// Update index
uint32_t new_length = length;
for (size_t i=0; i(src);
const size_t dmax = size();
size_t len = 0;
ssize_t offset = 0;
// We can not find sequence larger than 'length' bytes
avail = lsp_min(avail, dmax);
// Lookup among all matches
uint32_t delta = length - root[*v];
const size_t mask = cap - 1;
while (delta <= dmax)
{
// Byte matched, do some heuristics
const size_t soff = (head + cap - delta) & mask;
if ((len > 1) && (data[(soff + len - 1) & mask] != v[len-1]))
{
delta = length - index[soff];
continue;
}
// Compute the length of the sub-sequence
const size_t lookup = lsp_min(avail, delta);
size_t slen = 1;
for (size_t i=1; i= avail)
break;
}
// Update search position
delta = length - index[soff];
}
*out = offset - 1;
return len;
}
uint8_t cbuffer_t::byte_at(size_t offset)
{
return (offset < cap) ? data[(head + cap - offset - 1) & (cap - 1)] : 0;
}
void cbuffer_t::clear()
{
head = 0;
length = 0;
if (root != NULL)
{
for (size_t i=0; i < 0x100; ++i)
root[i] = -1;
}
}
dbuffer_t::dbuffer_t()
{
data = NULL;
length = 0;
head = 0;
cap = 0;
}
dbuffer_t::~dbuffer_t()
{
destroy();
}
status_t dbuffer_t::init(size_t log_capacity)
{
size_t dbuf = sizeof(uint8_t) << log_capacity;
uint8_t *ptr = static_cast(realloc(data, dbuf));
if (ptr == NULL)
return STATUS_NO_MEM;
data = ptr;
length = 0;
head = 0;
cap = uint32_t(1 << log_capacity);
return STATUS_OK;
}
void dbuffer_t::destroy()
{
if (data != NULL)
free(data);
data = NULL;
length = 0;
head = 0;
cap = 0;
}
void dbuffer_t::append(const void *src, size_t count)
{
const uint8_t *v = static_cast(src);
if (count >= cap)
{
// Replace data in the buffer
memcpy(data, &v[count - cap], cap * sizeof(uint8_t));
length = cap;
head = 0;
return;
}
// Copy data to the buffer
size_t ohead = head;
head = (head + count) & (cap-1);
if (head < ohead)
{
const size_t split = cap - ohead;
memcpy(&data[ohead], v, split * sizeof(uint8_t));
memcpy(&data[0], &v[split], head * sizeof(uint8_t));
}
else
memcpy(&data[ohead], v, count * sizeof(uint8_t));
length = uint32_t(lsp_min(length + count, cap));
}
status_t dbuffer_t::extract(void *dst, size_t offset, size_t count)
{
if (offset >= length)
return STATUS_UNDERFLOW;
const size_t shift = offset + 1;
if (count > shift)
return STATUS_UNDERFLOW;
uint8_t *dptr = static_cast(dst);
uint32_t soff = (head + cap - shift) & (cap-1);
if ((soff + count) > cap)
{
const size_t split = cap - soff;
memcpy(dptr, &data[soff], split * sizeof(uint8_t));
memcpy(&dptr[split], data, (count - split) * sizeof(uint8_t));
}
else
memcpy(dptr, &data[soff], count * sizeof(uint8_t));
return STATUS_OK;
}
void dbuffer_t::append(uint8_t v)
{
data[head] = v;
head = (head + 1) & (cap - 1);
length = lsp_min(length + 1, cap);
}
void dbuffer_t::clear()
{
length = 0;
head = 0;
}
} /* namespace resource */
} /* namespace lsp */