CommonHelix.h

#pragma once
#if defined(ARDUINO)
#  include "Arduino.h"
#else
// remove delay statment if used outside of arduino
#include <stdint.h>
#  define delay(ms)
#endif
 
// Not all processors support assert
#ifndef assert
#  ifdef NDEBUG
#    define assert(condition) ((void)0)
#  else
#    define assert(condition) /*implementation defined*/
#  endif
#endif
 
#include "ConfigHelix.h"
#include "utils/Allocator.h"
#include "utils/Buffers.h"
#include "utils/Vector.h"
#include "utils/helix_log.h"
 
namespace libhelix {
 
class CommonHelix {
 public:
#if defined(ARDUINO) || defined(HELIX_PRINT)
  void setOutput(Print &output) { this->out = &output; }
#endif
 
  virtual bool begin() {
    frame_buffer.reset();
    frame_counter = 0;
 
    if (active) {
      end();
    }
 
    if (!allocateDecoder()) {
      return false;
    }
    frame_buffer.resize(maxFrameSize());
    pcm_buffer.resize(maxPCMSize());
    memset(pcm_buffer.data(), 0, maxPCMSize());
    memset(frame_buffer.data(), 0, maxFrameSize());
    active = true;
    return true;
  }
 
  virtual void end() {
    frame_buffer.resize(0);
    pcm_buffer.resize(0);
 
    active = false;
  }
 
  virtual size_t write(const void *in_ptr, size_t in_size) {
    LOGI_HELIX( "write %zu", in_size);
    int open = in_size;
    size_t processed = 0;
    uint8_t *data = (uint8_t *)in_ptr;
    while (open > 0) {
      int bytes = writeChunk(data, MIN(open, HELIX_CHUNK_SIZE));
      // if we did not advance we leave the loop
      if (bytes == 0) break;
      open -= bytes;
      data += bytes;
      processed += bytes;
    }
    return processed;
  }
 
  operator bool() { return active; }
 
#ifdef ARDUINO
  uint64_t timeOfLastWrite() { return time_last_write; }
 
  uint64_t timeOfLastResult() { return time_last_result; }
#endif
 
  void flush() {
    int rc = 1;
    while (rc >= 0) {
      // we must start with sych word
      if (!presync()) break;
      // we must end with synch world 
      if (findSynchWord(3) < 0) break;
      rc = decode();
      if (!resynch(rc)) break;
      // remove processed data
      if (rc > 0) frame_buffer.clearArray(rc);    
    }
  }
 
  virtual size_t maxFrameSize() = 0;
 
  void setMaxFrameSize(size_t len) { max_frame_size = len; }
 
  virtual size_t maxPCMSize() = 0;
 
  void setMaxPCMSize(size_t len) { max_pcm_size = len; }
 
  void setReference(void* ref){
      p_caller_ref = ref;
  }
 
 protected:
  bool active = false;
  bool is_raw = false;
  Vector<uint8_t> pcm_buffer{0};
  SingleBuffer<uint8_t> frame_buffer{0};
  size_t max_frame_size = 0;
  size_t max_pcm_size = 0;
  size_t frame_counter = 0;
  int delay_ms = -1;
  int parse_0_count = 0; // keep track of parser returning 0
  int min_frame_buffer_size = 0;
  uint64_t time_last_write = 0;
  uint64_t time_last_result = 0;
  void *p_caller_ref = nullptr;
 
 
#if defined(ARDUINO) || defined(HELIX_PRINT)
  Print *out = nullptr;
#endif
 
  bool presync() {
    LOGD_HELIX( "presynch");
    bool rc = true;
    int pos = findSynchWord();
    if (pos > 3) rc = removeInvalidData(pos);
 
    return rc;
  }
 
  bool resynch(int rc) {
    LOGD_HELIX( "resynch: %d" , rc);
    // reset 0 result counter
    if (rc != 0) parse_0_count = 0;
    if (rc <= 0) {
      if (rc == 0) {
        parse_0_count++;
        int pos = findSynchWord(SYNCH_WORD_LEN);
        LOGD_HELIX( "rc: %d - available %d - pos %d", rc,
                  frame_buffer.available(), pos);
        // if we are stuck, request more data and if this does not help we
        // remove the invalid data
        if (parse_0_count > 2) {
          return removeInvalidData(pos);
        }
        return false;
      } else if (rc == -1) {
        // underflow
        LOGD_HELIX( "rc: %d - available %d", rc,
                  frame_buffer.available());
        return false;
      } else {
        // generic error handling: remove the data until the next synch word
        int pos = findSynchWord(SYNCH_WORD_LEN + 1);
        removeInvalidData(pos);
      }
    }
    return true;
  }
 
  bool removeInvalidData(int pos) {
    LOGD_HELIX( "removeInvalidData: %d", pos);
    if (pos > 0) {
      LOGI_HELIX( "removing: %d bytes", pos);
      frame_buffer.clearArray(pos);
      return true;
    } else if (pos <= 0) {
      frame_buffer.reset();
      return false;
    }
    return true;
  }
 
  virtual size_t writeChunk(const void *in_ptr, size_t in_size) {
    LOGI_HELIX( "writeChunk %zu", in_size);
#ifdef ARDUINO
    time_last_write = millis();
#endif
    size_t result = frame_buffer.writeArray((uint8_t *)in_ptr, in_size);
 
    while (frame_buffer.available() >= minFrameBufferSize()) {
 
      if (!presync()) break;
      int rc = decode();
      if (!resynch(rc)) break;
      // remove processed data
      frame_buffer.clearArray(rc);
      
      LOGI_HELIX( "rc: %d - available %d", rc,
                frame_buffer.available());
 
    }
 
    return result;
  }
 
  virtual int decode() = 0;
 
  virtual bool allocateDecoder() = 0;
 
  virtual int findSynchWord(int offset = 0) = 0;
 
  virtual int minFrameBufferSize() { return min_frame_buffer_size; }
  virtual void setMinFrameBufferSize(int size) { min_frame_buffer_size = size; }
};
 
}  // namespace libhelix