DynamicMultiBuffer.h

#pragma once
 
namespace audio_tools {
 
template <typename T, template<typename> class BufferType>
class DynamicMultiBuffer : public BaseBuffer<T> {
 public:
  DynamicMultiBuffer(size_t component_size, size_t initial_components = 1, 
                     size_t max_components = 0) {
    TRACED();
    component_size_ = component_size;
    max_components_ = max_components;
    
    // Create initial buffer components
    for (size_t i = 0; i < initial_components; i++) {
      if (!addBufferComponent()) {
        LOGE("Failed to allocate initial buffer component %d", (int)i);
        break;
      }
    }
  }
  DynamicMultiBuffer(size_t component_size, size_t initial_components = 1,  {…}
 
  virtual ~DynamicMultiBuffer() {
    TRACED();
    // Clean up all buffer components
    for (auto* buffer : buffer_components) {
      delete buffer;
    }
    buffer_components.clear();
  }
  virtual ~DynamicMultiBuffer() {…}
 
  bool read(T &result) override {
    if (isEmpty()) {
      return false;
    }
 
    // Find the buffer component containing the read position
    size_t buffer_idx = read_pos / component_size_;
    size_t local_pos = read_pos % component_size_;
    
    // Perform read from the appropriate buffer
    bool success = buffer_components[buffer_idx]->read(result);
    if (success) {
      read_pos++;
    }
    
    return success;
  }
  bool read(T &result) override  {…}
 
  bool peek(T &result) override {
    if (isEmpty()) {
      return false;
    }
 
    // Find the buffer component containing the read position
    size_t buffer_idx = read_pos / component_size_;
    size_t local_pos = read_pos % component_size_;
    
    // Perform peek from the appropriate buffer
    return buffer_components[buffer_idx]->peek(result);
  }
  bool peek(T &result) override  {…}
 
  bool write(T data) override {
    // Check if we need to add a new buffer component
    if (isCurrentBufferFull()) {
      if (!addBufferComponent()) {
        return false; // Couldn't expand, so write fails
      }
    }
 
    // Find the buffer component for writing
    size_t buffer_idx = write_pos / component_size_;
    size_t local_pos = write_pos % component_size_;
    
    // Perform write to the appropriate buffer
    bool success = buffer_components[buffer_idx]->write(data);
    if (success) {
      write_pos++;
    }
    
    return success;
  }
  bool write(T data) override  {…}
 
  int readArray(T data[], int len) override {
    if (isEmpty() || data == nullptr) {
      return 0;
    }
    
    int total_read = 0;
    int remaining = min(len, available());
    
    while (remaining > 0) {
      // Find the current buffer component and position
      size_t buffer_idx = read_pos / component_size_;
      size_t local_pos = read_pos % component_size_;
      
      // Calculate how many elements we can read from this component
      int can_read = min(remaining, (int)(component_size_ - local_pos));
      
      // Set up the buffer component for reading from the correct position
      buffer_components[buffer_idx]->reset();
      for (size_t i = 0; i < local_pos; i++) {
        T dummy;
        buffer_components[buffer_idx]->read(dummy);
      }
      
      // Read from the buffer component
      int actually_read = buffer_components[buffer_idx]->readArray(data + total_read, can_read);
      
      // Update positions
      total_read += actually_read;
      read_pos += actually_read;
      remaining -= actually_read;
      
      // If we couldn't read as much as expected, stop
      if (actually_read < can_read) {
        break;
      }
    }
    
    return total_read;
  }
  int readArray(T data[], int len) override  {…}
 
  int writeArray(const T data[], int len) override {
    if (data == nullptr) {
      return 0;
    }
    
    int total_written = 0;
    int remaining = len;
    
    while (remaining > 0) {
      // Check if we need to add a new buffer component
      if (isCurrentBufferFull()) {
        if (!addBufferComponent()) {
          break; // Couldn't expand, so stop writing
        }
      }
      
      // Find the current buffer component and position
      size_t buffer_idx = write_pos / component_size_;
      size_t local_pos = write_pos % component_size_;
      
      // Calculate how many elements we can write to this component
      int can_write = min(remaining, (int)(component_size_ - local_pos));
      
      // Set up the buffer component for writing at the correct position
      buffer_components[buffer_idx]->reset();
      for (size_t i = 0; i < local_pos; i++) {
        buffer_components[buffer_idx]->write(T()); // Write dummy values
      }
      
      // Write to the buffer component
      int actually_written = buffer_components[buffer_idx]->writeArray(data + total_written, can_write);
      
      // Update positions
      total_written += actually_written;
      write_pos += actually_written;
      remaining -= actually_written;
      
      // If we couldn't write as much as expected, stop
      if (actually_written < can_write) {
        break;
      }
    }
    
    return total_written;
  }
  int writeArray(const T data[], int len) override  {…}
 
  void reset() override {
    read_pos = 0;
    write_pos = 0;
    
    // Reset all buffer components
    for (auto* buffer : buffer_components) {
      buffer->reset();
    }
  }
  void reset() override  {…}
 
  int available() override {
    return write_pos - read_pos;
  }
  int available() override  {…}
 
  int availableForWrite() override {
    // Calculate space in existing buffers
    size_t existing_space = totalCapacity() - write_pos;
    
    // If no maximum component limit, return a large value
    if (max_components_ == 0 || buffer_components.size() < max_components_) {
      return existing_space + 1000000; // Effectively unlimited
    }
    
    return existing_space;
  }
  int availableForWrite() override  {…}
 
  bool isFull() override {
    if (max_components_ == 0) {
      return false; // Never full if unlimited components
    }
    
    return buffer_components.size() >= max_components_ && isCurrentBufferFull();
  }
  bool isFull() override  {…}
 
  bool isEmpty() override {
    return available() == 0;
  }
  bool isEmpty() override  {…}
 
  T* address() override {
    if (isEmpty() || buffer_components.empty()) {
      return nullptr;
    }
    
    size_t buffer_idx = read_pos / component_size_;
    return buffer_components[buffer_idx]->address();
  }
  T* address() override  {…}
 
  size_t size() override {
    return totalCapacity();
  }
  size_t size() override  {…}
 
  bool resize(int new_size) override {
    // Calculate needed components
    size_t needed_components = (new_size + component_size_ - 1) / component_size_;
    
    // Check if we're allowed to have this many components
    if (max_components_ != 0 && needed_components > max_components_) {
      needed_components = max_components_;
    }
    
    // Remove excess components
    while (buffer_components.size() > needed_components) {
      delete buffer_components.back();
      buffer_components.pop_back();
    }
    
    // Add needed components
    while (buffer_components.size() < needed_components) {
      if (!addBufferComponent()) {
        return false;
      }
    }
    
    // Adjust read/write positions if they're now out of bounds
    size_t total_capacity = totalCapacity();
    if (write_pos > total_capacity) {
      write_pos = total_capacity;
    }
    if (read_pos > write_pos) {
      read_pos = write_pos;
    }
    
    return true;
  }
  bool resize(int new_size) override  {…}
 
  size_t getComponentCount() {
    return buffer_components.size();
  }
  size_t getComponentCount() {…}
 
  size_t getComponentSize() {
    return component_size_;
  }
  size_t getComponentSize() {…}
 
 protected:
  Vector<BufferType<T>*> buffer_components; // Collection of buffer components
  size_t component_size_ = 0;    // Size of each component in elements
  size_t max_components_ = 0;    // Maximum number of components (0 = unlimited)
  size_t read_pos = 0;           // Global read position
  size_t write_pos = 0;          // Global write position
 
  bool addBufferComponent() {
    // Check if we're allowed to add more components
    if (max_components_ != 0 && buffer_components.size() >= max_components_) {
      LOGW("Maximum number of buffer components reached: %d", (int)max_components_);
      return false;
    }
    
    // Create new buffer component
    BufferType<T>* new_buffer = new BufferType<T>(component_size_);
    if (new_buffer == nullptr) {
      LOGE("Failed to allocate new buffer component");
      return false;
    }
 
    // make sure the component has the correct size
    new_buffer->resize(component_size_);
    
    // Add to our collection
    buffer_components.push_back(new_buffer);
    LOGI("Added buffer component #%d", (int)buffer_components.size());
    
    return true;
  }
  bool addBufferComponent() {…}
 
  size_t totalCapacity() {
    return buffer_components.size() * component_size_;
  }
  size_t totalCapacity() {…}
 
  bool isCurrentBufferFull() {
    if (buffer_components.empty()) {
      return true;
    }
    
    size_t buffer_idx = write_pos / component_size_;
    size_t local_pos = write_pos % component_size_;
    
    return local_pos >= component_size_ || buffer_idx >= buffer_components.size();
  }
  bool isCurrentBufferFull() {…}
};
class DynamicMultiBuffer : public BaseBuffer<T> {…};
 
}