/*
cbuf.cpp - Circular buffer implementation
Copyright (c) 2014 Ivan Grokhotkov. All rights reserved.
This file is part of the esp8266 core for Arduino environment.
This library 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 2.1 of the License, or (at your option) any later version.
This library 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 this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
#include "cbuf.h"
#include "esp32-hal-log.h"
#if CONFIG_DISABLE_HAL_LOCKS
#define CBUF_MUTEX_CREATE()
#define CBUF_MUTEX_LOCK()
#define CBUF_MUTEX_UNLOCK()
#define CBUF_MUTEX_DELETE()
#else
#define CBUF_MUTEX_CREATE() if(_lock == NULL){_lock = xSemaphoreCreateMutex(); if(_lock == NULL){log_e("failed to create mutex");}}
#define CBUF_MUTEX_LOCK() if(_lock != NULL){xSemaphoreTakeRecursive(_lock, portMAX_DELAY);}
#define CBUF_MUTEX_UNLOCK() if(_lock != NULL){xSemaphoreGiveRecursive(_lock);}
#define CBUF_MUTEX_DELETE() if(_lock != NULL){SemaphoreHandle_t l = _lock; _lock = NULL; vSemaphoreDelete(l);}
#endif
cbuf::cbuf(size_t size) :
next(NULL),
has_peek(false),
peek_byte(0),
_buf(xRingbufferCreate(size, RINGBUF_TYPE_BYTEBUF))
{
if(_buf == NULL) {
log_e("failed to allocate ring buffer");
}
CBUF_MUTEX_CREATE();
}
cbuf::~cbuf()
{
CBUF_MUTEX_LOCK();
if(_buf != NULL){
RingbufHandle_t b = _buf;
_buf = NULL;
vRingbufferDelete(b);
}
CBUF_MUTEX_UNLOCK();
CBUF_MUTEX_DELETE();
}
size_t cbuf::resizeAdd(size_t addSize)
{
return resize(size() + addSize);
}
size_t cbuf::resize(size_t newSize)
{
CBUF_MUTEX_LOCK();
size_t _size = size();
if(newSize == _size) {
return _size;
}
// not lose any data
// if data can be lost use remove or flush before resize
size_t bytes_available = available();
if(newSize < bytes_available) {
CBUF_MUTEX_UNLOCK();
log_e("new size is less than the currently available data size");
return _size;
}
RingbufHandle_t newbuf = xRingbufferCreate(newSize, RINGBUF_TYPE_BYTEBUF);
if(newbuf == NULL) {
CBUF_MUTEX_UNLOCK();
log_e("failed to allocate new ring buffer");
return _size;
}
if(_buf != NULL) {
if(bytes_available){
char * old_data = (char *)malloc(bytes_available);
if(old_data == NULL){
vRingbufferDelete(newbuf);
CBUF_MUTEX_UNLOCK();
log_e("failed to allocate temporary buffer");
return _size;
}
bytes_available = read(old_data, bytes_available);
if(!bytes_available){
free(old_data);
vRingbufferDelete(newbuf);
CBUF_MUTEX_UNLOCK();
log_e("failed to read previous data");
return _size;
}
if(xRingbufferSend(newbuf, (void*)old_data, bytes_available, 0) != pdTRUE){
write(old_data, bytes_available);
free(old_data);
vRingbufferDelete(newbuf);
CBUF_MUTEX_UNLOCK();
log_e("failed to restore previous data");
return _size;
}
free(old_data);
}
RingbufHandle_t b = _buf;
_buf = newbuf;
vRingbufferDelete(b);
} else {
_buf = newbuf;
}
CBUF_MUTEX_UNLOCK();
return newSize;
}
size_t cbuf::available() const
{
size_t available = 0;
if(_buf != NULL){
vRingbufferGetInfo(_buf, NULL, NULL, NULL, NULL, (UBaseType_t *)&available);
}
if (has_peek) available++;
return available;
}
size_t cbuf::size()
{
size_t _size = 0;
if(_buf != NULL){
_size = xRingbufferGetMaxItemSize(_buf);
}
return _size;
}
size_t cbuf::room() const
{
size_t _room = 0;
if(_buf != NULL){
_room = xRingbufferGetCurFreeSize(_buf);
}
return _room;
}
bool cbuf::empty() const
{
return available() == 0;
}
bool cbuf::full() const
{
return room() == 0;
}
int cbuf::peek()
{
if (!available()) {
return -1;
}
int c;
CBUF_MUTEX_LOCK();
if (has_peek) {
c = peek_byte;
} else {
c = read();
if (c >= 0) {
has_peek = true;
peek_byte = c;
}
}
CBUF_MUTEX_UNLOCK();
return c;
}
int cbuf::read()
{
char result = 0;
if(!read(&result, 1)){
return -1;
}
return static_cast<int>(result);
}
size_t cbuf::read(char* dst, size_t size)
{
CBUF_MUTEX_LOCK();
size_t bytes_available = available();
if(!bytes_available || !size){
CBUF_MUTEX_UNLOCK();
return 0;
}
if (has_peek) {
if (dst != NULL) {
*dst++ = peek_byte;
}
size--;
}
size_t size_read = 0;
if (size) {
size_t received_size = 0;
size_t size_to_read = (size < bytes_available) ? size : bytes_available;
uint8_t *received_buff = (uint8_t *)xRingbufferReceiveUpTo(_buf, &received_size, 0, size_to_read);
if (received_buff != NULL) {
if(dst != NULL){
memcpy(dst, received_buff, received_size);
}
vRingbufferReturnItem(_buf, received_buff);
size_read = received_size;
size_to_read -= received_size;
// wrap around data
if(size_to_read){
received_size = 0;
received_buff = (uint8_t *)xRingbufferReceiveUpTo(_buf, &received_size, 0, size_to_read);
if (received_buff != NULL) {
if(dst != NULL){
memcpy(dst+size_read, received_buff, received_size);
}
vRingbufferReturnItem(_buf, received_buff);
size_read += received_size;
} else {
log_e("failed to read wrap around data from ring buffer");
}
}
} else {
log_e("failed to read from ring buffer");
}
}
if (has_peek) {
has_peek = false;
size_read++;
}
CBUF_MUTEX_UNLOCK();
return size_read;
}
size_t cbuf::write(char c)
{
return write(&c, 1);
}
size_t cbuf::write(const char* src, size_t size)
{
CBUF_MUTEX_LOCK();
size_t bytes_available = room();
if(!bytes_available || !size){
CBUF_MUTEX_UNLOCK();
return 0;
}
size_t size_to_write = (size < bytes_available) ? size : bytes_available;
if(xRingbufferSend(_buf, (void*)src, size_to_write, 0) != pdTRUE){
CBUF_MUTEX_UNLOCK();
log_e("failed to write to ring buffer");
return 0;
}
CBUF_MUTEX_UNLOCK();
return size_to_write;
}
void cbuf::flush()
{
read(NULL, available());
}
size_t cbuf::remove(size_t size)
{
CBUF_MUTEX_LOCK();
size_t bytes_available = available();
if(bytes_available && size){
size_t size_to_remove = (size < bytes_available) ? size : bytes_available;
bytes_available -= read(NULL, size_to_remove);
}
CBUF_MUTEX_UNLOCK();
return bytes_available;
}