Class ArithmeticEncoder

src/arithmeticencoder.hpp:45–112

class ArithmeticBitModel;

class ArithmeticEncoder
{
public:

/* Constructor & Destructor                                  */
  ArithmeticEncoder();
  ~ArithmeticEncoder();

/* Manage encoding                                           */
  BOOL init(ByteStreamOut* outstream);
  void done();

/* Manage an entropy model for a single bit                  */
  ArithmeticBitModel* createBitModel();
  void initBitModel(ArithmeticBitModel* model);
  void destroyBitModel(ArithmeticBitModel* model);

/* Manage an entropy model for n symbols (table optional)    */
  ArithmeticModel* createSymbolModel(U32 n);
  void initSymbolModel(ArithmeticModel* model, U32 *table=0);
  void destroySymbolModel(ArithmeticModel* model);

/* Encode a bit with modelling                               */
  void encodeBit(ArithmeticBitModel* model, U32 sym);

/* Encode a symbol with modelling                            */
  void encodeSymbol(ArithmeticModel* model, U32 sym);

/* Encode a bit without modelling                            */
  void writeBit(U32 sym);

/* Encode bits without modelling                             */
  void writeBits(U32 bits, U32 sym);

/* Encode an unsigned char without modelling                 */
  void writeByte(U8 sym);

/* Encode an unsigned short without modelling                */
  void writeShort(U16 sym);

/* Encode an unsigned int without modelling                  */
  void writeInt(U32 sym);

/* Encode a float without modelling                          */
  void writeFloat(F32 sym);

/* Encode an unsigned 64 bit int without modelling           */
  void writeInt64(U64 sym);

/* Encode a double without modelling                         */
  void writeDouble(F64 sym);

/* Only write to outstream if ArithmeticEncoder is dummy     */
  ByteStreamOut* getByteStreamOut() const { return outstream; };

private:

  ByteStreamOut* outstream;