ECLCompress.h

/**************************************************************************
 * BASF2 (Belle Analysis Framework 2)                                     *
 * Copyright(C) 2017 - Belle II Collaboration                             *
 *                                                                        *
 * Author: The Belle II Collaboration                                     *
 * Contributors: Alexei Sibidanov                                         *
 *                                                                        *
 * This software is provided "as is" without any warranty.                *
 **************************************************************************/
 
#ifndef ECLCOMPRESS_H
#define ECLCOMPRESS_H
 
#include <algorithm>
#include <vector>
#include <string.h>
 
namespace Belle2 {
  namespace ECL {
    unsigned int ilog2(unsigned int v);
 
    class BitStream {
    public:
      BitStream(): m_pos(0) {}
 
      explicit BitStream(int n): m_pos(0)
      {
        m_store.resize(n);
        memset(m_store.data(), 0, m_store.size()*sizeof(unsigned int));
      }
 
      void putNBits(unsigned int value, unsigned int n)
      {
        unsigned int bpos = m_pos % 32, wpos = m_pos / 32;
        value &= 0xffffffffu >> (32 - n);
        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;
        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);
  }
}
#endif