3#include "AudioTools/CoreAudio/AudioBasic/Collections.h"
4#include "AudioTools/CoreAudio/AudioBasic/Str.h"
5#include "AudioTools/CoreAudio/AudioLogger.h"
30 virtual bool read(T &result) = 0;
34 if (data ==
nullptr) {
39 for (
int j = 0; j < lenResult; j++) {
42 LOGD(
"readArray %d -> %d", len, lenResult);
60 for (
int j = 0; j < len; j++) {
61 if (!
write(data[j])) {
67 LOGD(
"writeArray %d -> %d", len, result);
81 virtual bool peek(T &result) = 0;
86 bool isEmpty() {
return available() == 0; }
106 virtual size_t size() = 0;
111 if (size() == 0)
return 0.0f;
112 return 100.0f *
static_cast<float>(
available()) /
113 static_cast<float>(size());
118 LOGE(
"resize not implemented for this buffer");
132 LOGD(
"%s: %d", LOG_METHOD, len);
134 int result = min(len, p_buffer->available());
135 for (
int j = 0; j < result; j++) {
137 p_buffer->read(sample);
145 template <
int rows,
int channels>
147 int lenResult = min(rows, p_buffer->available());
148 for (
int j = 0; j < lenResult; j++) {
150 p_buffer->read(sample);
151 for (
int i = 0; i < channels; i++) {
160 BaseBuffer<T> *p_buffer =
nullptr;
191 this->owns_buffer =
false;
192 this->buffer = (uint8_t *)
data;
193 this->current_read_pos = 0;
194 this->current_write_pos = len;
198 if (size() == 0)
resize(len);
204 if (current_write_pos < buffer.size()) {
205 buffer[current_write_pos++] = sample;
211 bool read(T &result)
override {
212 bool success =
false;
213 if (current_read_pos < current_write_pos) {
214 result = buffer[current_read_pos++];
220 bool peek(T &result)
override {
221 bool success =
false;
222 if (current_read_pos < current_write_pos) {
223 result = buffer[current_read_pos];
230 int result = current_write_pos - current_read_pos;
231 return max(result, 0);
243 return len_available;
245 current_read_pos += len;
246 len_available -= len;
247 memmove(buffer.data(), buffer.data() + current_read_pos, len_available *
sizeof(T));
248 current_read_pos = 0;
249 current_write_pos = len_available;
251 if (is_clear_with_zero) {
252 memset(buffer.data() + current_write_pos, 0,
253 buffer.size() - current_write_pos);
262 memmove(buffer.data(), buffer.data() + current_read_pos, av *
sizeof(T));
263 current_write_pos = av;
264 current_read_pos = 0;
268 T *
address()
override {
return buffer.data(); }
271 T *
data() {
return buffer.data() + current_read_pos; }
274 current_read_pos = 0;
275 current_write_pos = 0;
276 if (is_clear_with_zero) {
277 memset(buffer.data(), 0, buffer.size());
284 size_t result = min(available_size, (
size_t)buffer.size());
285 current_read_pos = 0;
286 current_write_pos = result;
290 size_t size()
override {
return buffer.size(); }
293 if (buffer.size() < size) {
314 int current_read_pos = 0;
315 int current_write_pos = 0;
316 bool owns_buffer =
true;
317 bool is_clear_with_zero =
false;
334 bool read(T &result)
override {
339 result = _aucBuffer[_iTail];
340 _iTail = nextIndex(_iTail);
347 bool peek(T &result)
override {
352 result = _aucBuffer[_iTail];
356 virtual int peekArray(T *data,
int n) {
357 if (isEmpty())
return -1;
359 int count = _numElems;
361 for (
int j = 0; j < n; j++) {
362 data[j] = _aucBuffer[tail];
363 tail = nextIndex(tail);
366 if (count == 0)
break;
374 bool isEmpty() {
return available() == 0; }
377 virtual bool write(T data)
override {
380 _aucBuffer[_iHead] = data;
381 _iHead = nextIndex(_iHead);
402 virtual T *
address()
override {
return _aucBuffer.data(); }
405 if (max_size != len) {
406 LOGI(
"resize: %d", len);
407 _aucBuffer.resize(len);
414 virtual size_t size()
override {
return max_size; }
423 int nextIndex(
int index) {
424 if (max_size == 0)
return 0;
425 return (uint32_t)(index + 1) % max_size; }
436template <
class File,
typename T>
445 if (p_file) p_file->close();
451 p_file = &bufferFile;
453 LOGE(
"file is not valid");
463 if (p_file ==
nullptr)
return 0;
464 int read_count = min(count,
available());
467 if (!
file_seek(offset.pos))
return false;
469 if (offset.len1 > 0) {
471 n +=
file_read(data + offset.len, offset.len1);
472 read_pos = offset.len1;
474 read_pos += read_count;
477 for (
int i = 0; i < count; i++) {
478 LOGI(
"read #%d value %d", offset.pos, (
int)data[i]);
481 element_count -= read_count;
486 bool peek(T &result)
override {
487 if (p_file ==
nullptr || isEmpty()) {
498 if (p_file ==
nullptr)
return 0;
499 int read_count = min(count,
available());
502 if (!
file_seek(offset.pos))
return false;
504 if (offset.len1 > 0) {
506 n +=
file_read(data + offset.len, offset.len1);
508 assert(n == read_count);
517 if (p_file ==
nullptr)
return 0;
518 for (
int i = 0; i < len; i++) {
519 LOGI(
"write #%d value %d", write_pos, (
int)data[i]);
525 if (!
file_seek(offset.pos))
return false;
527 if (offset.len1 > 0) {
529 n +=
file_write(data + offset.len, offset.len1);
530 write_pos = offset.len1;
532 write_pos += write_count;
534 element_count += write_count;
541 bool isEmpty() {
return available() == 0; }
558 size_t size()
override {
return max_size; }
570 File *p_file =
nullptr;
573 int element_count = 0;
587 int overflow = (pos + len) - max_size;
594 result.len = len - overflow;
595 result.len1 = overflow;
602 int file_pos = pos *
sizeof(T);
603 if (p_file->position() != file_pos) {
604 LOGD(
"file_seek: %d", pos);
605 if (!p_file->seek(file_pos)) {
606 LOGE(
"seek %d", file_pos);
615 LOGD(
"file_write: %d", count);
616 if (p_file ==
nullptr)
return 0;
617 int to_write_bytes =
sizeof(T) * count;
618 int bytes_written = p_file->write((
const uint8_t *)data, to_write_bytes);
620 int elements_written = bytes_written /
sizeof(T);
621 if (bytes_written != to_write_bytes) {
622 LOGE(
"write: %d -> %d bytes", to_write_bytes, bytes_written);
624 return elements_written;
629 LOGD(
"file_read: %d", count);
630 int read_bytes = count *
sizeof(T);
631 int result_bytes = p_file->readBytes((
char *)result, read_bytes);
632 int result_count = result_bytes /
sizeof(T);
633 if (result_count != count) {
634 LOGE(
"readBytes: %d -> %d", read_bytes, result_bytes);
652 virtual ~NBuffer() { freeMemory(); }
655 bool read(T &result)
override {
657 return actual_read_buffer->read(result);
661 bool peek(T &result)
override {
663 return actual_read_buffer->peek(result);
672 if (actual_write_buffer ==
nullptr) {
673 actual_write_buffer = getNextAvailableBuffer();
675 if (actual_write_buffer !=
nullptr) {
676 result = actual_write_buffer->write(data);
678 if (actual_write_buffer->isFull()) {
679 addFilledBuffer(actual_write_buffer);
680 actual_write_buffer = getNextAvailableBuffer();
684 if (start_time == 0l) {
687 if (result) sample_count++;
694 if (actual_read_buffer ==
nullptr) {
695 actual_read_buffer = getNextFilledBuffer();
697 if (actual_read_buffer ==
nullptr) {
700 int result = actual_read_buffer->available();
705 (actual_read_buffer ==
nullptr) ? 0 : actual_read_buffer->available();
712 if (actual_write_buffer ==
nullptr) {
713 actual_write_buffer = getNextAvailableBuffer();
716 if (actual_write_buffer ==
nullptr) {
720 if (actual_write_buffer->isFull()) {
723 addFilledBuffer(actual_write_buffer);
724 actual_write_buffer = getNextAvailableBuffer();
726 return actual_write_buffer->availableForWrite();
732 while (actual_read_buffer !=
nullptr) {
733 actual_read_buffer->reset();
734 addAvailableBuffer(actual_read_buffer);
736 actual_read_buffer = getNextFilledBuffer();
742 unsigned long run_time = (
millis() - start_time);
743 return run_time == 0 ? 0 : sample_count * 1000 / run_time;
748 return actual_read_buffer ==
nullptr ? nullptr
749 : actual_read_buffer->address();
759 int count = bytes / buffer_size;
760 return resize(buffer_size, count);
765 if (buffer_size ==
size && buffer_count == count)
return true;
767 filled_buffers.resize(count);
768 available_buffers.resize(count);
772 buffer_count = count;
774 for (
int j = 0; j < count; j++) {
776 LOGD(
"new buffer %p", buffer);
777 available_buffers.enqueue(buffer);
783 size_t size() {
return buffer_size * buffer_count; }
786 int buffer_size = 1024;
787 uint16_t buffer_count = 0;
791 QueueFromVector<BaseBuffer<T> *> filled_buffers{0,
nullptr};
792 unsigned long start_time = 0;
793 unsigned long sample_count = 0;
799 if (actual_write_buffer) {
800 LOGD(
"deleting %p", actual_write_buffer);
801 delete actual_write_buffer;
802 actual_write_buffer =
nullptr;
804 if (actual_read_buffer) {
805 LOGD(
"deleting %p", actual_read_buffer);
806 delete actual_read_buffer;
807 actual_read_buffer =
nullptr;
811 while (ptr !=
nullptr) {
812 LOGD(
"deleting %p", ptr);
814 ptr = getNextAvailableBuffer();
817 ptr = getNextFilledBuffer();
818 while (ptr !=
nullptr) {
819 LOGD(
"deleting %p", ptr);
821 ptr = getNextFilledBuffer();
825 void resetCurrent() {
826 if (actual_read_buffer !=
nullptr) {
827 actual_read_buffer->
reset();
828 addAvailableBuffer(actual_read_buffer);
831 actual_read_buffer = getNextFilledBuffer();
834 virtual BaseBuffer<T> *getNextAvailableBuffer() {
835 if (available_buffers.empty())
return nullptr;
836 BaseBuffer<T> *result =
nullptr;
837 available_buffers.dequeue(result);
841 virtual bool addAvailableBuffer(BaseBuffer<T> *buffer) {
842 return available_buffers.enqueue(buffer);
845 virtual BaseBuffer<T> *getNextFilledBuffer() {
846 if (filled_buffers.empty())
return nullptr;
847 BaseBuffer<T> *result =
nullptr;
848 filled_buffers.dequeue(result);
852 virtual bool addFilledBuffer(BaseBuffer<T> *buffer) {
853 return filled_buffers.enqueue(buffer);
871 actual_write_buffer = getNextAvailableBuffer();
872 if (actual_write_buffer !=
nullptr) {
873 addFilledBuffer(actual_write_buffer);
888 for (
auto &buffer : this->filled_buffers.toVector()) {
890 if (sbuffer->
id ==
id) {
900 using NBuffer<T>::resetCurrent;
901 using NBuffer<T>::addFilledBuffer;
902 using NBuffer<T>::getNextAvailableBuffer;
903 using NBuffer<T>::actual_write_buffer;
904 using NBuffer<T>::actual_read_buffer;
917template <
class File,
typename T>
921 NBufferFile(
int fileSize) { number_of_objects_per_file = fileSize; }
927 next_file_name.
set(
"buffer-");
929 snprintf(number, 40,
"%d", file_count);
930 next_file_name.
add(number);
931 next_file_name.
add(
".tmp");
932 return next_file_name.
c_str();
938 if (!file)
return false;
939 empty_files.enqueue(file);
949 if (!filled_files.dequeue(read_file)) {
956 int result = read_file.readBytes((
char *)data, len *
sizeof(T)) /
sizeof(T);
961 empty_files.enqueue(read_file);
968 size_t pos = read_file.position();
969 bool result =
read(data);
977 if (!write_file || write_file.size() + len > number_of_objects_per_file) {
981 filled_files.enqueue(write_file);
984 if (!empty_files.dequeue(write_file))
return false;
986 int result = write_file.write((uint8_t *)data, len *
sizeof(T));
987 return result /
sizeof(T);
991 return filled_files.size() * number_of_objects_per_file +
992 (read_file.available() /
sizeof(T));
998 number_of_objects_per_file - (write_file.available() /
sizeof(T));
999 return empty_files.size() * number_of_objects_per_file +
1000 write_file.available() + open_current;
1003 size_t size()
override {
return number_of_objects_per_file * file_count; }
1007 cleanupFile(read_file);
1008 cleanupFile(write_file);
1010 while (empty_files.dequeue(file)) cleanupFile(file);
1011 while (filled_files.dequeue(file)) cleanupFile(file);
1016 file_delete_callback = cb;
1022 empty_files.enqueue(read_file);
1027 empty_files.enqueue(write_file);
1031 while (filled_files.dequeue(file)) {
1033 empty_files.enqueue(file);
1045 int number_of_objects_per_file = 0;
1047 const uint16_t max_file_name = 256;
1049 void (*file_delete_callback)(
const char *filename);
1051 void cleanupFile(
File &file) {
1054 int len = strlen(file.name());
1055 char file_name[len + 1];
1056 strncpy(file_name, file.name(), len);
1058 file_delete_callback(file_name);
1071template <
typename T>
1075 LOGI(
"BufferedArray(%d)", len);
1080 int16_t *getValues(
size_t offset,
size_t length) {
1081 LOGD(
"getValues(%d,%d) - max %d", offset, length, array.size());
1085 actual_end = length;
1088 last_end = actual_end >= 0 ? actual_end : offset;
1090 actual_end = offset + length > actual_end ? offset + length : actual_end;
1092 int size = actual_end - last_end;
1094 LOGD(
"readBytes(%d,%d)", last_end, size);
1095 assert(last_end + size <= array.size());
1096 p_stream->readBytes((uint8_t *)(&array[last_end]), size * 2);
1098 assert(offset < actual_end);
1099 return &array[offset];
1103 int actual_end = -1;
1106 Stream *p_stream =
nullptr;