text: /*
   * HEVC CABAC decoding
   *
   * Copyright (C) 2012 - 2013 Guillaume Martres
   * Copyright (C) 2012 - 2013 Gildas Cocherel
   *
   * This file is part of FFmpeg.
   *
   * FFmpeg 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 2.1 of the License, or (at your option) any later version.
   *
   * FFmpeg 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 FFmpeg; if not, write to the Free Software
   * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
   */
  
  #include "libavutil/attributes.h"
  #include "libavutil/common.h"
  
  #include "cabac_functions.h"
  #include "hevc.h"
  
  #define CABAC_MAX_BIN 31
  
  /**
   * number of bin by SyntaxElement.
   */
  av_unused static const int8_t num_bins_in_se[] = {
       1, // sao_merge_flag
       1, // sao_type_idx
       0, // sao_eo_class
       0, // sao_band_position
       0, // sao_offset_abs
       0, // sao_offset_sign
       0, // end_of_slice_flag
       3, // split_coding_unit_flag
       1, // cu_transquant_bypass_flag
       3, // skip_flag
       3, // cu_qp_delta
       1, // pred_mode
       4, // part_mode
       0, // pcm_flag
       1, // prev_intra_luma_pred_mode
       0, // mpm_idx
       0, // rem_intra_luma_pred_mode
       2, // intra_chroma_pred_mode
       1, // merge_flag
       1, // merge_idx
       5, // inter_pred_idc
       2, // ref_idx_l0
       2, // ref_idx_l1
       2, // abs_mvd_greater0_flag
       2, // abs_mvd_greater1_flag
       0, // abs_mvd_minus2
       0, // mvd_sign_flag
       1, // mvp_lx_flag
       1, // no_residual_data_flag
       3, // split_transform_flag
       2, // cbf_luma
       4, // cbf_cb, cbf_cr
       2, // transform_skip_flag[][]
       2, // explicit_rdpcm_flag[][]
       2, // explicit_rdpcm_dir_flag[][]
      18, // last_significant_coeff_x_prefix
      18, // last_significant_coeff_y_prefix
       0, // last_significant_coeff_x_suffix
       0, // last_significant_coeff_y_suffix
       4, // significant_coeff_group_flag
      44, // significant_coeff_flag
      24, // coeff_abs_level_greater1_flag
       6, // coeff_abs_level_greater2_flag
       0, // coeff_abs_level_remaining
       0, // coeff_sign_flag
       8, // log2_res_scale_abs
       2, // res_scale_sign_flag
       1, // cu_chroma_qp_offset_flag
       1, // cu_chroma_qp_offset_idx
  };
  
  /**
   * Offset to ctxIdx 0 in init_values and states, indexed by SyntaxElement.
   */
  static const int elem_offset[sizeof(num_bins_in_se)] = {
      0, // sao_merge_flag
      1, // sao_type_idx
      2, // sao_eo_class
      2, // sao_band_position
      2, // sao_offset_abs
      2, // sao_offset_sign
      2, // end_of_slice_flag
      2, // split_coding_unit_flag
      5, // cu_transquant_bypass_flag
      6, // skip_flag
      9, // cu_qp_delta
      12, // pred_mode
      13, // part_mode
      17, // pcm_flag
      17, // prev_intra_luma_pred_mode
      18, // mpm_idx
      18, // rem_intra_luma_pred_mode
      18, // intra_chroma_pred_mode
      20, // merge_flag
      21, // merge_idx
      22, // inter_pred_idc
      27, // ref_idx_l0
      29, // ref_idx_l1
      31, // abs_mvd_greater0_flag
      33, // abs_mvd_greater1_flag
      35, // abs_mvd_minus2
      35, // mvd_sign_flag
      35, // mvp_lx_flag
      36, // no_residual_data_flag
      37, // split_transform_flag
      40, // cbf_luma
      42, // cbf_cb, cbf_cr
      46, // transform_skip_flag[][]
      48, // explicit_rdpcm_flag[][]
      50, // explicit_rdpcm_dir_flag[][]
      52, // last_significant_coeff_x_prefix
      70, // last_significant_coeff_y_prefix
      88, // last_significant_coeff_x_suffix
      88, // last_significant_coeff_y_suffix
      88, // significant_coeff_group_flag
      92, // significant_coeff_flag
      136, // coeff_abs_level_greater1_flag
      160, // coeff_abs_level_greater2_flag
      166, // coeff_abs_level_remaining
      166, // coeff_sign_flag
      166, // log2_res_scale_abs
      174, // res_scale_sign_flag
      176, // cu_chroma_qp_offset_flag
      177, // cu_chroma_qp_offset_idx
  };
  
  #define CNU 154
  /**
   * Indexed by init_type
   */
  static const uint8_t init_values[3][HEVC_CONTEXTS] = {
      { // sao_merge_flag
        153,
        // sao_type_idx
        200,
        // split_coding_unit_flag
        139, 141, 157,
        // cu_transquant_bypass_flag
        154,
        // skip_flag
        CNU, CNU, CNU,
        // cu_qp_delta
        154, 154, 154,
        // pred_mode
        CNU,
        // part_mode
        184, CNU, CNU, CNU,
        // prev_intra_luma_pred_mode
        184,
        // intra_chroma_pred_mode
        63, 139,
        // merge_flag
        CNU,
        // merge_idx
        CNU,
        // inter_pred_idc
        CNU, CNU, CNU, CNU, CNU,
        // ref_idx_l0
        CNU, CNU,
        // ref_idx_l1
        CNU, CNU,
        // abs_mvd_greater1_flag
        CNU, CNU,
        // abs_mvd_greater1_flag
        CNU, CNU,
        // mvp_lx_flag
        CNU,
        // no_residual_data_flag
        CNU,
        // split_transform_flag
        153, 138, 138,
        // cbf_luma
        111, 141,
        // cbf_cb, cbf_cr
        94, 138, 182, 154,
        // transform_skip_flag
        139, 139,
        // explicit_rdpcm_flag
        139, 139,
        // explicit_rdpcm_dir_flag
        139, 139,
        // last_significant_coeff_x_prefix
        110, 110, 124, 125, 140, 153, 125, 127, 140, 109, 111, 143, 127, 111,
         79, 108, 123,  63,
        // last_significant_coeff_y_prefix
        110, 110, 124, 125, 140, 153, 125, 127, 140, 109, 111, 143, 127, 111,
         79, 108, 123,  63,
        // significant_coeff_group_flag
        91, 171, 134, 141,
        // significant_coeff_flag
        111, 111, 125, 110, 110,  94, 124, 108, 124, 107, 125, 141, 179, 153,
        125, 107, 125, 141, 179, 153, 125, 107, 125, 141, 179, 153, 125, 140,
        139, 182, 182, 152, 136, 152, 136, 153, 136, 139, 111, 136, 139, 111,
        141, 111,
        // coeff_abs_level_greater1_flag
        140,  92, 137, 138, 140, 152, 138, 139, 153,  74, 149,  92, 139, 107,
        122, 152, 140, 179, 166, 182, 140, 227, 122, 197,
        // coeff_abs_level_greater2_flag
        138, 153, 136, 167, 152, 152,
        // log2_res_scale_abs
        154, 154, 154, 154, 154, 154, 154, 154,
        // res_scale_sign_flag
        154, 154,
        // cu_chroma_qp_offset_flag
        154,
        // cu_chroma_qp_offset_idx
        154,
      },
      { // sao_merge_flag
        153,
        // sao_type_idx
        185,
        // split_coding_unit_flag
        107, 139, 126,
        // cu_transquant_bypass_flag
        154,
        // skip_flag
        197, 185, 201,
        // cu_qp_delta
        154, 154, 154,
        // pred_mode
        149,
        // part_mode
        154, 139, 154, 154,
        // prev_intra_luma_pred_mode
        154,
        // intra_chroma_pred_mode
        152, 139,
        // merge_flag
        110,
        // merge_idx
        122,
        // inter_pred_idc
        95, 79, 63, 31, 31,
        // ref_idx_l0
        153, 153,
        // ref_idx_l1
        153, 153,
        // abs_mvd_greater1_flag
        140, 198,
        // abs_mvd_greater1_flag
        140, 198,
        // mvp_lx_flag
        168,
        // no_residual_data_flag
        79,
        // split_transform_flag
        124, 138, 94,
        // cbf_luma
        153, 111,
        // cbf_cb, cbf_cr
        149, 107, 167, 154,
        // transform_skip_flag
        139, 139,
        // explicit_rdpcm_flag
        139, 139,
        // explicit_rdpcm_dir_flag
        139, 139,
        // last_significant_coeff_x_prefix
        125, 110,  94, 110,  95,  79, 125, 111, 110,  78, 110, 111, 111,  95,
         94, 108, 123, 108,
        // last_significant_coeff_y_prefix
        125, 110,  94, 110,  95,  79, 125, 111, 110,  78, 110, 111, 111,  95,
         94, 108, 123, 108,
        // significant_coeff_group_flag
        121, 140, 61, 154,
        // significant_coeff_flag
        155, 154, 139, 153, 139, 123, 123,  63, 153, 166, 183, 140, 136, 153,
        154, 166, 183, 140, 136, 153, 154, 166, 183, 140, 136, 153, 154, 170,
        153, 123, 123, 107, 121, 107, 121, 167, 151, 183, 140, 151, 183, 140,
        140, 140,
        // coeff_abs_level_greater1_flag
        154, 196, 196, 167, 154, 152, 167, 182, 182, 134, 149, 136, 153, 121,
        136, 137, 169, 194, 166, 167, 154, 167, 137, 182,
        // coeff_abs_level_greater2_flag
        107, 167, 91, 122, 107, 167,
        // log2_res_scale_abs
        154, 154, 154, 154, 154, 154, 154, 154,
        // res_scale_sign_flag
        154, 154,
        // cu_chroma_qp_offset_flag
        154,
        // cu_chroma_qp_offset_idx
        154,
      },
      { // sao_merge_flag
        153,
        // sao_type_idx
        160,
        // split_coding_unit_flag
        107, 139, 126,
        // cu_transquant_bypass_flag
        154,
        // skip_flag
        197, 185, 201,
        // cu_qp_delta
        154, 154, 154,
        // pred_mode
        134,
        // part_mode
        154, 139, 154, 154,
        // prev_intra_luma_pred_mode
        183,
        // intra_chroma_pred_mode
        152, 139,
        // merge_flag
        154,
        // merge_idx
        137,
        // inter_pred_idc
        95, 79, 63, 31, 31,
        // ref_idx_l0
        153, 153,
        // ref_idx_l1
        153, 153,
        // abs_mvd_greater1_flag
        169, 198,
        // abs_mvd_greater1_flag
        169, 198,
        // mvp_lx_flag
        168,
        // no_residual_data_flag
        79,
        // split_transform_flag
        224, 167, 122,
        // cbf_luma
        153, 111,
        // cbf_cb, cbf_cr
        149, 92, 167, 154,
        // transform_skip_flag
        139, 139,
        // explicit_rdpcm_flag
        139, 139,
        // explicit_rdpcm_dir_flag
        139, 139,
        // last_significant_coeff_x_prefix
        125, 110, 124, 110,  95,  94, 125, 111, 111,  79, 125, 126, 111, 111,
         79, 108, 123,  93,
        // last_significant_coeff_y_prefix
        125, 110, 124, 110,  95,  94, 125, 111, 111,  79, 125, 126, 111, 111,
         79, 108, 123,  93,
        // significant_coeff_group_flag
        121, 140, 61, 154,
        // significant_coeff_flag
        170, 154, 139, 153, 139, 123, 123,  63, 124, 166, 183, 140, 136, 153,
        154, 166, 183, 140, 136, 153, 154, 166, 183, 140, 136, 153, 154, 170,
        153, 138, 138, 122, 121, 122, 121, 167, 151, 183, 140, 151, 183, 140,
        140, 140,
        // coeff_abs_level_greater1_flag
        154, 196, 167, 167, 154, 152, 167, 182, 182, 134, 149, 136, 153, 121,
        136, 122, 169, 208, 166, 167, 154, 152, 167, 182,
        // coeff_abs_level_greater2_flag
        107, 167, 91, 107, 107, 167,
        // log2_res_scale_abs
        154, 154, 154, 154, 154, 154, 154, 154,
        // res_scale_sign_flag
        154, 154,
        // cu_chroma_qp_offset_flag
        154,
        // cu_chroma_qp_offset_idx
        154,
      },
  };
  
  static const uint8_t scan_1x1[1] = {
      0,
  };
  
  static const uint8_t horiz_scan2x2_x[4] = {
      0, 1, 0, 1,
  };
  
  static const uint8_t horiz_scan2x2_y[4] = {
      0, 0, 1, 1
  };
  
  static const uint8_t horiz_scan4x4_x[16] = {
      0, 1, 2, 3,
      0, 1, 2, 3,
      0, 1, 2, 3,
      0, 1, 2, 3,
  };
  
  static const uint8_t horiz_scan4x4_y[16] = {
      0, 0, 0, 0,
      1, 1, 1, 1,
      2, 2, 2, 2,
      3, 3, 3, 3,
  };
  
  static const uint8_t horiz_scan8x8_inv[8][8] = {
      {  0,  1,  2,  3, 16, 17, 18, 19, },
      {  4,  5,  6,  7, 20, 21, 22, 23, },
      {  8,  9, 10, 11, 24, 25, 26, 27, },
      { 12, 13, 14, 15, 28, 29, 30, 31, },
      { 32, 33, 34, 35, 48, 49, 50, 51, },
      { 36, 37, 38, 39, 52, 53, 54, 55, },
      { 40, 41, 42, 43, 56, 57, 58, 59, },
      { 44, 45, 46, 47, 60, 61, 62, 63, },
  };
  
  static const uint8_t diag_scan2x2_x[4] = {
      0, 0, 1, 1,
  };
  
  static const uint8_t diag_scan2x2_y[4] = {
      0, 1, 0, 1,
  };
  
  static const uint8_t diag_scan2x2_inv[2][2] = {
      { 0, 2, },
      { 1, 3, },
  };
  
  static const uint8_t diag_scan4x4_inv[4][4] = {
      { 0,  2,  5,  9, },
      { 1,  4,  8, 12, },
      { 3,  7, 11, 14, },
      { 6, 10, 13, 15, },
  };
  
  static const uint8_t diag_scan8x8_inv[8][8] = {
      {  0,  2,  5,  9, 14, 20, 27, 35, },
      {  1,  4,  8, 13, 19, 26, 34, 42, },
      {  3,  7, 12, 18, 25, 33, 41, 48, },
      {  6, 11, 17, 24, 32, 40, 47, 53, },
      { 10, 16, 23, 31, 39, 46, 52, 57, },
      { 15, 22, 30, 38, 45, 51, 56, 60, },
      { 21, 29, 37, 44, 50, 55, 59, 62, },
      { 28, 36, 43, 49, 54, 58, 61, 63, },
  };
  
  void ff_hevc_save_states(HEVCContext *s, int ctb_addr_ts)
  {
      if (s->ps.pps->entropy_coding_sync_enabled_flag &&
          (ctb_addr_ts % s->ps.sps->ctb_width == 2 ||
           (s->ps.sps->ctb_width == 2 &&
            ctb_addr_ts % s->ps.sps->ctb_width == 0))) {
          memcpy(s->cabac_state, s->HEVClc->cabac_state, HEVC_CONTEXTS);
      }
  }
  
  static void load_states(HEVCContext *s)
  {
      memcpy(s->HEVClc->cabac_state, s->cabac_state, HEVC_CONTEXTS);
  }
  
  static void cabac_reinit(HEVCLocalContext *lc)
  {
      skip_bytes(&lc->cc, 0);
  }
  
  static void cabac_init_decoder(HEVCContext *s)
  {
      GetBitContext *gb = &s->HEVClc->gb;
      skip_bits(gb, 1);
      align_get_bits(gb);
      ff_init_cabac_decoder(&s->HEVClc->cc,
                            gb->buffer + get_bits_count(gb) / 8,
                            (get_bits_left(gb) + 7) / 8);
  }
  
  static void cabac_init_state(HEVCContext *s)
  {
      int init_type = 2 - s->sh.slice_type;
      int i;
  
      if (s->sh.cabac_init_flag && s->sh.slice_type != I_SLICE)
          init_type ^= 3;
  
      for (i = 0; i < HEVC_CONTEXTS; i++) {
          int init_value = init_values[init_type][i];
          int m = (init_value >> 4) * 5 - 45;
          int n = ((init_value & 15) << 3) - 16;
          int pre = 2 * (((m * av_clip(s->sh.slice_qp, 0, 51)) >> 4) + n) - 127;
  
          pre ^= pre >> 31;
          if (pre > 124)
              pre = 124 + (pre & 1);
          s->HEVClc->cabac_state[i] = pre;
      }
  
      for (i = 0; i < 4; i++)
          s->HEVClc->stat_coeff[i] = 0;
  }
  
  void ff_hevc_cabac_init(HEVCContext *s, int ctb_addr_ts)
  {
      if (ctb_addr_ts == s->ps.pps->ctb_addr_rs_to_ts[s->sh.slice_ctb_addr_rs]) {
          cabac_init_decoder(s);
          if (s->sh.dependent_slice_segment_flag == 0 ||
              (s->ps.pps->tiles_enabled_flag &&
               s->ps.pps->tile_id[ctb_addr_ts] != s->ps.pps->tile_id[ctb_addr_ts - 1]))
              cabac_init_state(s);
  
          if (!s->sh.first_slice_in_pic_flag &&
              s->ps.pps->entropy_coding_sync_enabled_flag) {
              if (ctb_addr_ts % s->ps.sps->ctb_width == 0) {
                  if (s->ps.sps->ctb_width == 1)
                      cabac_init_state(s);
                  else if (s->sh.dependent_slice_segment_flag == 1)
                      load_states(s);
              }
          }
      } else {
          if (s->ps.pps->tiles_enabled_flag &&
              s->ps.pps->tile_id[ctb_addr_ts] != s->ps.pps->tile_id[ctb_addr_ts - 1]) {
              if (s->threads_number == 1)
                  cabac_reinit(s->HEVClc);
              else
                  cabac_init_decoder(s);
              cabac_init_state(s);
          }
          if (s->ps.pps->entropy_coding_sync_enabled_flag) {
              if (ctb_addr_ts % s->ps.sps->ctb_width == 0) {
                  get_cabac_terminate(&s->HEVClc->cc);
                  if (s->threads_number == 1)
                      cabac_reinit(s->HEVClc);
                  else
                      cabac_init_decoder(s);
  
                  if (s->ps.sps->ctb_width == 1)
                      cabac_init_state(s);
                  else
                      load_states(s);
              }
          }
      }
  }
  
  #define GET_CABAC(ctx) get_cabac(&s->HEVClc->cc, &s->HEVClc->cabac_state[ctx])
  
  int ff_hevc_sao_merge_flag_decode(HEVCContext *s)
  {
      return GET_CABAC(elem_offset[SAO_MERGE_FLAG]);
  }
  
  int ff_hevc_sao_type_idx_decode(HEVCContext *s)
  {
      if (!GET_CABAC(elem_offset[SAO_TYPE_IDX]))
          return 0;
  
      if (!get_cabac_bypass(&s->HEVClc->cc))
          return SAO_BAND;
      return SAO_EDGE;
  }
  
  int ff_hevc_sao_band_position_decode(HEVCContext *s)
  {
      int i;
      int value = get_cabac_bypass(&s->HEVClc->cc);
  
      for (i = 0; i < 4; i++)
          value = (value << 1) | get_cabac_bypass(&s->HEVClc->cc);
      return value;
  }
  
  int ff_hevc_sao_offset_abs_decode(HEVCContext *s)
  {
      int i = 0;
      int length = (1 << (FFMIN(s->ps.sps->bit_depth, 10) - 5)) - 1;
  
      while (i < length && get_cabac_bypass(&s->HEVClc->cc))
          i++;
      return i;
  }
  
  int ff_hevc_sao_offset_sign_decode(HEVCContext *s)
  {
      return get_cabac_bypass(&s->HEVClc->cc);
  }
  
  int ff_hevc_sao_eo_class_decode(HEVCContext *s)
  {
      int ret = get_cabac_bypass(&s->HEVClc->cc) << 1;
      ret    |= get_cabac_bypass(&s->HEVClc->cc);
      return ret;
  }
  
  int ff_hevc_end_of_slice_flag_decode(HEVCContext *s)
  {
      return get_cabac_terminate(&s->HEVClc->cc);
  }
  
  int ff_hevc_cu_transquant_bypass_flag_decode(HEVCContext *s)
  {
      return GET_CABAC(elem_offset[CU_TRANSQUANT_BYPASS_FLAG]);
  }
  
  int ff_hevc_skip_flag_decode(HEVCContext *s, int x0, int y0, int x_cb, int y_cb)
  {
      int min_cb_width = s->ps.sps->min_cb_width;
      int inc = 0;
      int x0b = av_mod_uintp2(x0, s->ps.sps->log2_ctb_size);
      int y0b = av_mod_uintp2(y0, s->ps.sps->log2_ctb_size);
  
      if (s->HEVClc->ctb_left_flag || x0b)
          inc = !!SAMPLE_CTB(s->skip_flag, x_cb - 1, y_cb);
      if (s->HEVClc->ctb_up_flag || y0b)
          inc += !!SAMPLE_CTB(s->skip_flag, x_cb, y_cb - 1);
  
      return GET_CABAC(elem_offset[SKIP_FLAG] + inc);
  }
  
  int ff_hevc_cu_qp_delta_abs(HEVCContext *s)
  {
      int prefix_val = 0;
      int suffix_val = 0;
      int inc = 0;
  
      while (prefix_val < 5 && GET_CABAC(elem_offset[CU_QP_DELTA] + inc)) {
          prefix_val++;
          inc = 1;
      }
      if (prefix_val >= 5) {
          int k = 0;
          while (k < CABAC_MAX_BIN && get_cabac_bypass(&s->HEVClc->cc)) {
              suffix_val += 1 << k;
              k++;
          }
          if (k == CABAC_MAX_BIN)
              av_log(s->avctx, AV_LOG_ERROR, "CABAC_MAX_BIN : %d\n", k);
  
          while (k--)
              suffix_val += get_cabac_bypass(&s->HEVClc->cc) << k;
      }
      return prefix_val + suffix_val;
  }
  
  int ff_hevc_cu_qp_delta_sign_flag(HEVCContext *s)
  {
      return get_cabac_bypass(&s->HEVClc->cc);
  }
  
  int ff_hevc_cu_chroma_qp_offset_flag(HEVCContext *s)
  {
      return GET_CABAC(elem_offset[CU_CHROMA_QP_OFFSET_FLAG]);
  }
  
  int ff_hevc_cu_chroma_qp_offset_idx(HEVCContext *s)
  {
      int c_max= FFMAX(5, s->ps.pps->chroma_qp_offset_list_len_minus1);
      int i = 0;
  
      while (i < c_max && GET_CABAC(elem_offset[CU_CHROMA_QP_OFFSET_IDX]))
          i++;
  
      return i;
  }
  
  int ff_hevc_pred_mode_decode(HEVCContext *s)
  {
      return GET_CABAC(elem_offset[PRED_MODE_FLAG]);
  }
  
  int ff_hevc_split_coding_unit_flag_decode(HEVCContext *s, int ct_depth, int x0, int y0)
  {
      int inc = 0, depth_left = 0, depth_top = 0;
      int x0b  = av_mod_uintp2(x0, s->ps.sps->log2_ctb_size);
      int y0b  = av_mod_uintp2(y0, s->ps.sps->log2_ctb_size);
      int x_cb = x0 >> s->ps.sps->log2_min_cb_size;
      int y_cb = y0 >> s->ps.sps->log2_min_cb_size;
  
      if (s->HEVClc->ctb_left_flag || x0b)
          depth_left = s->tab_ct_depth[(y_cb) * s->ps.sps->min_cb_width + x_cb - 1];
      if (s->HEVClc->ctb_up_flag || y0b)
          depth_top = s->tab_ct_depth[(y_cb - 1) * s->ps.sps->min_cb_width + x_cb];
  
      inc += (depth_left > ct_depth);
      inc += (depth_top  > ct_depth);
  
      return GET_CABAC(elem_offset[SPLIT_CODING_UNIT_FLAG] + inc);
  }
  
  int ff_hevc_part_mode_decode(HEVCContext *s, int log2_cb_size)
  {
      if (GET_CABAC(elem_offset[PART_MODE])) // 1
          return PART_2Nx2N;
      if (log2_cb_size == s->ps.sps->log2_min_cb_size) {
          if (s->HEVClc->cu.pred_mode == MODE_INTRA) // 0
              return PART_NxN;
          if (GET_CABAC(elem_offset[PART_MODE] + 1)) // 01
              return PART_2NxN;
          if (log2_cb_size == 3) // 00
              return PART_Nx2N;
          if (GET_CABAC(elem_offset[PART_MODE] + 2)) // 001
              return PART_Nx2N;
          return PART_NxN; // 000
      }
  
      if (!s->ps.sps->amp_enabled_flag) {
          if (GET_CABAC(elem_offset[PART_MODE] + 1)) // 01
              return PART_2NxN;
          return PART_Nx2N;
      }
  
      if (GET_CABAC(elem_offset[PART_MODE] + 1)) { // 01X, 01XX
          if (GET_CABAC(elem_offset[PART_MODE] + 3)) // 011
              return PART_2NxN;
          if (get_cabac_bypass(&s->HEVClc->cc)) // 0101
              return PART_2NxnD;
          return PART_2NxnU; // 0100
      }
  
      if (GET_CABAC(elem_offset[PART_MODE] + 3)) // 001
          return PART_Nx2N;
      if (get_cabac_bypass(&s->HEVClc->cc)) // 0001
          return PART_nRx2N;
      return PART_nLx2N;  // 0000
  }
  
  int ff_hevc_pcm_flag_decode(HEVCContext *s)
  {
      return get_cabac_terminate(&s->HEVClc->cc);
  }
  
  int ff_hevc_prev_intra_luma_pred_flag_decode(HEVCContext *s)
  {
      return GET_CABAC(elem_offset[PREV_INTRA_LUMA_PRED_FLAG]);
  }
  
  int ff_hevc_mpm_idx_decode(HEVCContext *s)
  {
      int i = 0;
      while (i < 2 && get_cabac_bypass(&s->HEVClc->cc))
          i++;
      return i;
  }
  
  int ff_hevc_rem_intra_luma_pred_mode_decode(HEVCContext *s)
  {
      int i;
      int value = get_cabac_bypass(&s->HEVClc->cc);
  
      for (i = 0; i < 4; i++)
          value = (value << 1) | get_cabac_bypass(&s->HEVClc->cc);
      return value;
  }
  
  int ff_hevc_intra_chroma_pred_mode_decode(HEVCContext *s)
  {
      int ret;
      if (!GET_CABAC(elem_offset[INTRA_CHROMA_PRED_MODE]))
          return 4;
  
      ret  = get_cabac_bypass(&s->HEVClc->cc) << 1;
      ret |= get_cabac_bypass(&s->HEVClc->cc);
      return ret;
  }
  
  int ff_hevc_merge_idx_decode(HEVCContext *s)
  {
      int i = GET_CABAC(elem_offset[MERGE_IDX]);
  
      if (i != 0) {
          while (i < s->sh.max_num_merge_cand-1 && get_cabac_bypass(&s->HEVClc->cc))
              i++;
      }
      return i;
  }
  
  int ff_hevc_merge_flag_decode(HEVCContext *s)
  {
      return GET_CABAC(elem_offset[MERGE_FLAG]);
  }
  
  int ff_hevc_inter_pred_idc_decode(HEVCContext *s, int nPbW, int nPbH)
  {
      if (nPbW + nPbH == 12)
          return GET_CABAC(elem_offset[INTER_PRED_IDC] + 4);
      if (GET_CABAC(elem_offset[INTER_PRED_IDC] + s->HEVClc->ct_depth))
          return PRED_BI;
  
      return GET_CABAC(elem_offset[INTER_PRED_IDC] + 4);
  }
  
  int ff_hevc_ref_idx_lx_decode(HEVCContext *s, int num_ref_idx_lx)
  {
      int i = 0;
      int max = num_ref_idx_lx - 1;
      int max_ctx = FFMIN(max, 2);
  
      while (i < max_ctx && GET_CABAC(elem_offset[REF_IDX_L0] + i))
          i++;
      if (i == 2) {
          while (i < max && get_cabac_bypass(&s->HEVClc->cc))
              i++;
      }
  
      return i;
  }
  
  int ff_hevc_mvp_lx_flag_decode(HEVCContext *s)
  {
      return GET_CABAC(elem_offset[MVP_LX_FLAG]);
  }
  
  int ff_hevc_no_residual_syntax_flag_decode(HEVCContext *s)
  {
      return GET_CABAC(elem_offset[NO_RESIDUAL_DATA_FLAG]);
  }
  
  static av_always_inline int abs_mvd_greater0_flag_decode(HEVCContext *s)
  {
      return GET_CABAC(elem_offset[ABS_MVD_GREATER0_FLAG]);
  }
  
  static av_always_inline int abs_mvd_greater1_flag_decode(HEVCContext *s)
  {
      return GET_CABAC(elem_offset[ABS_MVD_GREATER1_FLAG] + 1);
  }
  
  static av_always_inline int mvd_decode(HEVCContext *s)
  {
      int ret = 2;
      int k = 1;
  
      while (k < CABAC_MAX_BIN && get_cabac_bypass(&s->HEVClc->cc)) {
          ret += 1U << k;
          k++;
      }
      if (k == CABAC_MAX_BIN) {
          av_log(s->avctx, AV_LOG_ERROR, "CABAC_MAX_BIN : %d\n", k);
          return 0;
      }
      while (k--)
          ret += get_cabac_bypass(&s->HEVClc->cc) << k;
      return get_cabac_bypass_sign(&s->HEVClc->cc, -ret);
  }
  
  static av_always_inline int mvd_sign_flag_decode(HEVCContext *s)
  {
      return get_cabac_bypass_sign(&s->HEVClc->cc, -1);
  }
  
  int ff_hevc_split_transform_flag_decode(HEVCContext *s, int log2_trafo_size)
  {
      return GET_CABAC(elem_offset[SPLIT_TRANSFORM_FLAG] + 5 - log2_trafo_size);
  }
  
  int ff_hevc_cbf_cb_cr_decode(HEVCContext *s, int trafo_depth)
  {
      return GET_CABAC(elem_offset[CBF_CB_CR] + trafo_depth);
  }
  
  int ff_hevc_cbf_luma_decode(HEVCContext *s, int trafo_depth)
  {
      return GET_CABAC(elem_offset[CBF_LUMA] + !trafo_depth);
  }
  
  static int hevc_transform_skip_flag_decode(HEVCContext *s, int c_idx)
  {
      return GET_CABAC(elem_offset[TRANSFORM_SKIP_FLAG] + !!c_idx);
  }
  
  static int explicit_rdpcm_flag_decode(HEVCContext *s, int c_idx)
  {
      return GET_CABAC(elem_offset[EXPLICIT_RDPCM_FLAG] + !!c_idx);
  }
  
  static int explicit_rdpcm_dir_flag_decode(HEVCContext *s, int c_idx)
  {
      return GET_CABAC(elem_offset[EXPLICIT_RDPCM_DIR_FLAG] + !!c_idx);
  }
  
  int ff_hevc_log2_res_scale_abs(HEVCContext *s, int idx) {
      int i =0;
  
      while (i < 4 && GET_CABAC(elem_offset[LOG2_RES_SCALE_ABS] + 4 * idx + i))
          i++;
  
      return i;
  }
  
  int ff_hevc_res_scale_sign_flag(HEVCContext *s, int idx) {
      return GET_CABAC(elem_offset[RES_SCALE_SIGN_FLAG] + idx);
  }
  
  static av_always_inline void last_significant_coeff_xy_prefix_decode(HEVCContext *s, int c_idx,
                                                     int log2_size, int *last_scx_prefix, int *last_scy_prefix)
  {
      int i = 0;
      int max = (log2_size << 1) - 1;
      int ctx_offset, ctx_shift;
  
      if (!c_idx) {
          ctx_offset = 3 * (log2_size - 2)  + ((log2_size - 1) >> 2);
          ctx_shift = (log2_size + 1) >> 2;
      } else {
          ctx_offset = 15;
          ctx_shift = log2_size - 2;
      }
      while (i < max &&
             GET_CABAC(elem_offset[LAST_SIGNIFICANT_COEFF_X_PREFIX] + (i >> ctx_shift) + ctx_offset))
          i++;
      *last_scx_prefix = i;
  
      i = 0;
      while (i < max &&
             GET_CABAC(elem_offset[LAST_SIGNIFICANT_COEFF_Y_PREFIX] + (i >> ctx_shift) + ctx_offset))
          i++;
      *last_scy_prefix = i;
  }
  
  static av_always_inline int last_significant_coeff_suffix_decode(HEVCContext *s,
                                                   int last_significant_coeff_prefix)
  {
      int i;
      int length = (last_significant_coeff_prefix >> 1) - 1;
      int value = get_cabac_bypass(&s->HEVClc->cc);
  
      for (i = 1; i < length; i++)
          value = (value << 1) | get_cabac_bypass(&s->HEVClc->cc);
      return value;
  }
  
  static av_always_inline int significant_coeff_group_flag_decode(HEVCContext *s, int c_idx, int ctx_cg)
  {
      int inc;
  
      inc = FFMIN(ctx_cg, 1) + (c_idx>0 ? 2 : 0);
  
      return GET_CABAC(elem_offset[SIGNIFICANT_COEFF_GROUP_FLAG] + inc);
  }
  static av_always_inline int significant_coeff_flag_decode(HEVCContext *s, int x_c, int y_c,
                                             int offset, const uint8_t *ctx_idx_map)
  {
      int inc = ctx_idx_map[(y_c << 2) + x_c] + offset;
      return GET_CABAC(elem_offset[SIGNIFICANT_COEFF_FLAG] + inc);
  }
  
  static av_always_inline int significant_coeff_flag_decode_0(HEVCContext *s, int c_idx, int offset)
  {
      return GET_CABAC(elem_offset[SIGNIFICANT_COEFF_FLAG] + offset);
  }
  
  static av_always_inline int coeff_abs_level_greater1_flag_decode(HEVCContext *s, int c_idx, int inc)
  {
  
      if (c_idx > 0)
          inc += 16;
  
      return GET_CABAC(elem_offset[COEFF_ABS_LEVEL_GREATER1_FLAG] + inc);
  }
  
  static av_always_inline int coeff_abs_level_greater2_flag_decode(HEVCContext *s, int c_idx, int inc)
  {
      if (c_idx > 0)
          inc += 4;
  
      return GET_CABAC(elem_offset[COEFF_ABS_LEVEL_GREATER2_FLAG] + inc);
  }
  
  static av_always_inline int coeff_abs_level_remaining_decode(HEVCContext *s, int rc_rice_param)
  {
      int prefix = 0;
      int suffix = 0;
      int last_coeff_abs_level_remaining;
      int i;
  
      while (prefix < CABAC_MAX_BIN && get_cabac_bypass(&s->HEVClc->cc))
          prefix++;
      if (prefix == CABAC_MAX_BIN) {
          av_log(s->avctx, AV_LOG_ERROR, "CABAC_MAX_BIN : %d\n", prefix);
          return 0;
      }
      if (prefix < 3) {
          for (i = 0; i < rc_rice_param; i++)
              suffix = (suffix << 1) | get_cabac_bypass(&s->HEVClc->cc);
          last_coeff_abs_level_remaining = (prefix << rc_rice_param) + suffix;
      } else {
          int prefix_minus3 = prefix - 3;
          for (i = 0; i < prefix_minus3 + rc_rice_param; i++)
              suffix = (suffix << 1) | get_cabac_bypass(&s->HEVClc->cc);
          last_coeff_abs_level_remaining = (((1 << prefix_minus3) + 3 - 1)
                                                << rc_rice_param) + suffix;
      }
      return last_coeff_abs_level_remaining;
  }
  
  static av_always_inline int coeff_sign_flag_decode(HEVCContext *s, uint8_t nb)
  {
      int i;
      int ret = 0;
  
      for (i = 0; i < nb; i++)
          ret = (ret << 1) | get_cabac_bypass(&s->HEVClc->cc);
      return ret;
  }
  
  void ff_hevc_hls_residual_coding(HEVCContext *s, int x0, int y0,
                                  int log2_trafo_size, enum ScanType scan_idx,
                                  int c_idx)
  {
  #define GET_COORD(offset, n)                                    \
      do {                                                        \
          x_c = (x_cg << 2) + scan_x_off[n];                      \
          y_c = (y_cg << 2) + scan_y_off[n];                      \
      } while (0)
      HEVCLocalContext *lc = s->HEVClc;
      int transform_skip_flag = 0;
  
      int last_significant_coeff_x, last_significant_coeff_y;
      int last_scan_pos;
      int n_end;
      int num_coeff = 0;
      int greater1_ctx = 1;
  
      int num_last_subset;
      int x_cg_last_sig, y_cg_last_sig;
  
      const uint8_t *scan_x_cg, *scan_y_cg, *scan_x_off, *scan_y_off;
  
      ptrdiff_t stride = s->frame->linesize[c_idx];
      int hshift = s->ps.sps->hshift[c_idx];
      int vshift = s->ps.sps->vshift[c_idx];
      uint8_t *dst = &s->frame->data[c_idx][(y0 >> vshift) * stride +
                                            ((x0 >> hshift) << s->ps.sps->pixel_shift)];
      int16_t *coeffs = (int16_t*)(c_idx ? lc->edge_emu_buffer2 : lc->edge_emu_buffer);
      uint8_t significant_coeff_group_flag[8][8] = {{0}};
      int explicit_rdpcm_flag = 0;
      int explicit_rdpcm_dir_flag;
  
      int trafo_size = 1 << log2_trafo_size;
      int i;
      int qp,shift,add,scale,scale_m;
      const uint8_t level_scale[] = { 40, 45, 51, 57, 64, 72 };
      const uint8_t *scale_matrix = NULL;
      uint8_t dc_scale;
      int pred_mode_intra = (c_idx == 0) ? lc->tu.intra_pred_mode :
                                           lc->tu.intra_pred_mode_c;
  
      memset(coeffs, 0, trafo_size * trafo_size * sizeof(int16_t));
  
      // Derive QP for dequant
      if (!lc->cu.cu_transquant_bypass_flag) {
          static const int qp_c[] = { 29, 30, 31, 32, 33, 33, 34, 34, 35, 35, 36, 36, 37, 37 };
          static const uint8_t rem6[51 + 4 * 6 + 1] = {
              0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2,
              3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5,
              0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3,
              4, 5, 0, 1, 2, 3, 4, 5, 0, 1
          };
  
          static const uint8_t div6[51 + 4 * 6 + 1] = {
              0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 3,  3,  3,
              3, 3, 3, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6,  6,  6,
              7, 7, 7, 7, 7, 7, 8, 8, 8, 8, 8, 8, 9, 9, 9, 9, 9, 9, 10, 10, 10, 10,
              10, 10, 11, 11, 11, 11, 11, 11, 12, 12
          };
          int qp_y = lc->qp_y;
  
          if (s->ps.pps->transform_skip_enabled_flag &&
              log2_trafo_size <= s->ps.pps->log2_max_transform_skip_block_size) {
              transform_skip_flag = hevc_transform_skip_flag_decode(s, c_idx);
          }
  
          if (c_idx == 0) {
              qp = qp_y + s->ps.sps->qp_bd_offset;
          } else {
              int qp_i, offset;
  
              if (c_idx == 1)
                  offset = s->ps.pps->cb_qp_offset + s->sh.slice_cb_qp_offset +
                           lc->tu.cu_qp_offset_cb;
              else
                  offset = s->ps.pps->cr_qp_offset + s->sh.slice_cr_qp_offset +
                           lc->tu.cu_qp_offset_cr;
  
              qp_i = av_clip(qp_y + offset, - s->ps.sps->qp_bd_offset, 57);
              if (s->ps.sps->chroma_format_idc == 1) {
                  if (qp_i < 30)
                      qp = qp_i;
                  else if (qp_i > 43)
                      qp = qp_i - 6;
                  else
                      qp = qp_c[qp_i - 30];
              } else {
                  if (qp_i > 51)
                      qp = 51;
                  else
                      qp = qp_i;
              }
  
              qp += s->ps.sps->qp_bd_offset;
          }
  
          shift    = s->ps.sps->bit_depth + log2_trafo_size - 5;
          add      = 1 << (shift-1);
          scale    = level_scale[rem6[qp]] << (div6[qp]);
          scale_m  = 16; // default when no custom scaling lists.
          dc_scale = 16;
  
          if (s->ps.sps->scaling_list_enable_flag && !(transform_skip_flag && log2_trafo_size > 2)) {
              const ScalingList *sl = s->ps.pps->scaling_list_data_present_flag ?
              &s->ps.pps->scaling_list : &s->ps.sps->scaling_list;
              int matrix_id = lc->cu.pred_mode != MODE_INTRA;
  
              matrix_id = 3 * matrix_id + c_idx;
  
              scale_matrix = sl->sl[log2_trafo_size - 2][matrix_id];
              if (log2_trafo_size >= 4)
                  dc_scale = sl->sl_dc[log2_trafo_size - 4][matrix_id];
          }
      } else {
          shift        = 0;
          add          = 0;
          scale        = 0;
          dc_scale     = 0;
      }
  
      if (lc->cu.pred_mode == MODE_INTER && s->ps.sps->explicit_rdpcm_enabled_flag &&
          (transform_skip_flag || lc->cu.cu_transquant_bypass_flag)) {
          explicit_rdpcm_flag = explicit_rdpcm_flag_decode(s, c_idx);
          if (explicit_rdpcm_flag) {
              explicit_rdpcm_dir_flag = explicit_rdpcm_dir_flag_decode(s, c_idx);
          }
      }
  
      last_significant_coeff_xy_prefix_decode(s, c_idx, log2_trafo_size,
                                             &last_significant_coeff_x, &last_significant_coeff_y);
  
      if (last_significant_coeff_x > 3) {
          int suffix = last_significant_coeff_suffix_decode(s, last_significant_coeff_x);
          last_significant_coeff_x = (1 << ((last_significant_coeff_x >> 1) - 1)) *
          (2 + (last_significant_coeff_x & 1)) +
          suffix;
      }
  
      if (last_significant_coeff_y > 3) {
          int suffix = last_significant_coeff_suffix_decode(s, last_significant_coeff_y);
          last_significant_coeff_y = (1 << ((last_significant_coeff_y >> 1) - 1)) *
          (2 + (last_significant_coeff_y & 1)) +
          suffix;
      }
  
      if (scan_idx == SCAN_VERT)
          FFSWAP(int, last_significant_coeff_x, last_significant_coeff_y);
  
      x_cg_last_sig = last_significant_coeff_x >> 2;
      y_cg_last_sig = last_significant_coeff_y >> 2;
  
      switch (scan_idx) {
      case SCAN_DIAG: {
          int last_x_c = last_significant_coeff_x & 3;
          int last_y_c = last_significant_coeff_y & 3;
  
          scan_x_off = ff_hevc_diag_scan4x4_x;
          scan_y_off = ff_hevc_diag_scan4x4_y;
          num_coeff = diag_scan4x4_inv[last_y_c][last_x_c];
          if (trafo_size == 4) {
              scan_x_cg = scan_1x1;
              scan_y_cg = scan_1x1;
          } else if (trafo_size == 8) {
              num_coeff += diag_scan2x2_inv[y_cg_last_sig][x_cg_last_sig] << 4;
              scan_x_cg = diag_scan2x2_x;
              scan_y_cg = diag_scan2x2_y;
          } else if (trafo_size == 16) {
              num_coeff += diag_scan4x4_inv[y_cg_last_sig][x_cg_last_sig] << 4;
              scan_x_cg = ff_hevc_diag_scan4x4_x;
              scan_y_cg = ff_hevc_diag_scan4x4_y;
          } else { // trafo_size == 32
              num_coeff += diag_scan8x8_inv[y_cg_last_sig][x_cg_last_sig] << 4;
              scan_x_cg = ff_hevc_diag_scan8x8_x;
              scan_y_cg = ff_hevc_diag_scan8x8_y;
          }
          break;
      }
      case SCAN_HORIZ:
          scan_x_cg = horiz_scan2x2_x;
          scan_y_cg = horiz_scan2x2_y;
          scan_x_off = horiz_scan4x4_x;
          scan_y_off = horiz_scan4x4_y;
          num_coeff = horiz_scan8x8_inv[last_significant_coeff_y][last_significant_coeff_x];
          break;
      default: //SCAN_VERT
          scan_x_cg = horiz_scan2x2_y;
          scan_y_cg = horiz_scan2x2_x;
          scan_x_off = horiz_scan4x4_y;
          scan_y_off = horiz_scan4x4_x;
          num_coeff = horiz_scan8x8_inv[last_significant_coeff_x][last_significant_coeff_y];
          break;
      }
      num_coeff++;
      num_last_subset = (num_coeff - 1) >> 4;
  
      for (i = num_last_subset; i >= 0; i--) {
          int n, m;
          int x_cg, y_cg, x_c, y_c, pos;
          int implicit_non_zero_coeff = 0;
          int64_t trans_coeff_level;
          int prev_sig = 0;
          int offset = i << 4;
          int rice_init = 0;
  
          uint8_t significant_coeff_flag_idx[16];
          uint8_t nb_significant_coeff_flag = 0;
  
          x_cg = scan_x_cg[i];
          y_cg = scan_y_cg[i];
  
          if ((i < num_last_subset) && (i > 0)) {
              int ctx_cg = 0;
              if (x_cg < (1 << (log2_trafo_size - 2)) - 1)
                  ctx_cg += significant_coeff_group_flag[x_cg + 1][y_cg];
              if (y_cg < (1 << (log2_trafo_size - 2)) - 1)
                  ctx_cg += significant_coeff_group_flag[x_cg][y_cg + 1];
  
              significant_coeff_group_flag[x_cg][y_cg] =
                  significant_coeff_group_flag_decode(s, c_idx, ctx_cg);
              implicit_non_zero_coeff = 1;
          } else {
              significant_coeff_group_flag[x_cg][y_cg] =
              ((x_cg == x_cg_last_sig && y_cg == y_cg_last_sig) ||
               (x_cg == 0 && y_cg == 0));
          }
  
          last_scan_pos = num_coeff - offset - 1;
  
          if (i == num_last_subset) {
              n_end = last_scan_pos - 1;
              significant_coeff_flag_idx[0] = last_scan_pos;
              nb_significant_coeff_flag = 1;
          } else {
              n_end = 15;
          }
  
          if (x_cg < ((1 << log2_trafo_size) - 1) >> 2)
              prev_sig = !!significant_coeff_group_flag[x_cg + 1][y_cg];
          if (y_cg < ((1 << log2_trafo_size) - 1) >> 2)
              prev_sig += (!!significant_coeff_group_flag[x_cg][y_cg + 1] << 1);
  
          if (significant_coeff_group_flag[x_cg][y_cg] && n_end >= 0) {
              static const uint8_t ctx_idx_map[] = {
                  0, 1, 4, 5, 2, 3, 4, 5, 6, 6, 8, 8, 7, 7, 8, 8, // log2_trafo_size == 2
                  1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, // prev_sig == 0
                  2, 2, 2, 2, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, // prev_sig == 1
                  2, 1, 0, 0, 2, 1, 0, 0, 2, 1, 0, 0, 2, 1, 0, 0, // prev_sig == 2
                  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2  // default
              };
              const uint8_t *ctx_idx_map_p;
              int scf_offset = 0;
              if (s->ps.sps->transform_skip_context_enabled_flag &&
                  (transform_skip_flag || lc->cu.cu_transquant_bypass_flag)) {
                  ctx_idx_map_p = (uint8_t*) &ctx_idx_map[4 * 16];
                  if (c_idx == 0) {
                      scf_offset = 40;
                  } else {
                      scf_offset = 14 + 27;
                  }
              } else {
                  if (c_idx != 0)
                      scf_offset = 27;
                  if (log2_trafo_size == 2) {
                      ctx_idx_map_p = (uint8_t*) &ctx_idx_map[0];
                  } else {
                      ctx_idx_map_p = (uint8_t*) &ctx_idx_map[(prev_sig + 1) << 4];
                      if (c_idx == 0) {
                          if ((x_cg > 0 || y_cg > 0))
                              scf_offset += 3;
                          if (log2_trafo_size == 3) {
                              scf_offset += (scan_idx == SCAN_DIAG) ? 9 : 15;
                          } else {
                              scf_offset += 21;
                          }
                      } else {
                          if (log2_trafo_size == 3)
                              scf_offset += 9;
                          else
                              scf_offset += 12;
                      }
                  }
              }
              for (n = n_end; n > 0; n--) {
                  x_c = scan_x_off[n];
                  y_c = scan_y_off[n];
                  if (significant_coeff_flag_decode(s, x_c, y_c, scf_offset, ctx_idx_map_p)) {
                      significant_coeff_flag_idx[nb_significant_coeff_flag] = n;
                      nb_significant_coeff_flag++;
                      implicit_non_zero_coeff = 0;
                  }
              }
              if (implicit_non_zero_coeff == 0) {
                  if (s->ps.sps->transform_skip_context_enabled_flag &&
                      (transform_skip_flag || lc->cu.cu_transquant_bypass_flag)) {
                      if (c_idx == 0) {
                          scf_offset = 42;
                      } else {
                          scf_offset = 16 + 27;
                      }
                  } else {
                      if (i == 0) {
                          if (c_idx == 0)
                              scf_offset = 0;
                          else
                              scf_offset = 27;
                      } else {
                          scf_offset = 2 + scf_offset;
                      }
                  }
                  if (significant_coeff_flag_decode_0(s, c_idx, scf_offset) == 1) {
                      significant_coeff_flag_idx[nb_significant_coeff_flag] = 0;
                      nb_significant_coeff_flag++;
                  }
              } else {
                  significant_coeff_flag_idx[nb_significant_coeff_flag] = 0;
                  nb_significant_coeff_flag++;
              }
          }
  
          n_end = nb_significant_coeff_flag;
  
  
          if (n_end) {
              int first_nz_pos_in_cg;
              int last_nz_pos_in_cg;
              int c_rice_param = 0;
              int first_greater1_coeff_idx = -1;
              uint8_t coeff_abs_level_greater1_flag[8];
              uint16_t coeff_sign_flag;
              int sum_abs = 0;
              int sign_hidden;
              int sb_type;
  
  
              // initialize first elem of coeff_bas_level_greater1_flag
              int ctx_set = (i > 0 && c_idx == 0) ? 2 : 0;
  
              if (s->ps.sps->persistent_rice_adaptation_enabled_flag) {
                  if (!transform_skip_flag && !lc->cu.cu_transquant_bypass_flag)
                      sb_type = 2 * (c_idx == 0 ? 1 : 0);
                  else
                      sb_type = 2 * (c_idx == 0 ? 1 : 0) + 1;
                  c_rice_param = lc->stat_coeff[sb_type] / 4;
              }
  
              if (!(i == num_last_subset) && greater1_ctx == 0)
                  ctx_set++;
              greater1_ctx = 1;
              last_nz_pos_in_cg = significant_coeff_flag_idx[0];
  
              for (m = 0; m < (n_end > 8 ? 8 : n_end); m++) {
                  int inc = (ctx_set << 2) + greater1_ctx;
                  coeff_abs_level_greater1_flag[m] =
                      coeff_abs_level_greater1_flag_decode(s, c_idx, inc);
                  if (coeff_abs_level_greater1_flag[m]) {
                      greater1_ctx = 0;
                      if (first_greater1_coeff_idx == -1)
                          first_greater1_coeff_idx = m;
                  } else if (greater1_ctx > 0 && greater1_ctx < 3) {
                      greater1_ctx++;
                  }
              }
              first_nz_pos_in_cg = significant_coeff_flag_idx[n_end - 1];
  
              if (lc->cu.cu_transquant_bypass_flag ||
                  (lc->cu.pred_mode ==  MODE_INTRA  &&
                   s->ps.sps->implicit_rdpcm_enabled_flag  &&  transform_skip_flag  &&
                   (pred_mode_intra == 10 || pred_mode_intra  ==  26 )) ||
                   explicit_rdpcm_flag)
                  sign_hidden = 0;
              else
                  sign_hidden = (last_nz_pos_in_cg - first_nz_pos_in_cg >= 4);
  
              if (first_greater1_coeff_idx != -1) {
                  coeff_abs_level_greater1_flag[first_greater1_coeff_idx] += coeff_abs_level_greater2_flag_decode(s, c_idx, ctx_set);
              }
              if (!s->ps.pps->sign_data_hiding_flag || !sign_hidden ) {
                  coeff_sign_flag = coeff_sign_flag_decode(s, nb_significant_coeff_flag) << (16 - nb_significant_coeff_flag);
              } else {
                  coeff_sign_flag = coeff_sign_flag_decode(s, nb_significant_coeff_flag - 1) << (16 - (nb_significant_coeff_flag - 1));
              }
  
              for (m = 0; m < n_end; m++) {
                  n = significant_coeff_flag_idx[m];
                  GET_COORD(offset, n);
                  if (m < 8) {
                      trans_coeff_level = 1 + coeff_abs_level_greater1_flag[m];
                      if (trans_coeff_level == ((m == first_greater1_coeff_idx) ? 3 : 2)) {
                          int last_coeff_abs_level_remaining = coeff_abs_level_remaining_decode(s, c_rice_param);
  
                          trans_coeff_level += last_coeff_abs_level_remaining;
                          if (trans_coeff_level > (3 << c_rice_param))
                              c_rice_param = s->ps.sps->persistent_rice_adaptation_enabled_flag ? c_rice_param + 1 : FFMIN(c_rice_param + 1, 4);
                          if (s->ps.sps->persistent_rice_adaptation_enabled_flag && !rice_init) {
                              int c_rice_p_init = lc->stat_coeff[sb_type] / 4;
                              if (last_coeff_abs_level_remaining >= (3 << c_rice_p_init))
                                  lc->stat_coeff[sb_type]++;
                              else if (2 * last_coeff_abs_level_remaining < (1 << c_rice_p_init))
                                  if (lc->stat_coeff[sb_type] > 0)
                                      lc->stat_coeff[sb_type]--;
                              rice_init = 1;
                          }
                      }
                  } else {
                      int last_coeff_abs_level_remaining = coeff_abs_level_remaining_decode(s, c_rice_param);
  
                      trans_coeff_level = 1 + last_coeff_abs_level_remaining;
                      if (trans_coeff_level > (3 << c_rice_param))
                          c_rice_param = s->ps.sps->persistent_rice_adaptation_enabled_flag ? c_rice_param + 1 : FFMIN(c_rice_param + 1, 4);
                      if (s->ps.sps->persistent_rice_adaptation_enabled_flag && !rice_init) {
                          int c_rice_p_init = lc->stat_coeff[sb_type] / 4;
                          if (last_coeff_abs_level_remaining >= (3 << c_rice_p_init))
                              lc->stat_coeff[sb_type]++;
                          else if (2 * last_coeff_abs_level_remaining < (1 << c_rice_p_init))
                              if (lc->stat_coeff[sb_type] > 0)
                                  lc->stat_coeff[sb_type]--;
                          rice_init = 1;
                      }
                  }
                  if (s->ps.pps->sign_data_hiding_flag && sign_hidden) {
                      sum_abs += trans_coeff_level;
                      if (n == first_nz_pos_in_cg && (sum_abs&1))
                          trans_coeff_level = -trans_coeff_level;
                  }
                  if (coeff_sign_flag >> 15)
                      trans_coeff_level = -trans_coeff_level;
                  coeff_sign_flag <<= 1;
                  if(!lc->cu.cu_transquant_bypass_flag) {
                      if (s->ps.sps->scaling_list_enable_flag && !(transform_skip_flag && log2_trafo_size > 2)) {
                          if(y_c || x_c || log2_trafo_size < 4) {
                              switch(log2_trafo_size) {
                                  case 3: pos = (y_c << 3) + x_c; break;
                                  case 4: pos = ((y_c >> 1) << 3) + (x_c >> 1); break;
                                  case 5: pos = ((y_c >> 2) << 3) + (x_c >> 2); break;
                                  default: pos = (y_c << 2) + x_c; break;
                              }
                              scale_m = scale_matrix[pos];
                          } else {
                              scale_m = dc_scale;
                          }
                      }
                      trans_coeff_level = (trans_coeff_level * (int64_t)scale * (int64_t)scale_m + add) >> shift;
                      if(trans_coeff_level < 0) {
                          if((~trans_coeff_level) & 0xFffffffffff8000)
                              trans_coeff_level = -32768;
                      } else {
                          if(trans_coeff_level & 0xffffffffffff8000)
                              trans_coeff_level = 32767;
                      }
                  }
                  coeffs[y_c * trafo_size + x_c] = trans_coeff_level;
              }
          }
      }
  
      if (lc->cu.cu_transquant_bypass_flag) {
          if (explicit_rdpcm_flag || (s->ps.sps->implicit_rdpcm_enabled_flag &&
                                      (pred_mode_intra == 10 || pred_mode_intra == 26))) {
              int mode = s->ps.sps->implicit_rdpcm_enabled_flag ? (pred_mode_intra == 26) : explicit_rdpcm_dir_flag;
  
              s->hevcdsp.transform_rdpcm(coeffs, log2_trafo_size, mode);
          }
      } else {
          if (transform_skip_flag) {
              int rot = s->ps.sps->transform_skip_rotation_enabled_flag &&
                        log2_trafo_size == 2 &&
                        lc->cu.pred_mode == MODE_INTRA;
              if (rot) {
                  for (i = 0; i < 8; i++)
                      FFSWAP(int16_t, coeffs[i], coeffs[16 - i - 1]);
              }
  
              s->hevcdsp.transform_skip(coeffs, log2_trafo_size);
  
              if (explicit_rdpcm_flag || (s->ps.sps->implicit_rdpcm_enabled_flag &&
                                          lc->cu.pred_mode == MODE_INTRA &&
                                          (pred_mode_intra == 10 || pred_mode_intra == 26))) {
                  int mode = explicit_rdpcm_flag ? explicit_rdpcm_dir_flag : (pred_mode_intra == 26);
  
                  s->hevcdsp.transform_rdpcm(coeffs, log2_trafo_size, mode);
              }
          } else if (lc->cu.pred_mode == MODE_INTRA && c_idx == 0 && log2_trafo_size == 2) {
              s->hevcdsp.idct_4x4_luma(coeffs);
          } else {
              int max_xy = FFMAX(last_significant_coeff_x, last_significant_coeff_y);
              if (max_xy == 0)
                  s->hevcdsp.idct_dc[log2_trafo_size-2](coeffs);
              else {
                  int col_limit = last_significant_coeff_x + last_significant_coeff_y + 4;
                  if (max_xy < 4)
                      col_limit = FFMIN(4, col_limit);
                  else if (max_xy < 8)
                      col_limit = FFMIN(8, col_limit);
                  else if (max_xy < 12)
                      col_limit = FFMIN(24, col_limit);
                  s->hevcdsp.idct[log2_trafo_size-2](coeffs, col_limit);
              }
          }
      }
      if (lc->tu.cross_pf) {
          int16_t *coeffs_y = (int16_t*)lc->edge_emu_buffer;
  
          for (i = 0; i < (trafo_size * trafo_size); i++) {
              coeffs[i] = coeffs[i] + ((lc->tu.res_scale_val * coeffs_y[i]) >> 3);
          }
      }
      s->hevcdsp.transform_add[log2_trafo_size-2](dst, coeffs, stride);
  }
  
  void ff_hevc_hls_mvd_coding(HEVCContext *s, int x0, int y0, int log2_cb_size)
  {
      HEVCLocalContext *lc = s->HEVClc;
      int x = abs_mvd_greater0_flag_decode(s);
      int y = abs_mvd_greater0_flag_decode(s);
  
      if (x)
          x += abs_mvd_greater1_flag_decode(s);
      if (y)
          y += abs_mvd_greater1_flag_decode(s);
  
      switch (x) {
      case 2: lc->pu.mvd.x = mvd_decode(s);           break;
      case 1: lc->pu.mvd.x = mvd_sign_flag_decode(s); break;
      case 0: lc->pu.mvd.x = 0;                       break;
      }
  
      switch (y) {
      case 2: lc->pu.mvd.y = mvd_decode(s);           break;
      case 1: lc->pu.mvd.y = mvd_sign_flag_decode(s); break;
      case 0: lc->pu.mvd.y = 0;                       break;
      }
  }
  
  