/*

 * 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/>.

 */

#include "cabac.h"

#include "util.h"

#include <stdint.h>

#include <stdio.h>

#include <stdlib.h>

#include <assert.h>

#define INITIAL_CABAC_BUFFER_CAPACITY 4096

static const uint8_t LPS_table[64][4] =

  {

    { 128, 176, 208, 240},

    { 128, 167, 197, 227},

    { 128, 158, 187, 216},

    { 123, 150, 178, 205},

    { 116, 142, 169, 195},

    { 111, 135, 160, 185},

    { 105, 128, 152, 175},

    { 100, 122, 144, 166},

    {  95, 116, 137, 158},

    {  90, 110, 130, 150},

    {  85, 104, 123, 142},

    {  81,  99, 117, 135},

    {  77,  94, 111, 128},

    {  73,  89, 105, 122},

    {  69,  85, 100, 116},

    {  66,  80,  95, 110},

    {  62,  76,  90, 104},

    {  59,  72,  86,  99},

    {  56,  69,  81,  94},

    {  53,  65,  77,  89},

    {  51,  62,  73,  85},

    {  48,  59,  69,  80},

    {  46,  56,  66,  76},

    {  43,  53,  63,  72},

    {  41,  50,  59,  69},

    {  39,  48,  56,  65},

    {  37,  45,  54,  62},

    {  35,  43,  51,  59},

    {  33,  41,  48,  56},

    {  32,  39,  46,  53},

    {  30,  37,  43,  50},

    {  29,  35,  41,  48},

    {  27,  33,  39,  45},

    {  26,  31,  37,  43},

    {  24,  30,  35,  41},

    {  23,  28,  33,  39},

    {  22,  27,  32,  37},

    {  21,  26,  30,  35},

    {  20,  24,  29,  33},

    {  19,  23,  27,  31},

    {  18,  22,  26,  30},

    {  17,  21,  25,  28},

    {  16,  20,  23,  27},

    {  15,  19,  22,  25},

    {  14,  18,  21,  24},

    {  14,  17,  20,  23},

    {  13,  16,  19,  22},

    {  12,  15,  18,  21},

    {  12,  14,  17,  20},

    {  11,  14,  16,  19},

    {  11,  13,  15,  18},

    {  10,  12,  15,  17},

    {  10,  12,  14,  16},

    {   9,  11,  13,  15},

    {   9,  11,  12,  14},

    {   8,  10,  12,  14},

    {   8,   9,  11,  13},

    {   7,   9,  11,  12},

    {   7,   9,  10,  12},

    {   7,   8,  10,  11},

    {   6,   8,   9,  11},

    {   6,   7,   9,  10},

    {   6,   7,   8,   9},

    {   2,   2,   2,   2}

  };

static const uint8_t renorm_table[32] =

  {

    6,  5,  4,  4,

    3,  3,  3,  3,

    2,  2,  2,  2,

    2,  2,  2,  2,

    1,  1,  1,  1,

    1,  1,  1,  1,

    1,  1,  1,  1,

    1,  1,  1,  1

  };

static const uint8_t next_state_MPS[64] =

  {

    1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,

    17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,

    33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,

    49,50,51,52,53,54,55,56,57,58,59,60,61,62,62,63

  };

static const uint8_t next_state_LPS[64] =

  {

    0,0,1,2,2,4,4,5,6,7,8,9,9,11,11,12,

    13,13,15,15,16,16,18,18,19,19,21,21,22,22,23,24,

    24,25,26,26,27,27,28,29,29,30,30,30,31,32,32,33,

    33,33,34,34,35,35,35,36,36,36,37,37,37,38,38,63

  };

#ifdef DE265_LOG_TRACE

int logcnt=1;

#endif

void CABAC_decoder::init(uint8_t* bitstream, int length)

{

  assert(length >= 0);

  bitstream_start = bitstream;

  bitstream_curr  = bitstream;

  bitstream_end   = bitstream+length;

}

void CABAC_decoder::init_CABAC()

{

  int length = bitstream_end - bitstream_curr;

  range = 510;

  bits_needed = 8;

  value = 0;

  if (length>0) { value  = (*bitstream_curr++) << 8;  bits_needed-=8; }

  if (length>1) { value |= (*bitstream_curr++);       bits_needed-=8; }

  logtrace(LogCABAC,"[%3d] init_CABAC_decode_2 r:%x v:%x\n", logcnt, range, value);

}

#if defined(__x86_64__) && defined(__GNUC__) && !defined(DE265_LOG_TRACE)

#define DE265_CABAC_ASM_X86_64 1

// Combined state-transition table (folds the MPS-flip at state 0), indexed by

// the packed context byte (state*2+MPSbit) for MPS and (packed ^ 0xFF) for LPS.

static const uint8_t cabac_transition[256] =

  {

      2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16, 17,

     18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33,

     34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49,

     50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65,

     66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81,

     82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97,

     98, 99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,

    114,115,116,117,118,119,120,121,122,123,124,125,124,125,126,127,

    127,126, 77, 76, 77, 76, 75, 74, 75, 74, 75, 74, 73, 72, 73, 72,

     73, 72, 71, 70, 71, 70, 71, 70, 69, 68, 69, 68, 67, 66, 67, 66,

     67, 66, 65, 64, 65, 64, 63, 62, 61, 60, 61, 60, 61, 60, 59, 58,

     59, 58, 57, 56, 55, 54, 55, 54, 53, 52, 53, 52, 51, 50, 49, 48,

     49, 48, 47, 46, 45, 44, 45, 44, 43, 42, 43, 42, 39, 38, 39, 38,

     37, 36, 37, 36, 33, 32, 33, 32, 31, 30, 31, 30, 27, 26, 27, 26,

     25, 24, 23, 22, 23, 22, 19, 18, 19, 18, 17, 16, 15, 14, 13, 12,

     11, 10,  9,  8,  9,  8,  5,  4,  5,  4,  3,  2,  1,  0,  0,  1,

  };

#endif

int  CABAC_decoder::decode_bit(context_model* model)

{

#ifdef DE265_CABAC_ASM_X86_64

  // x86-64 branchless arithmetic decoder. Bit-identical to the C fallback below.

  uint32_t range_l = range, value_l = value;

  int      bn_l    = bits_needed;

  uint8_t* curr_l = bitstream_curr;

  uint8_t* sp = reinterpret_cast<uint8_t*>(model);

  int bit_l;

  __asm__ (

    "movzbl (%[sp]), %%eax            \n\t" // eax = b (state*2 + MPS)

    "mov    %[range], %%ecx           \n\t"

    "shr    $6, %%ecx                 \n\t"

    "sub    $4, %%ecx                 \n\t" // ecx = (range>>6)-4

    "mov    %%eax, %%edx              \n\t"

    "shr    $1, %%edx                 \n\t" // edx = state

    "lea    (%%rcx,%%rdx,4), %%rcx    \n\t" // rcx = state*4 + ridx

    "lea    %[lps], %%rdx             \n\t" // rdx = &LPS_table[0][0]

    "movzbl (%%rdx,%%rcx,1), %%edx    \n\t" // edx = RangeLPS

    "sub    %%edx, %[range]           \n\t" // range = range - RangeLPS (MPS range)

    "mov    %[range], %%r8d           \n\t"

    "shl    $7, %%r8d                 \n\t" // r8d = scaled_range

    "mov    %[value], %%r9d           \n\t"

    "sub    %%r8d, %%r9d              \n\t"

    "sar    $31, %%r9d                \n\t" // r9d = mps_mask (-1 if MPS)

    "not    %%r9d                     \n\t" // r9d = lps_mask (-1 if LPS)

    "mov    %%r8d, %%ecx              \n\t"

    "and    %%r9d, %%ecx              \n\t"

    "sub    %%ecx, %[value]           \n\t" // value -= scaled & lps_mask

    "mov    %%edx, %%ecx              \n\t" // RangeLPS

    "sub    %[range], %%ecx           \n\t"

    "and    %%r9d, %%ecx              \n\t"

    "add    %%ecx, %[range]           \n\t" // range = RangeLPS if LPS, else unchanged

    "and    $0xFF, %%r9d              \n\t"

    "xor    %%r9d, %%eax              \n\t" // eax = idx

    "mov    %%eax, %[bit]             \n\t"

    "and    $1, %[bit]                \n\t" // bit = idx & 1

    "lea    %[trans], %%rcx           \n\t" // rcx = &cabac_transition[0]

    "movzbl (%%rcx,%%rax,1), %%edx    \n\t"

    "mov    %%dl, (%[sp])             \n\t" // *sp = cabac_transition[idx]

    "bsr    %[range], %%ecx           \n\t" // ecx = MSB index

    "mov    $8, %%edx                 \n\t"

    "sub    %%ecx, %%edx              \n\t" // edx = renorm shift = 8 - bsr

    "mov    %%edx, %%ecx              \n\t"

    "shl    %%cl, %[value]            \n\t"

    "shl    %%cl, %[range]            \n\t"

    "add    %%edx, %[bn]              \n\t" // bits_needed += shift

    "test   %[bn], %[bn]              \n\t"

    "js     1f                        \n\t" // bits_needed < 0: no refill

    "cmp    %[end], %[curr]           \n\t"

    "jae    2f                        \n\t" // curr >= end: no read

    "movzbl (%[curr]), %%eax          \n\t"

    "mov    %[bn], %%ecx              \n\t"

    "shl    %%cl, %%eax              \n\t"

    "or     %%eax, %[value]           \n\t" // value |= (*curr) << bits_needed

    "inc    %[curr]                   \n\t"

    "2:                               \n\t"

    "sub    $8, %[bn]                 \n\t"

    "1:                               \n\t"

    : [range]"+r"(range_l), [value]"+r"(value_l), [bn]"+r"(bn_l),

      [curr]"+r"(curr_l), [bit]"=&r"(bit_l)

    : [sp]"r"(sp), [end]"r"(bitstream_end),

      [lps]"m"(LPS_table[0][0]), [trans]"m"(cabac_transition[0])

    : "rax","rcx","rdx","r8","r9","cc","memory"

  );

  range = range_l; value = value_l; bits_needed = (int16_t)bn_l; bitstream_curr = curr_l;

  return bit_l;

#else

  logtrace(LogCABAC,"[%3d] decodeBin r:%x v:%x state:%d\n",logcnt,range, value, model->state);

  int decoded_bit;

  int LPS = LPS_table[model->state][ ( range >> 6 ) - 4 ];

  range -= LPS;

  uint32_t scaled_range = range << 7;

  logtrace(LogCABAC,"[%3d] sr:%x v:%x\n",logcnt,scaled_range, value);

  if (value < scaled_range)

    {

      logtrace(LogCABAC,"[%3d] MPS\n",logcnt);

      // MPS path

      decoded_bit = model->MPSbit;

      model->state = next_state_MPS[model->state];

      if (scaled_range < ( 256 << 7 ) )

        {

          // scaled range, highest bit (15) not set

          range = scaled_range >> 6; // shift range by one bit

          value <<= 1;               // shift value by one bit

          bits_needed++;

          if (bits_needed == 0)

            {

              bits_needed = -8;

              if (bitstream_curr < bitstream_end)

                { value |= *bitstream_curr++; }

            }

        }

    }

  else

    {

      logtrace(LogCABAC,"[%3d] LPS\n",logcnt);

      //printf("%d %d\n", model->state, 0);

      // LPS path

      value = (value - scaled_range);

      uint8_t num_bits = renorm_table[ LPS >> 3 ];

      value <<= num_bits;

      range   = LPS << num_bits;  /* this is always >= 0x100 except for state 63,

                                              but state 63 is never used */

#ifndef NDEBUG

      int num_bitsTab = renorm_table[ LPS >> 3 ];

      assert(num_bits == num_bitsTab);

#endif

      decoded_bit      = 1 - model->MPSbit;

      if (model->state==0) { model->MPSbit = 1-model->MPSbit; }

      model->state = next_state_LPS[model->state];

      bits_needed += num_bits;

      if (bits_needed >= 0)

        {

          logtrace(LogCABAC,"bits_needed: %d\n", bits_needed);

          if (bitstream_curr < bitstream_end)

            { value |= (*bitstream_curr++) << bits_needed; }

          bits_needed -= 8;

        }

    }

  logtrace(LogCABAC,"[%3d] -> bit %d  r:%x v:%x\n", logcnt, decoded_bit, range, value);

#ifdef DE265_LOG_TRACE

  logcnt++;

#endif

  return decoded_bit;

#endif

}

int  CABAC_decoder::decode_term_bit()

{

  logtrace(LogCABAC,"CABAC term: range=%x\n", range);

  range -= 2;

  uint32_t scaledRange = range << 7;

  if (value >= scaledRange)

    {

      return 1;

    }

  else

    {

      // there is a while loop in the standard, but it will always be executed only once

      if (scaledRange < (256<<7))

        {

          range = scaledRange >> 6;

          value *= 2;

          bits_needed++;

          if (bits_needed==0)

            {

              bits_needed = -8;

              if (bitstream_curr < bitstream_end) {

                value += (*bitstream_curr++);

              }

            }

        }

      return 0;

    }

}

// When we read past the end of the bitstream (which should only happen on faulty bitstreams),

// we will eventually only return zeros.

int  CABAC_decoder::decode_bypass()

{

#ifdef DE265_CABAC_ASM_X86_64

  uint32_t value_l = value;

  int      bn_l    = bits_needed;

  uint8_t* curr_l  = bitstream_curr;

  int bit_l;

  __asm__ (

    "add    %[value], %[value]        \n\t" // value <<= 1

    "addl   $1, %[bn]                 \n\t" // bits_needed++

    "js     1f                        \n\t" // bits_needed < 0: no refill

    "cmp    %[end], %[curr]           \n\t"

    "jae    2f                        \n\t" // curr >= end: no read

    "movzbl (%[curr]), %%eax          \n\t"

    "or     %%eax, %[value]           \n\t" // value |= *curr (bits_needed==0)

    "inc    %[curr]                   \n\t"

    "2:                               \n\t"

    "movl   $-8, %[bn]                \n\t" // bits_needed = -8

    "1:                               \n\t"

    "mov    %[range], %%ecx           \n\t"

    "shl    $7, %%ecx                 \n\t" // ecx = scaled_range

    "mov    %[value], %%edx           \n\t"

    "sub    %%ecx, %%edx              \n\t" // edx = value - scaled_range

    "mov    %%edx, %%eax              \n\t"

    "sar    $31, %%eax               \n\t"  // eax = mask (-1 if value<scaled -> bit 0)

    "mov    %%eax, %[bit]             \n\t"

    "add    $1, %[bit]                \n\t" // bit = mask + 1

    "not    %%eax                     \n\t" // eax = ~mask

    "and    %%eax, %%ecx              \n\t" // ecx = scaled & ~mask

    "sub    %%ecx, %[value]           \n\t" // value -= scaled when bit==1

    : [value]"+r"(value_l), [bn]"+r"(bn_l), [curr]"+r"(curr_l), [bit]"=&r"(bit_l)

    : [range]"r"(range), [end]"r"(bitstream_end)

    : "rax","rcx","rdx","cc","memory"

  );

  value = value_l; bits_needed = (int16_t)bn_l; bitstream_curr = curr_l;

  return bit_l;

#else

  logtrace(LogCABAC,"[%3d] bypass r:%x v:%x\n",logcnt,range, value);

  value <<= 1;

  bits_needed++;

  if (bits_needed >= 0)

    {

      if (bitstream_end > bitstream_curr) {

        bits_needed = -8;

        value |= *bitstream_curr++;

      }

      else {

        // we read past the end of the bitstream, fill with 0

        bits_needed = -8;

      }

    }

  int bit;

  uint32_t scaled_range = range << 7;

  if (value >= scaled_range)

    {

      value -= scaled_range;

      bit=1;

    }

  else

    {

      bit=0;

    }

  logtrace(LogCABAC,"[%3d] -> bit %d  r:%x v:%x\n", logcnt, bit, range, value);

#ifdef DE265_LOG_TRACE

  logcnt++;

#endif

  return bit;

#endif

}

int  CABAC_decoder::decode_TU_bypass(int cMax)

{

  for (int i=0;i<cMax;i++)

    {

      int bit = decode_bypass();

      if (bit==0)

        return i;

    }

  return cMax;

}

int  CABAC_decoder::decode_TU(int cMax, context_model* model)

{

  for (int i=0;i<cMax;i++)

    {

      int bit = decode_bit(model);

      if (bit==0)

        return i;

    }

  return cMax;

}

int  CABAC_decoder::decode_FL_bypass_parallel(int nBits)

{

  logtrace(LogCABAC,"[%3d] bypass group r:%x v:%x (nBits=%d)\n",logcnt,

           range, value, nBits);

  value <<= nBits;

  bits_needed+=nBits;

  if (bits_needed >= 0)

    {

      if (bitstream_end > bitstream_curr) {

        int input = *bitstream_curr++;

        input <<= bits_needed;

        bits_needed -= 8;

        value |= input;

      }

    }

  uint32_t scaled_range = range << 7;

  int v = value / scaled_range;

  if (unlikely(v>=(1<<nBits))) { v=(1<<nBits)-1; } // may happen with broken bitstreams

  value -= v * scaled_range;

  logtrace(LogCABAC,"[%3d] -> value %d  r:%x v:%x\n", logcnt+nBits-1,

           v, range, value);

#ifdef DE265_LOG_TRACE

  logcnt+=nBits;

#endif

  return v;

}

uint32_t  CABAC_decoder::decode_FL_bypass(int nBits)

{

  uint32_t v=0;

  if (likely(nBits<=8)) {

    if (nBits==0) {

      return 0;

    }

    // we could use decode_bypass() for a single bit, but this seems to be slower

#if 0

    else if (nBits==1) {

      v = decode_bypass();

    }

#endif

    else {

      v = decode_FL_bypass_parallel(nBits);

    }

  }

  else {

    v = decode_FL_bypass_parallel(8);

    nBits-=8;

    while (nBits--) {

      v <<= 1;

      v |= decode_bypass();

    }

  }

  logtrace(LogCABAC,"      -> FL: %d\n", v);

  return v;

}

int  CABAC_decoder::decode_TR_bypass(int cRiceParam, int cTRMax)

{

  int prefix = decode_TU_bypass(cTRMax>>cRiceParam);

  if (prefix==4) { // TODO check: constant 4 only works for coefficient decoding

    return cTRMax;

  }

  int suffix = decode_FL_bypass(cRiceParam);

  return (prefix << cRiceParam) | suffix;

}

uint32_t  CABAC_decoder::decode_EGk_bypass(int k)

{

  uint32_t base=0;

  int n=k;

  for (;;)

    {

      int bit = decode_bypass();

      if (bit==0)

        break;

      else {

        if (n >= 31) {

          return 0; // TODO: error

        }

        base += 1u<<n;

        n++;

      }

    }

  uint32_t suffix = decode_FL_bypass(n);

  return base + suffix;

}

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

void CABAC_encoder::add_trailing_bits()

{

  write_bit(1);

  int nZeros = number_free_bits_in_byte();

  write_bits(0, nZeros);

}

CABAC_encoder_bitstream::CABAC_encoder_bitstream()

{

  init_CABAC();

}

CABAC_encoder_bitstream::~CABAC_encoder_bitstream()

{

  free(data_mem);

}

void CABAC_encoder_bitstream::reset()

{

  data_size = 0;

  state = 0;

  vlc_buffer_len = 0;

  init_CABAC();

}

void CABAC_encoder_bitstream::write_bits(uint32_t bits,int n)

{

  vlc_buffer <<= n;

  vlc_buffer |= bits;

  vlc_buffer_len += n;

  // TODO: errors returned by append_byte() are ignored, resulting in a broken output.

  while (vlc_buffer_len>=8) {

    append_byte((vlc_buffer >> (vlc_buffer_len-8)) & 0xFF);

    vlc_buffer_len -= 8;

  }

}

void CABAC_encoder::write_uvlc(int value)

{

  assert(value>=0);

  int nLeadingZeros=0;

  int base=0;

  int range=1;

  while (value>=base+range) {

    base += range;

    range <<= 1;

    nLeadingZeros++;

  }

  write_bits((1<<nLeadingZeros) | (value-base),2*nLeadingZeros+1);

}

void CABAC_encoder::write_svlc(int value)

{

  if      (value==0) write_bits(1,1);

  else if (value>0)  write_uvlc(2*value-1);

  else               write_uvlc(-2*value);

}

void CABAC_encoder_bitstream::flush_VLC()

{

  // TODO: errors returned by append_byte() are ignored, resulting in a broken output.

  while (vlc_buffer_len>=8) {

    append_byte((vlc_buffer >> (vlc_buffer_len-8)) & 0xFF);

    vlc_buffer_len -= 8;

  }

  if (vlc_buffer_len>0) {

    append_byte(vlc_buffer << (8-vlc_buffer_len));

    vlc_buffer_len = 0;

  }

  vlc_buffer = 0;

}

void CABAC_encoder_bitstream::skip_bits(int nBits)

{

  while (nBits>=8) {

    write_bits(0,8);

    nBits-=8;

  }

  if (nBits>0) {

    write_bits(0,nBits);

  }

}

int  CABAC_encoder_bitstream::number_free_bits_in_byte() const

{

  if ((vlc_buffer_len % 8)==0) return 0;

  return 8- (vlc_buffer_len % 8);

}

bool CABAC_encoder_bitstream::check_size_and_resize(int nBytes)

{

  if (data_size+nBytes > data_capacity) { // 1 extra byte for stuffing

    if (data_capacity==0) {

      data_capacity = INITIAL_CABAC_BUFFER_CAPACITY;

    } else {

      data_capacity *= 2;

    }

    uint8_t* new_data_mem = (uint8_t*)realloc(data_mem,data_capacity);

    if (new_data_mem) {

      data_mem = new_data_mem;

    }

    else {

      return false;

    }

  }

  return true;

}

bool CABAC_encoder_bitstream::append_byte(int byte)

{

  if (!check_size_and_resize(2)) {

    return false;

  }

  // --- emulation prevention ---

  /* These byte sequences may never occur in the bitstream:

     0x000000 / 0x000001 / 0x000002

     Hence, we have to add a 0x03 before the third byte.

     We also have to add a 0x03 for this sequence: 0x000003, because

     the escape byte itself also has to be escaped.

  */

  // S0 --(0)--> S1 --(0)--> S2 --(0,1,2,3)--> add stuffing

  if (byte<=3) {

    /**/ if (state< 2 && byte==0) { state++; }

    else if (state==2 && byte<=3) {

      data_mem[ data_size++ ] = 3;

      if (byte==0) state=1;

      else         state=0;

    }

    else { state=0; }

  }

  else { state=0; }

  // write actual data byte

  data_mem[ data_size++ ] = byte;

  return true;

}

bool CABAC_encoder_bitstream::write_startcode()

{

  if (!check_size_and_resize(3)) {

    return false;

  }

  data_mem[ data_size+0 ] = 0;

  data_mem[ data_size+1 ] = 0;

  data_mem[ data_size+2 ] = 1;

  data_size+=3;

  return true;

}

void CABAC_encoder_bitstream::init_CABAC()

{

  range = 510;

  low = 0;

  bits_left = 23;

  buffered_byte = 0xFF;

  num_buffered_bytes = 0;

}

void CABAC_encoder_bitstream::flush_CABAC()

{

  // TODO: errors returned by append_byte() are ignored, resulting in a broken output.

  if (low >> (32 - bits_left))

    {

      append_byte(buffered_byte + 1);

      while (num_buffered_bytes > 1)

        {

          append_byte(0x00);

          num_buffered_bytes--;

        }

      low -= 1 << (32 - bits_left);

    }

  else

    {

      if (num_buffered_bytes > 0)

        {

          append_byte(buffered_byte);

        }

      while (num_buffered_bytes > 1)

        {

          append_byte(0xff);

          num_buffered_bytes--;

        }

    }

  // printf("low: %08x  nbits left:%d  filled:%d\n",low,bits_left,32-bits_left);

  write_bits(low >> 8, 24-bits_left);

}

void CABAC_encoder_bitstream::write_out()

{

  // TODO: errors returned by append_byte() are ignored, resulting in a broken output.

  //logtrace(LogCABAC,"low = %08x (bits_left=%d)\n",low,bits_left);

  int leadByte = low >> (24 - bits_left);

  bits_left += 8;

  low &= 0xffffffffu >> bits_left;

  //logtrace(LogCABAC,"write byte %02x\n",leadByte);

  //logtrace(LogCABAC,"-> low = %08x\n",low);

  if (leadByte == 0xff)

    {

      num_buffered_bytes++;

    }

  else

    {

      if (num_buffered_bytes > 0)

        {

          int carry = leadByte >> 8;

          int byte = buffered_byte + carry;

          buffered_byte = leadByte & 0xff;

          append_byte(byte);

          byte = ( 0xff + carry ) & 0xff;

          while ( num_buffered_bytes > 1 )

            {

              append_byte(byte);

              num_buffered_bytes--;

            }

        }

      else

        {

          num_buffered_bytes = 1;

          buffered_byte = leadByte;

        }

    }

}

void CABAC_encoder_bitstream::testAndWriteOut()

{

  // logtrace(LogCABAC,"bits_left = %d\n",bits_left);

  if (bits_left < 12)

    {

      write_out();

    }

}

#ifdef DE265_LOG_TRACE

int encBinCnt=1;

#endif

void CABAC_encoder_bitstream::write_CABAC_bit(int modelIdx, int bin)

{

  context_model* model = &(*mCtxModels)[modelIdx];

  //m_uiBinsCoded += m_binCountIncrement;

  //rcCtxModel.setBinsCoded( 1 );

  logtrace(LogCABAC,"[%d] range=%x low=%x state=%d, bin=%d\n",

           encBinCnt, range,low, model->state,bin);

  /*

  printf("[%d] range=%x low=%x state=%d, bin=%d\n",

         encBinCnt, range,low, model->state,bin);

  printf("%d %d X\n",model->state,bin != model->MPSbit);

  */

#ifdef DE265_LOG_TRACE

  encBinCnt++;

#endif

  uint32_t LPS = LPS_table[model->state][ ( range >> 6 ) - 4 ];

  range -= LPS;

  if (bin != model->MPSbit)

    {

      //logtrace(LogCABAC,"LPS\n");

      int num_bits = renorm_table[ LPS >> 3 ];

      low = (low + range) << num_bits;

      range   = LPS << num_bits;

      if (model->state==0) { model->MPSbit = 1-model->MPSbit; }

      model->state = next_state_LPS[model->state];

      bits_left -= num_bits;

    }

  else

    {

      //logtrace(LogCABAC,"MPS\n");

      model->state = next_state_MPS[model->state];

      // renorm

      if (range >= 256) { return; }

      low <<= 1;

      range <<= 1;

      bits_left--;

    }

  testAndWriteOut();

}

void CABAC_encoder_bitstream::write_CABAC_bypass(int bin)

{

  logtrace(LogCABAC,"[%d] bypass = %d, range=%x\n",encBinCnt,bin,range);

  /*

  printf("[%d] bypass = %d, range=%x\n",encBinCnt,bin,range);

  printf("%d %d X\n",64, -1);

  */

#ifdef DE265_LOG_TRACE

  encBinCnt++;

#endif

  // BinsCoded += m_binCountIncrement;

  low <<= 1;

  if (bin)

    {

      low += range;

    }

  bits_left--;

  testAndWriteOut();

}

void CABAC_encoder::write_CABAC_TU_bypass(int value, int cMax)

{

  for (int i=0;i<value;i++) {

    write_CABAC_bypass(1);

  }

  if (value<cMax) {

    write_CABAC_bypass(0);

  }

}

void CABAC_encoder::write_CABAC_FL_bypass(int value, int n)

{

  while (n>0) {

    n--;

    write_CABAC_bypass(value & (1<<n));

  }

}

void CABAC_encoder_bitstream::write_CABAC_term_bit(int bit)

{

  logtrace(LogCABAC,"CABAC term: range=%x\n", range);