webrtc_H265player/test/prod_decoder/codec/3rdparty/de265/libde265/cabac.h

/*
 * H.265 video codec.
 * Copyright (c) 2013-2014 struktur AG, Dirk Farin <farin@struktur.de>
 *
 * This file is part of libde265.
 *
 * libde265 is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as
 * published by the Free Software Foundation, either version 3 of
 * the License, or (at your option) any later version.
 *
 * libde265 is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with libde265.  If not, see <http://www.gnu.org/licenses/>.
 */

#ifndef DE265_CABAC_H
#define DE265_CABAC_H

#include <stdint.h>
#include "contextmodel.h"


typedef struct {
  uint8_t* bitstream_start;
  uint8_t* bitstream_curr;
  uint8_t* bitstream_end;

  uint32_t range;
  uint32_t value;
  int16_t  bits_needed;
} CABAC_decoder;


void init_CABAC_decoder(CABAC_decoder* decoder, uint8_t* bitstream, int length);
void init_CABAC_decoder_2(CABAC_decoder* decoder);
int  decode_CABAC_bit(CABAC_decoder* decoder, context_model* model);
int  decode_CABAC_TU(CABAC_decoder* decoder, int cMax, context_model* model);
int  decode_CABAC_term_bit(CABAC_decoder* decoder);

int  decode_CABAC_bypass(CABAC_decoder* decoder);
int  decode_CABAC_TU_bypass(CABAC_decoder* decoder, int cMax);
int  decode_CABAC_FL_bypass(CABAC_decoder* decoder, int nBits);
int  decode_CABAC_TR_bypass(CABAC_decoder* decoder, int cRiceParam, int cTRMax);
int  decode_CABAC_EGk_bypass(CABAC_decoder* decoder, int k);


// ---------------------------------------------------------------------------

class CABAC_encoder
{
public:
 CABAC_encoder() : mCtxModels(NULL) { }
  virtual ~CABAC_encoder() { }

  virtual int size() const = 0;
  virtual void reset() = 0;

  // --- VLC ---

  virtual void write_bits(uint32_t bits,int n) = 0;
  virtual void write_bit(int bit) { write_bits(bit,1); }
  virtual void write_uvlc(int value);
  virtual void write_svlc(int value);
  virtual void write_startcode() = 0;
  virtual void skip_bits(int nBits) = 0;

  virtual void add_trailing_bits();
  virtual int  number_free_bits_in_byte() const = 0;

  // output all remaining bits and fill with zeros to next byte boundary
  virtual void flush_VLC() { }


  // --- CABAC ---

  void set_context_models(context_model_table* models) { mCtxModels=models; }

  virtual void init_CABAC() { }
  virtual void write_CABAC_bit(int modelIdx, int bit) = 0;
  virtual void write_CABAC_bypass(int bit) = 0;
  virtual void write_CABAC_TU_bypass(int value, int cMax);
  virtual void write_CABAC_FL_bypass(int value, int nBits);
  virtual void write_CABAC_term_bit(int bit) = 0;
  virtual void flush_CABAC()  { }

  void write_CABAC_EGk(int absolute_symbol, int k); // absolute_symbol >= 0

  virtual bool modifies_context() const = 0;

  float RDBits_for_CABAC_bin(int modelIdx, int bit);

 protected:
  context_model_table* mCtxModels;
};


class CABAC_encoder_bitstream : public CABAC_encoder
{
public:
  CABAC_encoder_bitstream();
  ~CABAC_encoder_bitstream();

  virtual void reset();

  virtual int size() const { return data_size; }
  uint8_t* data() const { return data_mem; }

  // --- VLC ---

  virtual void write_bits(uint32_t bits,int n);
  virtual void write_startcode();
  virtual void skip_bits(int nBits);

  virtual int  number_free_bits_in_byte() const;

  // output all remaining bits and fill with zeros to next byte boundary
  virtual void flush_VLC();


  // --- CABAC ---

  virtual void init_CABAC();
  virtual void write_CABAC_bit(int modelIdx, int bit);
  virtual void write_CABAC_bypass(int bit);
  virtual void write_CABAC_term_bit(int bit);
  virtual void flush_CABAC();

  virtual bool modifies_context() const { return true; }

private:
  // data buffer

  uint8_t* data_mem;
  uint32_t data_capacity;
  uint32_t data_size;
  char     state; // for inserting emulation-prevention bytes

  // VLC

  uint32_t vlc_buffer;
  uint32_t vlc_buffer_len;


  // CABAC

  uint32_t range;
  uint32_t low;
  int8_t   bits_left;
  uint8_t  buffered_byte;
  uint16_t num_buffered_bytes;


  void check_size_and_resize(int nBytes);
  void testAndWriteOut();
  void write_out();
  void append_byte(int byte);
};


class CABAC_encoder_estim : public CABAC_encoder
{
public:
  CABAC_encoder_estim() : mFracBits(0) { }

  virtual void reset() { mFracBits=0; }

  virtual int size() const { return mFracBits>>(15+3); }

  uint64_t getFracBits() const { return mFracBits; }
  float    getRDBits() const { return mFracBits / float(1<<15); }

  // --- VLC ---

  virtual void write_bits(uint32_t bits,int n) { mFracBits += n<<15; }
  virtual void write_bit(int bit) { mFracBits+=1<<15; }
  virtual void write_startcode() { mFracBits += (1<<15)*8*3; }
  virtual void skip_bits(int nBits) { mFracBits += nBits<<15; }
  virtual int  number_free_bits_in_byte() const { return 0; } // TODO, good enough for now

  // --- CABAC ---

  virtual void write_CABAC_bit(int modelIdx, int bit);
  virtual void write_CABAC_bypass(int bit) {
    mFracBits += 0x8000;
  }
  virtual void write_CABAC_FL_bypass(int value, int nBits) {
    mFracBits += nBits<<15;
  }
  virtual void write_CABAC_term_bit(int bit) { /* not implemented (not needed) */ }

  virtual bool modifies_context() const { return true; }

 protected:
  uint64_t mFracBits;
};


class CABAC_encoder_estim_constant : public CABAC_encoder_estim
{
 public:
  void write_CABAC_bit(int modelIdx, int bit);

  virtual bool modifies_context() const { return false; }
};

#endif