ECLCompress.h

/**************************************************************************
 * basf2 (Belle II Analysis Software Framework)                           *
 * Author: The Belle II Collaboration                                     *
 *                                                                        *
 * See git log for contributors and copyright holders.                    *
 * This file is licensed under LGPL-3.0, see LICENSE.md.                  *
 **************************************************************************/
 
#pragma once
 
#include <algorithm>
#include <vector>
#include <framework/utilities/Utils.h>
 
namespace Belle2 {
  namespace ECL {
    unsigned int ilog2(unsigned int v);
 
    class BitStream {
    public:
      BitStream(): m_pos(0), m_store(1, 0) {}
 
      explicit BitStream(int n): m_pos(0), m_store(n, 0) {}
 
      void putNBits(unsigned int value, unsigned int n)
      {
        unsigned int bpos = m_pos % 32, wpos = m_pos / 32;
        value &= 0xffffffffu >> (32 - n);
        // check if we have enough space and double in size if necessary.
        if (branch_unlikely(m_pos + n > m_store.size() * 32)) m_store.resize(2 * m_store.size(), 0);
        m_store[wpos] |= value << bpos;
        if (bpos + n > 32) m_store[wpos + 1] = value >> (32 - bpos);
        m_pos += n;
      }
 
      unsigned int getNBits(unsigned int n)
      {
        unsigned int bpos = m_pos % 32, wpos = m_pos / 32;
        // make sure we don't access memory we don't own
        if (branch_unlikely(m_pos + n > m_store.size() * 32)) throw std::range_error("Not enough bits in stream");
        unsigned int res = m_store[wpos] >> bpos;
        if (bpos + n > 32) res |= m_store[wpos + 1] << (32 - bpos);
        m_pos += n;
        return res & (0xffffffffu >> (32 - n));
      }
 
      size_t getPos() const {return m_pos;}
 
      void setPos(size_t pos) {m_pos = pos;}
 
      std::vector<unsigned int>& getStore() {return m_store;}
 
      void resize()
      {
        m_store.resize((m_pos + 31) / 32);
      }
    protected:
      size_t m_pos; 
      std::vector<unsigned int> m_store; 
    };
 
    struct width_t {
      unsigned char w0, 
               w1, 
               w2, 
               w3; 
    };
 
    class ECLCompress {
    public:
      virtual ~ECLCompress() {};
 
      virtual void compress(BitStream& out, const int* adc) = 0;
 
      virtual void uncompress(BitStream& in, int* adc) = 0;
    };
 
    class ECLBaseCompress: public ECLCompress {
    public:
      void compress(BitStream& out, const int* adc) override;
      void uncompress(BitStream& out, int* adc) override;
    };
 
    class ECLDeltaCompress: public ECLCompress {
    public:
      void compress(BitStream& out, const int* adc) override;
      void uncompress(BitStream& out, int* adc) override;
    };
 
    class ECLDCTCompress: public ECLCompress {
    public:
      ECLDCTCompress(double scale, double c0, width_t* w);
      void compress(BitStream& out, const int* adc) override;
      void uncompress(BitStream& out, int* adc) override;
    protected:
      const double m_scale; 
      const double m_c0; 
      const width_t* m_widths; 
    };
 
    ECLCompress* selectAlgo(int compAlgo);
  }
}