arith_code.hh

Go to the documentation of this file.

/*
 * @author Andrea C. G. Mennucci
 *
 * @file arith_code.hh
 *
 * @copyright (C) 2010-2019 Andrea C. G. Mennucci
 *
 * The new BSD License is applied to this software, see LICENSE.txt
 *
 */



namespace AC {

#include "arith_code_config.hh"


/*********** general constants ****/

#if (AC_representation_bitsize <= 15)
typedef uint16_t    I_t;
typedef uint32_t  long_I_t;
#define AC_PRI_I_t  PRId16
#define AC_PRI_long_I_t  PRId32
#define AC_SIZE 16
#elif (AC_representation_bitsize <= 31)
typedef uint32_t    I_t;
typedef uint64_t  long_I_t;
#define AC_PRI_I_t  PRId32
#define AC_PRI_long_I_t  PRId64
#define AC_SIZE 32
#elif (AC_representation_bitsize <= 63)
typedef uint64_t        I_t;
typedef __int128  long_I_t;
#define AC_PRI_I_t  PRId64
#define AC_PRI_long_I_t  PRId128 //this does not exist...
#define AC_SIZE 64
#else
#error "ARITHMETIC CODEC says: too many bits"
#endif

typedef  I_t F_t;
#define AC_PRI_F_t  AC_PRI_I_t

const  I_t  MAX_FREQ = ((I_t)1)      << (AC_representation_bitsize-2) ;

typedef  std::pair<I_t, I_t>  interval_t;

typedef std::function<void(int,void *)> output_callback_t;

typedef std::function<int(void *)> input_callback_t;


class Base{

public:
  const char *prefix;

  FILE * verbose_stream = stdout;

  unsigned int number_input_bits();
  unsigned int number_input_symbols();
  unsigned int number_output_bits();
  unsigned int number_output_symbols();

  void print_state();

  interval_t  S_interval();

  interval_t  B_interval();

  int output_bit();

  void output_bits(output_callback_t out);


  F_t * cumulative_frequencies  = NULL;
  I_t max_symbol = -1;

  F_t * frequencies  = NULL;

  void frequencies2cumulative_frequencies();


  void *callback_data = NULL;

protected:
  //typedef std::function<void(int,Base *)> callback_B_t;


#ifdef AC_QUARTER_ZOOM
  /* counts virtual bits, in case of centered zooms */
  unsigned int bitsToFollow;
  /* stores the value of the virtual bit , or -1 if there is no virtual bit */
  int virtual_bit;
#endif

  const I_t One = 1;
  const I_t  Top =  (One   << AC_representation_bitsize);
  const I_t  Qtr =  (One   << (AC_representation_bitsize-2));
  const I_t  QtrMinus =  (One   << (AC_representation_bitsize-2)) - One;
  const I_t  Half = (Qtr*2);
  const I_t  ThreeQtr = (Qtr*3);

  F_t const cum_freq_uniform8[9] =  { 8 , 7 , 6 , 5, 4 , 3 , 2 , 1 , 0 };

  static const int n_symbols_flush = 8;

  F_t const * cum_freq_flush = cum_freq_uniform8;

  // the old table was
  //F_t const cum_freq_flush[n_symbols_flush+1] =  { Qtr , QtrMinus , 1 , 0 };

  I_t  Slow;
  I_t  Shigh;
  long_I_t Srange;

  I_t  Blow;
  I_t Bhigh;

  // operations on intervals
  void  doubleit();
  void  doublehi();
  void  doublelow();
  void  doublecen();

  I_t separ_low_high(int symb,  const F_t  * cum_freq);
  
  int  resize_pull_one_bit();
  
  I_t interval_right(int symb, const F_t * cum_freq);

  I_t interval_left(int symb, const F_t * cum_freq);

  void push_symbol(int symb, const F_t * cum_freq);

  void push_bit(int bit);

  unsigned int significant_bits;

  unsigned int n_in_bits,
    n_in_symbs,
    n_zooms,
    n_out_bits,
    n_out_symbs;

  Base();

};



/**************** ENCODER **********/
class Encoder : public Base { 

public:
  output_callback_t output_callback;

  Encoder(
      output_callback_t output_callback_ = NULL);

  void input_symbol( 
            int symb,
            const F_t * cum_freq = NULL);

  void flush();
};


/********************* DECODER **********/
class Decoder : public Base {

private:
  //
  int input_eof = 0;

  /* callback when the decoder decodes a symbol */
  output_callback_t output_callback;


  /* when this callback is called, the  S-interval in the decoder is the same as the
   * S-interval in the encoder (at the same bitcount)
   * This is used only for 
   */
  output_callback_t bit_callback;

  input_callback_t read_bit_call;

  /* signal that the next symbol will be deflushed */
  int flag_flush=0;

  int search(
         const F_t * cum_freq,
         int max_symb );

  int search_fast(
         const F_t * cum_freq,
         int max_symb );
  int output_symbol_standard(
                 const F_t * cp,
                 I_t ms
                 );

public:

  /* inizializza */
  Decoder(
      output_callback_t output_callback_ = NULL ,
      input_callback_t read_bit_call_ = NULL ,
      output_callback_t bit_callback_    = NULL
      );

  int output_symbol(
            F_t const *  cum_freq = NULL,
            I_t max_symb = -1
            );

#if 0
  void push_bit(int bit);
#endif


  void input_bit(int bit);

  void run();

  void prepare_for_deflush();

  int is_deflushing();
};



/***************** utilities ***********/
  
void freq2cum_freq(F_t cum_freq[], F_t freq[], int max_symb, int  assert_non_zero);

  
}