Codec.h

#pragma once
#include <stddef.h>
#include <stdint.h>
#include <assert.h>
 
#include "pulse/Preamble.h"
#include "pulse/SignalBase.h"
#include "pulse/tools/Vector.h"
#include "pulse/tools/Logger.h"
 
namespace pulsewire {
 
enum class CodecEnum { PulseDistance, PulseWidth, Manchester, DifferentialManchester, NRZ };
 
const char* toStr(CodecEnum codec) {
  switch (codec) {
    case CodecEnum::PulseDistance:
      return "PulseDistance";
    case CodecEnum::PulseWidth:
      return "PulseWidth";
    case CodecEnum::Manchester:
      return "Manchester";
    case CodecEnum::DifferentialManchester:
      return "DifferentialManchester";
    case CodecEnum::NRZ:
      return "NRZ";
    default:
      return "Unknown";
  }
}
 
class Codec {
 public:
  Codec() = default;
 
  Codec(Preamble& preambleDetector) : _preamble(&preambleDetector) {}
 
  virtual void init(Preamble& detector, uint32_t shortPulseUs = 600,
                    uint32_t longPulseUs = 1200, uint32_t toleranceUs = 200) {}
 
  virtual bool begin(uint32_t bitFrequencyHz) {
    TRACE();
    assert(_preamble != nullptr);
    _inFrame = false;
    _bitFrequencyHz = bitFrequencyHz;
    _bitPeriodUs = 1000000UL / bitFrequencyHz;  // Bit period in microseconds
    _preamble->begin(bitFrequencyHz);
    _decodeEdgeStream.reserve(getEdgeCount());
    return true;
  }
 
  virtual void reset() {
    _decodeEdgeStream.clear();  // clear() keeps capacity, no realloc
    _inFrame = false;
    _preamble->reset();
  }
 
  Preamble& getPreamble() { return *_preamble; }
 
  void setPreamble(Preamble& preamble) { _preamble = &preamble; }
  virtual size_t getEdgeCount() const = 0;
 
  virtual bool decodeEdge(uint32_t durationUs, bool level, uint8_t& result) {
    // ensure that edges are allocated
    assert(_decodeEdgeStream.capacity() > 0);
 
     // Filter idle gaps
    if (level == getIdleLevel() && durationUs > getEndOfFrameDelayUs()) {
      Logger::debug("Idle gap detected: %d us, resetting decoder", durationUs);
      reset();
      return false;
    }
   
    OutputEdge newEdge{level, durationUs};
    assert(_preamble != nullptr);
    if (!_inFrame) {
      if (_preamble->preambleLength() == 0) {
        // no preamble, the edge is valid playload
        _decodeEdgeStream.clear();
        _decodeEdgeStream.push_back(newEdge);
        _inFrame = true;
        Logger::debug("No preamble, starting new frame");
      } else if (_preamble->detect(newEdge)) {
        // Detected preamble, start new frame
        _inFrame = true;
        _decodeEdgeStream.clear();
        Logger::debug("Preamble detected, starting new frame");
      }
    } else {
      _decodeEdgeStream.push_back(newEdge);
    }
 
    // Try to decode bytes if enough edges collected
    if (_decodeEdgeStream.size() == getEdgeCount()) {
      bool rc = decodeByte(_decodeEdgeStream, result);
      Logger::debug("Decoded byte: 0x%x", result);
      _decodeEdgeStream.clear();
      return rc;
    }
    return false;
  }
 
  size_t encodePreamble(Vector<OutputEdge>& output) {
    if (_preamble == nullptr) return 0;
    return _preamble->getEdges(output);
  }
 
  virtual size_t encode(uint8_t byte, Vector<OutputEdge>& output) {
    Vector<bool> bits;
    bits.reserve(8);
    encodeByte(byte, bits);
    size_t total = 0;
    for (int i = 0; i < 8; ++i) {
      total += encodeBit(bits[i], output);
    }
    return total;
  }
 
  void setFrameSize(uint16_t size) {
    _decodeEdgeStream.reserve(size * getEdgeCount());
  }
 
  virtual size_t encodeBit(bool bit, Vector<OutputEdge>& output) { return 0; };
 
  virtual void encodeByte(uint8_t byte, std::vector<bool> &bits) const {
    for (int i = 7; i >= 0; --i) {
      bool bit = (byte >> i) & 0x01;
      bits[7 - i] = bit ? 1 : 0;
    }
  }
 
  virtual bool decodeByte(Vector<OutputEdge>& edges, uint8_t& result) = 0;
 
  virtual int getEndOfFrameDelayUs() = 0;
 
  virtual bool getIdleLevel() const {
    return false;
  }
 
  virtual CodecEnum getCodecType() const = 0;
 
  const char* name() const { return toStr(getCodecType()); }
 
 
 protected:
  CustomPreambleUs _defaultPreamble;
  Preamble* _preamble = &_defaultPreamble;
  uint16_t _bitFrequencyHz = 0;
  uint32_t _bitPeriodUs = 0;
  Vector<OutputEdge> _decodeEdgeStream;
  volatile bool _inFrame = false;
};
 
}  // namespace pulsewire