Codec.h

#pragma once
#include <assert.h>
#include <stddef.h>
#include <stdint.h>
 
#include "pulse/Preamble.h"
#include "pulse/SignalBase.h"
#include "pulse/tools/Logger.h"
#include "pulse/tools/Vector.h"
 
namespace pulsewire {
 
enum class CodecEnum {
  PulseDistance,
  PulseWidth,
  Manchester,
  DifferentialManchester,
  NRZ,
  RZ,
  Miller
};
 
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";
    case CodecEnum::RZ:
      return "RZ";
    case CodecEnum::Miller:
      return "Miller";
    default:
      return "Unknown";
  }
}
 
class Codec {
  friend class RecorderCodec;
 
 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();
  }
  void setPreamble(Preamble& preamble) { _preamble = &preamble; }
 
  Preamble& getPreamble() { return *_preamble; }
 
  virtual size_t getEdgeCount() const = 0;
 
  void setFrameSize(uint16_t size) {
    _frameSize = size;
    _decodeEdgeStream.reserve(size * getEdgeCount());
  }
 
  uint16_t getFrameSize() const { return _frameSize; }
 
  virtual int getEndOfFrameDelayUs() = 0;
 
  virtual bool getIdleLevel() const { return false; }
 
  virtual CodecEnum getCodecType() const = 0;
 
  const char* name() const { return toStr(getCodecType()); }
 
  virtual bool decodeEdge(uint32_t durationUs, bool level, uint8_t& result) = 0;
 
  /***
   * @brief Fill output vector with protocol-specific preamble for the
   * preamble.
   */
  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)  = 0;
 
  virtual size_t flushEncoder(Vector<OutputEdge>& output) { return 0; }
 
 protected:
  CustomPreambleUs _defaultPreamble;
  Preamble* _preamble = &_defaultPreamble;
  uint16_t _bitFrequencyHz = 0;
  uint32_t _bitPeriodUs = 0;
  Vector<OutputEdge> _decodeEdgeStream;
  volatile bool _inFrame = false;
  uint16_t _frameSize = 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;
    }
  }
};
 
}  // namespace pulsewire