decoder.hpp

#pragma once
 
#include <bit>
#include <bitset>
#include <concepts>
#include <cstdint>
#include <iostream>
#include <type_traits>
 
#include "itk/logger.hpp"
#include "itk/itkpix/geo/geometry.hpp"
#include "itk/itkpix/endec/deccore.hpp"
 
#include "bintree.hpp"
#include "bitstream.hpp"
#include "print_utils.hpp"
 
 
 
namespace itk::itkpix::endec::codec {
 
[[maybe_unused]] static inline print<false> logger;
 
extern itk::Logger log;
 
// using Hit = itk::pixel::datafmt::Hit;
using Options = itk::itkpix::endec::Options;
 
//template <typename T, itkpix::concepts::DecoderOutput<Hit> OutPut, bool EnableLogging = false>
template <itk::itkpix::endec::concepts::EventCallback OutPut, bool EnableLogging = false>
class StreamDecoder {
//  using ItkChip = itkpix::frontend::ItkChip;
  static inline print<EnableLogging> logger;
 
 public:
  StreamDecoder(const std::span<const uint64_t> data_, OutPut &proc, Options opt = Options())
      : data(data_, opt.en_chip_id ? 3 : 1), out(proc), options(opt) {}
 
  ~StreamDecoder() = default;
 
  void decode() {
    uint64_t ccol = 999999;
    uint64_t tag;
    uint64_t qrow = 0;
    bool is_neighbor = false;
    bool is_last = true;
 
    auto fetch_ccol = [&]() mutable -> bool {
      bool result;
      std::tie(result, ccol) = data.fetch(6);
      logger.ccol(ccol);
      if ((ccol >> 3) == 0b111) {  // internal tag
        auto [result1, intTag] = data.fetch(5);
        intTag |= ((ccol & 0b111) << 5);
        bool result2;
        std::tie(result2, ccol) = data.fetch(6);
        logger.internal_tag(intTag);
        out.evt_init(intTag);
      }
      if (ccol == 0) return false;
      return result;
    };
 
    auto fetch_ctrl = [&]() mutable -> bool {
      auto [result, ctrl] = data.fetch(2);
      is_last = (ctrl & 2) == 2;
      is_neighbor = (ctrl & 1) == 1;
      logger.ctrl(ctrl);
      return result;
    };
 
    auto fetch_hitmap = [&]() -> bool {
      auto [result, hit_map] = data.prefetch(30);
      uint32_t decoded{};
      auto len = BinaryTreeLUT::decode(hit_map, decoded);
      data.advance(len);
      logger.hitmap(hit_map >> (30 - len), len, decoded);
      // auto hits = std::popcount(decoded);
 
      auto hits = BinaryTreeLUT::hit_lut_length[decoded];
      auto [result1, tots] = data.fetch(hits * 4);
      logger.tot(tots, hits);
      // printf("hitmap: %04x, totmap: %016lx\n", decoded, tots);
 
      int hit_count = hits;
      auto h = BinaryTreeLUT::hit_lut[decoded];
 
      uint16_t col_base = (ccol - 1) * itk::itkpix::geo::NumQColPix;
      uint16_t row_base = qrow * itk::itkpix::geo::NumQRowPix;
      for (int i = 0; i < hits; ++i) {
        uint16_t col = col_base + uint16_t(h[i].first);
        uint16_t row = row_base + uint16_t(h[i].second);
        hit_count--;
        uint16_t tot = ((tots >> (hit_count * 4)) & 0xf);
        //tot++; // tot from 1..16
        // hit_cache[i] = {col, row, tot};
        out.add_hit(col, row, tot);
      }
      // out.add_hits(hit_cache.data(), hits);
      return result;
    };
 
    bool result;
    std::tie(result, tag) = data.fetch(8);
    logger.tag(tag);
    out.evt_init(tag);
    while (data.left() > 6 && ccol != 0) {
      if (is_last) {
        auto success = fetch_ccol();
        if (!success) break;
      }
      fetch_ctrl();
      if (!is_neighbor) {
        bool result;
        std::tie(result, qrow) = data.fetch(8);
        logger.qrow(qrow);
      } else {
        qrow++;
      }
      fetch_hitmap();
    }
  }
 
  std::size_t bits_processed() const { return data.index(); }
 
private:
  static inline constexpr uint64_t bit_mask(std::size_t n) { return (uint64_t(1) << n) - 1; }
 
  BitStreamReader<const std::span<uint64_t>> data;
  OutPut &out;
  const Options options;
};
 
 
}  // itk::itkpix::endec::codec
 
 
namespace itk::itkpix::endec::codec {
 
extern itk::Logger log;
 
template<typename Callback, int cb_type = 0>
class DecCore {
public:
  using EventCallback = Callback;
 
  DecCore(Options opt, EventCallback& cb_evt)
  : opt(opt), cb_evt(cb_evt) {
    log.trace("slac.DecCore(opt, evt)");
  }
 
  inline void initialize() {
    log.trace("slac.initialize");
  }
  inline void finalize() {
    log.trace("slac.finalize");
  }
  inline void decode(uint64_t data64) {
    log.warn("not implemented | slac.decode(data64: 0x{:016x})", data64);
  }
  inline void decode(const uint8_t *buff, size_t size) {
    auto data = std::span<const uint8_t>{buff, size};
    decode(data);
  }
  inline void decode(const uint64_t *buff64, size_t size64) {
    auto data64 = std::span<const uint64_t>{buff64, size64};
    decode(data64);
  }
 
  inline void decode(const std::span<const uint8_t> buff) {
    log.trace("slac.decode(buff) | size64: {}", buff.size());
    for (auto data : buff) {
      log.trace("  0x{:02x}", data);
    }
  }
  inline void decode(const std::span<const uint64_t> buff64) {
    //log.info("wittgen.decode(buff64) | size64: {}", buff64.size());
    //for (auto data64 : buff64) {
    //  log.info("  0x{:016x}", data64);
    //}
 
    StreamDecoder<EventCallback> dec(buff64, cb_evt, opt);
    dec.decode();
  }
 
  Options opt;
  EventCallback& cb_evt;
};
 
} // itk::itkpix::endec::codec