deccore.hpp

Go to the documentation of this file.

// ╭─╮╭─╴╷╭─╮┌─╮
// ╰─╯╵  ╵╰─╯╵ ╵
#pragma once
 
#include <functional>
 
#include "itk/logger.hpp"
#include "itk/itkpix/endec/deccore.hpp"
 
// #include "orion/itkpix/endec.hpp"
 
namespace itk::itkpix::endec::orion {
 
extern factory::DecCore makeDecCore;
 
extern itk::Logger log;
 
 
template<typename T, int cb_type = 0>
class DecCore : public intf::EventCallback {
public:
  using EventCallback = T;
 
  Options opt;
  // orion::EventCallback<T, cb_type> cb;
  EventCallback& cb;
  intf::DecCore* dec;
 
  DecCore(Options opt, EventCallback& cb_evt) : opt(opt), cb(cb_evt) {
    log.debug("orion.DecCore(opt, evt)");
    dec = makeDecCore(opt, *this, 1);
  }
 
  ~DecCore() {
    delete dec;
  }
 
  inline void initialize() {
    log.debug("initialize()");
    dec->initialize();
  }
  inline void finalize() {
    log.debug("finalize()");
    dec->finalize();
  }
  inline void decode(uint64_t data64) { dec->decode(data64); }
  inline void decode(const uint8_t *buff, size_t size) { decode({ buff, size }); }
  inline void decode(const uint64_t *buff64, size_t size64) { decode({ buff64, size64 }); }
 
  inline void decode(const std::span<const uint8_t> buff) { dec->decode(buff); }
  inline void decode(const std::span<const uint64_t> buff64) { dec->decode(buff64); }
 
private:
  // EventCallback methods
  void evt_init(uint8_t tag) override { cb.evt_init(tag); }
  void evt_next(uint8_t tag) override { cb.evt_next(tag); }
  void evt_done() override { cb.evt_done(); }
 
  void add_hit(uint16_t col, uint16_t row, uint16_t tot) override {
    cb.add_hit(col, row, tot);
  }
  void add_qcore(uint8_t qcol, uint8_t qrow, uint64_t qtot) override {
    cb.add_qcore(qcol, qrow, qtot);
  }
 
  void add_hmap(uint8_t qcol, uint8_t qrow, uint16_t hmap, uint64_t tots) override {
    if (cb_type == 1) cb.add_hmap(qcol, qrow, hmap, tots);
    if (cb_type == 0 || cb_type == 2) {
      uint pix_col = qcol*8;
      uint pix_row = qrow*2;
 
      uint64_t qtot = 0;
      if (cb_type == 2) tots = ~tots;
 
      uint htmp = hmap;
      while (htmp) {
        uint i = __builtin_clz(htmp);
        htmp ^= 0x80000000 >> i;
        uint col = pix_col + (i - 16) % 8;
        uint row = pix_row + (i - 16) / 8;
        uint tot = tots >> 60;
        tots = tots << 4;
        if (cb_type == 0) cb.add_hit(col, row, tot);
        if (cb_type == 2) qtot |= tot << (4*(31 - i));
      }
      if (cb_type == 2) {
        qtot = ~qtot;
        cb.add_qcore(qcol, qrow, qtot);
      }
    }
  }
 
  uint8_t on_error(EventError error) override { return cb.on_error(error); }
 
};
 
 
} // itk::itkpix::endec::orion