Subversion Repositories Kolibri OS

Rev

Blame | Last modification | View Log | RSS feed

  1. /*
  2.  * HEVC CABAC decoding
  3.  *
  4.  * Copyright (C) 2012 - 2013 Guillaume Martres
  5.  * Copyright (C) 2012 - 2013 Gildas Cocherel
  6.  *
  7.  * This file is part of FFmpeg.
  8.  *
  9.  * FFmpeg is free software; you can redistribute it and/or
  10.  * modify it under the terms of the GNU Lesser General Public
  11.  * License as published by the Free Software Foundation; either
  12.  * version 2.1 of the License, or (at your option) any later version.
  13.  *
  14.  * FFmpeg is distributed in the hope that it will be useful,
  15.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17.  * Lesser General Public License for more details.
  18.  *
  19.  * You should have received a copy of the GNU Lesser General Public
  20.  * License along with FFmpeg; if not, write to the Free Software
  21.  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  22.  */
  23.  
  24. #include "libavutil/attributes.h"
  25. #include "libavutil/common.h"
  26.  
  27. #include "cabac_functions.h"
  28. #include "hevc.h"
  29.  
  30. #define CABAC_MAX_BIN 31
  31.  
  32. /**
  33.  * number of bin by SyntaxElement.
  34.  */
  35. av_unused static const int8_t num_bins_in_se[] = {
  36.      1, // sao_merge_flag
  37.      1, // sao_type_idx
  38.      0, // sao_eo_class
  39.      0, // sao_band_position
  40.      0, // sao_offset_abs
  41.      0, // sao_offset_sign
  42.      0, // end_of_slice_flag
  43.      3, // split_coding_unit_flag
  44.      1, // cu_transquant_bypass_flag
  45.      3, // skip_flag
  46.      3, // cu_qp_delta
  47.      1, // pred_mode
  48.      4, // part_mode
  49.      0, // pcm_flag
  50.      1, // prev_intra_luma_pred_mode
  51.      0, // mpm_idx
  52.      0, // rem_intra_luma_pred_mode
  53.      2, // intra_chroma_pred_mode
  54.      1, // merge_flag
  55.      1, // merge_idx
  56.      5, // inter_pred_idc
  57.      2, // ref_idx_l0
  58.      2, // ref_idx_l1
  59.      2, // abs_mvd_greater0_flag
  60.      2, // abs_mvd_greater1_flag
  61.      0, // abs_mvd_minus2
  62.      0, // mvd_sign_flag
  63.      1, // mvp_lx_flag
  64.      1, // no_residual_data_flag
  65.      3, // split_transform_flag
  66.      2, // cbf_luma
  67.      4, // cbf_cb, cbf_cr
  68.      2, // transform_skip_flag[][]
  69.      2, // explicit_rdpcm_flag[][]
  70.      2, // explicit_rdpcm_dir_flag[][]
  71.     18, // last_significant_coeff_x_prefix
  72.     18, // last_significant_coeff_y_prefix
  73.      0, // last_significant_coeff_x_suffix
  74.      0, // last_significant_coeff_y_suffix
  75.      4, // significant_coeff_group_flag
  76.     44, // significant_coeff_flag
  77.     24, // coeff_abs_level_greater1_flag
  78.      6, // coeff_abs_level_greater2_flag
  79.      0, // coeff_abs_level_remaining
  80.      0, // coeff_sign_flag
  81.      8, // log2_res_scale_abs
  82.      2, // res_scale_sign_flag
  83.      1, // cu_chroma_qp_offset_flag
  84.      1, // cu_chroma_qp_offset_idx
  85. };
  86.  
  87. /**
  88.  * Offset to ctxIdx 0 in init_values and states, indexed by SyntaxElement.
  89.  */
  90. static const int elem_offset[sizeof(num_bins_in_se)] = {
  91.     0, // sao_merge_flag
  92.     1, // sao_type_idx
  93.     2, // sao_eo_class
  94.     2, // sao_band_position
  95.     2, // sao_offset_abs
  96.     2, // sao_offset_sign
  97.     2, // end_of_slice_flag
  98.     2, // split_coding_unit_flag
  99.     5, // cu_transquant_bypass_flag
  100.     6, // skip_flag
  101.     9, // cu_qp_delta
  102.     12, // pred_mode
  103.     13, // part_mode
  104.     17, // pcm_flag
  105.     17, // prev_intra_luma_pred_mode
  106.     18, // mpm_idx
  107.     18, // rem_intra_luma_pred_mode
  108.     18, // intra_chroma_pred_mode
  109.     20, // merge_flag
  110.     21, // merge_idx
  111.     22, // inter_pred_idc
  112.     27, // ref_idx_l0
  113.     29, // ref_idx_l1
  114.     31, // abs_mvd_greater0_flag
  115.     33, // abs_mvd_greater1_flag
  116.     35, // abs_mvd_minus2
  117.     35, // mvd_sign_flag
  118.     35, // mvp_lx_flag
  119.     36, // no_residual_data_flag
  120.     37, // split_transform_flag
  121.     40, // cbf_luma
  122.     42, // cbf_cb, cbf_cr
  123.     46, // transform_skip_flag[][]
  124.     48, // explicit_rdpcm_flag[][]
  125.     50, // explicit_rdpcm_dir_flag[][]
  126.     52, // last_significant_coeff_x_prefix
  127.     70, // last_significant_coeff_y_prefix
  128.     88, // last_significant_coeff_x_suffix
  129.     88, // last_significant_coeff_y_suffix
  130.     88, // significant_coeff_group_flag
  131.     92, // significant_coeff_flag
  132.     136, // coeff_abs_level_greater1_flag
  133.     160, // coeff_abs_level_greater2_flag
  134.     166, // coeff_abs_level_remaining
  135.     166, // coeff_sign_flag
  136.     166, // log2_res_scale_abs
  137.     174, // res_scale_sign_flag
  138.     176, // cu_chroma_qp_offset_flag
  139.     177, // cu_chroma_qp_offset_idx
  140. };
  141.  
  142. #define CNU 154
  143. /**
  144.  * Indexed by init_type
  145.  */
  146. static const uint8_t init_values[3][HEVC_CONTEXTS] = {
  147.     { // sao_merge_flag
  148.       153,
  149.       // sao_type_idx
  150.       200,
  151.       // split_coding_unit_flag
  152.       139, 141, 157,
  153.       // cu_transquant_bypass_flag
  154.       154,
  155.       // skip_flag
  156.       CNU, CNU, CNU,
  157.       // cu_qp_delta
  158.       154, 154, 154,
  159.       // pred_mode
  160.       CNU,
  161.       // part_mode
  162.       184, CNU, CNU, CNU,
  163.       // prev_intra_luma_pred_mode
  164.       184,
  165.       // intra_chroma_pred_mode
  166.       63, 139,
  167.       // merge_flag
  168.       CNU,
  169.       // merge_idx
  170.       CNU,
  171.       // inter_pred_idc
  172.       CNU, CNU, CNU, CNU, CNU,
  173.       // ref_idx_l0
  174.       CNU, CNU,
  175.       // ref_idx_l1
  176.       CNU, CNU,
  177.       // abs_mvd_greater1_flag
  178.       CNU, CNU,
  179.       // abs_mvd_greater1_flag
  180.       CNU, CNU,
  181.       // mvp_lx_flag
  182.       CNU,
  183.       // no_residual_data_flag
  184.       CNU,
  185.       // split_transform_flag
  186.       153, 138, 138,
  187.       // cbf_luma
  188.       111, 141,
  189.       // cbf_cb, cbf_cr
  190.       94, 138, 182, 154,
  191.       // transform_skip_flag
  192.       139, 139,
  193.       // explicit_rdpcm_flag
  194.       139, 139,
  195.       // explicit_rdpcm_dir_flag
  196.       139, 139,
  197.       // last_significant_coeff_x_prefix
  198.       110, 110, 124, 125, 140, 153, 125, 127, 140, 109, 111, 143, 127, 111,
  199.        79, 108, 123,  63,
  200.       // last_significant_coeff_y_prefix
  201.       110, 110, 124, 125, 140, 153, 125, 127, 140, 109, 111, 143, 127, 111,
  202.        79, 108, 123,  63,
  203.       // significant_coeff_group_flag
  204.       91, 171, 134, 141,
  205.       // significant_coeff_flag
  206.       111, 111, 125, 110, 110,  94, 124, 108, 124, 107, 125, 141, 179, 153,
  207.       125, 107, 125, 141, 179, 153, 125, 107, 125, 141, 179, 153, 125, 140,
  208.       139, 182, 182, 152, 136, 152, 136, 153, 136, 139, 111, 136, 139, 111,
  209.       141, 111,
  210.       // coeff_abs_level_greater1_flag
  211.       140,  92, 137, 138, 140, 152, 138, 139, 153,  74, 149,  92, 139, 107,
  212.       122, 152, 140, 179, 166, 182, 140, 227, 122, 197,
  213.       // coeff_abs_level_greater2_flag
  214.       138, 153, 136, 167, 152, 152,
  215.       // log2_res_scale_abs
  216.       154, 154, 154, 154, 154, 154, 154, 154,
  217.       // res_scale_sign_flag
  218.       154, 154,
  219.       // cu_chroma_qp_offset_flag
  220.       154,
  221.       // cu_chroma_qp_offset_idx
  222.       154,
  223.     },
  224.     { // sao_merge_flag
  225.       153,
  226.       // sao_type_idx
  227.       185,
  228.       // split_coding_unit_flag
  229.       107, 139, 126,
  230.       // cu_transquant_bypass_flag
  231.       154,
  232.       // skip_flag
  233.       197, 185, 201,
  234.       // cu_qp_delta
  235.       154, 154, 154,
  236.       // pred_mode
  237.       149,
  238.       // part_mode
  239.       154, 139, 154, 154,
  240.       // prev_intra_luma_pred_mode
  241.       154,
  242.       // intra_chroma_pred_mode
  243.       152, 139,
  244.       // merge_flag
  245.       110,
  246.       // merge_idx
  247.       122,
  248.       // inter_pred_idc
  249.       95, 79, 63, 31, 31,
  250.       // ref_idx_l0
  251.       153, 153,
  252.       // ref_idx_l1
  253.       153, 153,
  254.       // abs_mvd_greater1_flag
  255.       140, 198,
  256.       // abs_mvd_greater1_flag
  257.       140, 198,
  258.       // mvp_lx_flag
  259.       168,
  260.       // no_residual_data_flag
  261.       79,
  262.       // split_transform_flag
  263.       124, 138, 94,
  264.       // cbf_luma
  265.       153, 111,
  266.       // cbf_cb, cbf_cr
  267.       149, 107, 167, 154,
  268.       // transform_skip_flag
  269.       139, 139,
  270.       // explicit_rdpcm_flag
  271.       139, 139,
  272.       // explicit_rdpcm_dir_flag
  273.       139, 139,
  274.       // last_significant_coeff_x_prefix
  275.       125, 110,  94, 110,  95,  79, 125, 111, 110,  78, 110, 111, 111,  95,
  276.        94, 108, 123, 108,
  277.       // last_significant_coeff_y_prefix
  278.       125, 110,  94, 110,  95,  79, 125, 111, 110,  78, 110, 111, 111,  95,
  279.        94, 108, 123, 108,
  280.       // significant_coeff_group_flag
  281.       121, 140, 61, 154,
  282.       // significant_coeff_flag
  283.       155, 154, 139, 153, 139, 123, 123,  63, 153, 166, 183, 140, 136, 153,
  284.       154, 166, 183, 140, 136, 153, 154, 166, 183, 140, 136, 153, 154, 170,
  285.       153, 123, 123, 107, 121, 107, 121, 167, 151, 183, 140, 151, 183, 140,
  286.       140, 140,
  287.       // coeff_abs_level_greater1_flag
  288.       154, 196, 196, 167, 154, 152, 167, 182, 182, 134, 149, 136, 153, 121,
  289.       136, 137, 169, 194, 166, 167, 154, 167, 137, 182,
  290.       // coeff_abs_level_greater2_flag
  291.       107, 167, 91, 122, 107, 167,
  292.       // log2_res_scale_abs
  293.       154, 154, 154, 154, 154, 154, 154, 154,
  294.       // res_scale_sign_flag
  295.       154, 154,
  296.       // cu_chroma_qp_offset_flag
  297.       154,
  298.       // cu_chroma_qp_offset_idx
  299.       154,
  300.     },
  301.     { // sao_merge_flag
  302.       153,
  303.       // sao_type_idx
  304.       160,
  305.       // split_coding_unit_flag
  306.       107, 139, 126,
  307.       // cu_transquant_bypass_flag
  308.       154,
  309.       // skip_flag
  310.       197, 185, 201,
  311.       // cu_qp_delta
  312.       154, 154, 154,
  313.       // pred_mode
  314.       134,
  315.       // part_mode
  316.       154, 139, 154, 154,
  317.       // prev_intra_luma_pred_mode
  318.       183,
  319.       // intra_chroma_pred_mode
  320.       152, 139,
  321.       // merge_flag
  322.       154,
  323.       // merge_idx
  324.       137,
  325.       // inter_pred_idc
  326.       95, 79, 63, 31, 31,
  327.       // ref_idx_l0
  328.       153, 153,
  329.       // ref_idx_l1
  330.       153, 153,
  331.       // abs_mvd_greater1_flag
  332.       169, 198,
  333.       // abs_mvd_greater1_flag
  334.       169, 198,
  335.       // mvp_lx_flag
  336.       168,
  337.       // no_residual_data_flag
  338.       79,
  339.       // split_transform_flag
  340.       224, 167, 122,
  341.       // cbf_luma
  342.       153, 111,
  343.       // cbf_cb, cbf_cr
  344.       149, 92, 167, 154,
  345.       // transform_skip_flag
  346.       139, 139,
  347.       // explicit_rdpcm_flag
  348.       139, 139,
  349.       // explicit_rdpcm_dir_flag
  350.       139, 139,
  351.       // last_significant_coeff_x_prefix
  352.       125, 110, 124, 110,  95,  94, 125, 111, 111,  79, 125, 126, 111, 111,
  353.        79, 108, 123,  93,
  354.       // last_significant_coeff_y_prefix
  355.       125, 110, 124, 110,  95,  94, 125, 111, 111,  79, 125, 126, 111, 111,
  356.        79, 108, 123,  93,
  357.       // significant_coeff_group_flag
  358.       121, 140, 61, 154,
  359.       // significant_coeff_flag
  360.       170, 154, 139, 153, 139, 123, 123,  63, 124, 166, 183, 140, 136, 153,
  361.       154, 166, 183, 140, 136, 153, 154, 166, 183, 140, 136, 153, 154, 170,
  362.       153, 138, 138, 122, 121, 122, 121, 167, 151, 183, 140, 151, 183, 140,
  363.       140, 140,
  364.       // coeff_abs_level_greater1_flag
  365.       154, 196, 167, 167, 154, 152, 167, 182, 182, 134, 149, 136, 153, 121,
  366.       136, 122, 169, 208, 166, 167, 154, 152, 167, 182,
  367.       // coeff_abs_level_greater2_flag
  368.       107, 167, 91, 107, 107, 167,
  369.       // log2_res_scale_abs
  370.       154, 154, 154, 154, 154, 154, 154, 154,
  371.       // res_scale_sign_flag
  372.       154, 154,
  373.       // cu_chroma_qp_offset_flag
  374.       154,
  375.       // cu_chroma_qp_offset_idx
  376.       154,
  377.     },
  378. };
  379.  
  380. static const uint8_t scan_1x1[1] = {
  381.     0,
  382. };
  383.  
  384. static const uint8_t horiz_scan2x2_x[4] = {
  385.     0, 1, 0, 1,
  386. };
  387.  
  388. static const uint8_t horiz_scan2x2_y[4] = {
  389.     0, 0, 1, 1
  390. };
  391.  
  392. static const uint8_t horiz_scan4x4_x[16] = {
  393.     0, 1, 2, 3,
  394.     0, 1, 2, 3,
  395.     0, 1, 2, 3,
  396.     0, 1, 2, 3,
  397. };
  398.  
  399. static const uint8_t horiz_scan4x4_y[16] = {
  400.     0, 0, 0, 0,
  401.     1, 1, 1, 1,
  402.     2, 2, 2, 2,
  403.     3, 3, 3, 3,
  404. };
  405.  
  406. static const uint8_t horiz_scan8x8_inv[8][8] = {
  407.     {  0,  1,  2,  3, 16, 17, 18, 19, },
  408.     {  4,  5,  6,  7, 20, 21, 22, 23, },
  409.     {  8,  9, 10, 11, 24, 25, 26, 27, },
  410.     { 12, 13, 14, 15, 28, 29, 30, 31, },
  411.     { 32, 33, 34, 35, 48, 49, 50, 51, },
  412.     { 36, 37, 38, 39, 52, 53, 54, 55, },
  413.     { 40, 41, 42, 43, 56, 57, 58, 59, },
  414.     { 44, 45, 46, 47, 60, 61, 62, 63, },
  415. };
  416.  
  417. static const uint8_t diag_scan2x2_x[4] = {
  418.     0, 0, 1, 1,
  419. };
  420.  
  421. static const uint8_t diag_scan2x2_y[4] = {
  422.     0, 1, 0, 1,
  423. };
  424.  
  425. static const uint8_t diag_scan2x2_inv[2][2] = {
  426.     { 0, 2, },
  427.     { 1, 3, },
  428. };
  429.  
  430. static const uint8_t diag_scan4x4_inv[4][4] = {
  431.     { 0,  2,  5,  9, },
  432.     { 1,  4,  8, 12, },
  433.     { 3,  7, 11, 14, },
  434.     { 6, 10, 13, 15, },
  435. };
  436.  
  437. static const uint8_t diag_scan8x8_inv[8][8] = {
  438.     {  0,  2,  5,  9, 14, 20, 27, 35, },
  439.     {  1,  4,  8, 13, 19, 26, 34, 42, },
  440.     {  3,  7, 12, 18, 25, 33, 41, 48, },
  441.     {  6, 11, 17, 24, 32, 40, 47, 53, },
  442.     { 10, 16, 23, 31, 39, 46, 52, 57, },
  443.     { 15, 22, 30, 38, 45, 51, 56, 60, },
  444.     { 21, 29, 37, 44, 50, 55, 59, 62, },
  445.     { 28, 36, 43, 49, 54, 58, 61, 63, },
  446. };
  447.  
  448. void ff_hevc_save_states(HEVCContext *s, int ctb_addr_ts)
  449. {
  450.     if (s->ps.pps->entropy_coding_sync_enabled_flag &&
  451.         (ctb_addr_ts % s->ps.sps->ctb_width == 2 ||
  452.          (s->ps.sps->ctb_width == 2 &&
  453.           ctb_addr_ts % s->ps.sps->ctb_width == 0))) {
  454.         memcpy(s->cabac_state, s->HEVClc->cabac_state, HEVC_CONTEXTS);
  455.     }
  456. }
  457.  
  458. static void load_states(HEVCContext *s)
  459. {
  460.     memcpy(s->HEVClc->cabac_state, s->cabac_state, HEVC_CONTEXTS);
  461. }
  462.  
  463. static void cabac_reinit(HEVCLocalContext *lc)
  464. {
  465.     skip_bytes(&lc->cc, 0);
  466. }
  467.  
  468. static void cabac_init_decoder(HEVCContext *s)
  469. {
  470.     GetBitContext *gb = &s->HEVClc->gb;
  471.     skip_bits(gb, 1);
  472.     align_get_bits(gb);
  473.     ff_init_cabac_decoder(&s->HEVClc->cc,
  474.                           gb->buffer + get_bits_count(gb) / 8,
  475.                           (get_bits_left(gb) + 7) / 8);
  476. }
  477.  
  478. static void cabac_init_state(HEVCContext *s)
  479. {
  480.     int init_type = 2 - s->sh.slice_type;
  481.     int i;
  482.  
  483.     if (s->sh.cabac_init_flag && s->sh.slice_type != I_SLICE)
  484.         init_type ^= 3;
  485.  
  486.     for (i = 0; i < HEVC_CONTEXTS; i++) {
  487.         int init_value = init_values[init_type][i];
  488.         int m = (init_value >> 4) * 5 - 45;
  489.         int n = ((init_value & 15) << 3) - 16;
  490.         int pre = 2 * (((m * av_clip(s->sh.slice_qp, 0, 51)) >> 4) + n) - 127;
  491.  
  492.         pre ^= pre >> 31;
  493.         if (pre > 124)
  494.             pre = 124 + (pre & 1);
  495.         s->HEVClc->cabac_state[i] = pre;
  496.     }
  497.  
  498.     for (i = 0; i < 4; i++)
  499.         s->HEVClc->stat_coeff[i] = 0;
  500. }
  501.  
  502. void ff_hevc_cabac_init(HEVCContext *s, int ctb_addr_ts)
  503. {
  504.     if (ctb_addr_ts == s->ps.pps->ctb_addr_rs_to_ts[s->sh.slice_ctb_addr_rs]) {
  505.         cabac_init_decoder(s);
  506.         if (s->sh.dependent_slice_segment_flag == 0 ||
  507.             (s->ps.pps->tiles_enabled_flag &&
  508.              s->ps.pps->tile_id[ctb_addr_ts] != s->ps.pps->tile_id[ctb_addr_ts - 1]))
  509.             cabac_init_state(s);
  510.  
  511.         if (!s->sh.first_slice_in_pic_flag &&
  512.             s->ps.pps->entropy_coding_sync_enabled_flag) {
  513.             if (ctb_addr_ts % s->ps.sps->ctb_width == 0) {
  514.                 if (s->ps.sps->ctb_width == 1)
  515.                     cabac_init_state(s);
  516.                 else if (s->sh.dependent_slice_segment_flag == 1)
  517.                     load_states(s);
  518.             }
  519.         }
  520.     } else {
  521.         if (s->ps.pps->tiles_enabled_flag &&
  522.             s->ps.pps->tile_id[ctb_addr_ts] != s->ps.pps->tile_id[ctb_addr_ts - 1]) {
  523.             if (s->threads_number == 1)
  524.                 cabac_reinit(s->HEVClc);
  525.             else
  526.                 cabac_init_decoder(s);
  527.             cabac_init_state(s);
  528.         }
  529.         if (s->ps.pps->entropy_coding_sync_enabled_flag) {
  530.             if (ctb_addr_ts % s->ps.sps->ctb_width == 0) {
  531.                 get_cabac_terminate(&s->HEVClc->cc);
  532.                 if (s->threads_number == 1)
  533.                     cabac_reinit(s->HEVClc);
  534.                 else
  535.                     cabac_init_decoder(s);
  536.  
  537.                 if (s->ps.sps->ctb_width == 1)
  538.                     cabac_init_state(s);
  539.                 else
  540.                     load_states(s);
  541.             }
  542.         }
  543.     }
  544. }
  545.  
  546. #define GET_CABAC(ctx) get_cabac(&s->HEVClc->cc, &s->HEVClc->cabac_state[ctx])
  547.  
  548. int ff_hevc_sao_merge_flag_decode(HEVCContext *s)
  549. {
  550.     return GET_CABAC(elem_offset[SAO_MERGE_FLAG]);
  551. }
  552.  
  553. int ff_hevc_sao_type_idx_decode(HEVCContext *s)
  554. {
  555.     if (!GET_CABAC(elem_offset[SAO_TYPE_IDX]))
  556.         return 0;
  557.  
  558.     if (!get_cabac_bypass(&s->HEVClc->cc))
  559.         return SAO_BAND;
  560.     return SAO_EDGE;
  561. }
  562.  
  563. int ff_hevc_sao_band_position_decode(HEVCContext *s)
  564. {
  565.     int i;
  566.     int value = get_cabac_bypass(&s->HEVClc->cc);
  567.  
  568.     for (i = 0; i < 4; i++)
  569.         value = (value << 1) | get_cabac_bypass(&s->HEVClc->cc);
  570.     return value;
  571. }
  572.  
  573. int ff_hevc_sao_offset_abs_decode(HEVCContext *s)
  574. {
  575.     int i = 0;
  576.     int length = (1 << (FFMIN(s->ps.sps->bit_depth, 10) - 5)) - 1;
  577.  
  578.     while (i < length && get_cabac_bypass(&s->HEVClc->cc))
  579.         i++;
  580.     return i;
  581. }
  582.  
  583. int ff_hevc_sao_offset_sign_decode(HEVCContext *s)
  584. {
  585.     return get_cabac_bypass(&s->HEVClc->cc);
  586. }
  587.  
  588. int ff_hevc_sao_eo_class_decode(HEVCContext *s)
  589. {
  590.     int ret = get_cabac_bypass(&s->HEVClc->cc) << 1;
  591.     ret    |= get_cabac_bypass(&s->HEVClc->cc);
  592.     return ret;
  593. }
  594.  
  595. int ff_hevc_end_of_slice_flag_decode(HEVCContext *s)
  596. {
  597.     return get_cabac_terminate(&s->HEVClc->cc);
  598. }
  599.  
  600. int ff_hevc_cu_transquant_bypass_flag_decode(HEVCContext *s)
  601. {
  602.     return GET_CABAC(elem_offset[CU_TRANSQUANT_BYPASS_FLAG]);
  603. }
  604.  
  605. int ff_hevc_skip_flag_decode(HEVCContext *s, int x0, int y0, int x_cb, int y_cb)
  606. {
  607.     int min_cb_width = s->ps.sps->min_cb_width;
  608.     int inc = 0;
  609.     int x0b = av_mod_uintp2(x0, s->ps.sps->log2_ctb_size);
  610.     int y0b = av_mod_uintp2(y0, s->ps.sps->log2_ctb_size);
  611.  
  612.     if (s->HEVClc->ctb_left_flag || x0b)
  613.         inc = !!SAMPLE_CTB(s->skip_flag, x_cb - 1, y_cb);
  614.     if (s->HEVClc->ctb_up_flag || y0b)
  615.         inc += !!SAMPLE_CTB(s->skip_flag, x_cb, y_cb - 1);
  616.  
  617.     return GET_CABAC(elem_offset[SKIP_FLAG] + inc);
  618. }
  619.  
  620. int ff_hevc_cu_qp_delta_abs(HEVCContext *s)
  621. {
  622.     int prefix_val = 0;
  623.     int suffix_val = 0;
  624.     int inc = 0;
  625.  
  626.     while (prefix_val < 5 && GET_CABAC(elem_offset[CU_QP_DELTA] + inc)) {
  627.         prefix_val++;
  628.         inc = 1;
  629.     }
  630.     if (prefix_val >= 5) {
  631.         int k = 0;
  632.         while (k < CABAC_MAX_BIN && get_cabac_bypass(&s->HEVClc->cc)) {
  633.             suffix_val += 1 << k;
  634.             k++;
  635.         }
  636.         if (k == CABAC_MAX_BIN)
  637.             av_log(s->avctx, AV_LOG_ERROR, "CABAC_MAX_BIN : %d\n", k);
  638.  
  639.         while (k--)
  640.             suffix_val += get_cabac_bypass(&s->HEVClc->cc) << k;
  641.     }
  642.     return prefix_val + suffix_val;
  643. }
  644.  
  645. int ff_hevc_cu_qp_delta_sign_flag(HEVCContext *s)
  646. {
  647.     return get_cabac_bypass(&s->HEVClc->cc);
  648. }
  649.  
  650. int ff_hevc_cu_chroma_qp_offset_flag(HEVCContext *s)
  651. {
  652.     return GET_CABAC(elem_offset[CU_CHROMA_QP_OFFSET_FLAG]);
  653. }
  654.  
  655. int ff_hevc_cu_chroma_qp_offset_idx(HEVCContext *s)
  656. {
  657.     int c_max= FFMAX(5, s->ps.pps->chroma_qp_offset_list_len_minus1);
  658.     int i = 0;
  659.  
  660.     while (i < c_max && GET_CABAC(elem_offset[CU_CHROMA_QP_OFFSET_IDX]))
  661.         i++;
  662.  
  663.     return i;
  664. }
  665.  
  666. int ff_hevc_pred_mode_decode(HEVCContext *s)
  667. {
  668.     return GET_CABAC(elem_offset[PRED_MODE_FLAG]);
  669. }
  670.  
  671. int ff_hevc_split_coding_unit_flag_decode(HEVCContext *s, int ct_depth, int x0, int y0)
  672. {
  673.     int inc = 0, depth_left = 0, depth_top = 0;
  674.     int x0b  = av_mod_uintp2(x0, s->ps.sps->log2_ctb_size);
  675.     int y0b  = av_mod_uintp2(y0, s->ps.sps->log2_ctb_size);
  676.     int x_cb = x0 >> s->ps.sps->log2_min_cb_size;
  677.     int y_cb = y0 >> s->ps.sps->log2_min_cb_size;
  678.  
  679.     if (s->HEVClc->ctb_left_flag || x0b)
  680.         depth_left = s->tab_ct_depth[(y_cb) * s->ps.sps->min_cb_width + x_cb - 1];
  681.     if (s->HEVClc->ctb_up_flag || y0b)
  682.         depth_top = s->tab_ct_depth[(y_cb - 1) * s->ps.sps->min_cb_width + x_cb];
  683.  
  684.     inc += (depth_left > ct_depth);
  685.     inc += (depth_top  > ct_depth);
  686.  
  687.     return GET_CABAC(elem_offset[SPLIT_CODING_UNIT_FLAG] + inc);
  688. }
  689.  
  690. int ff_hevc_part_mode_decode(HEVCContext *s, int log2_cb_size)
  691. {
  692.     if (GET_CABAC(elem_offset[PART_MODE])) // 1
  693.         return PART_2Nx2N;
  694.     if (log2_cb_size == s->ps.sps->log2_min_cb_size) {
  695.         if (s->HEVClc->cu.pred_mode == MODE_INTRA) // 0
  696.             return PART_NxN;
  697.         if (GET_CABAC(elem_offset[PART_MODE] + 1)) // 01
  698.             return PART_2NxN;
  699.         if (log2_cb_size == 3) // 00
  700.             return PART_Nx2N;
  701.         if (GET_CABAC(elem_offset[PART_MODE] + 2)) // 001
  702.             return PART_Nx2N;
  703.         return PART_NxN; // 000
  704.     }
  705.  
  706.     if (!s->ps.sps->amp_enabled_flag) {
  707.         if (GET_CABAC(elem_offset[PART_MODE] + 1)) // 01
  708.             return PART_2NxN;
  709.         return PART_Nx2N;
  710.     }
  711.  
  712.     if (GET_CABAC(elem_offset[PART_MODE] + 1)) { // 01X, 01XX
  713.         if (GET_CABAC(elem_offset[PART_MODE] + 3)) // 011
  714.             return PART_2NxN;
  715.         if (get_cabac_bypass(&s->HEVClc->cc)) // 0101
  716.             return PART_2NxnD;
  717.         return PART_2NxnU; // 0100
  718.     }
  719.  
  720.     if (GET_CABAC(elem_offset[PART_MODE] + 3)) // 001
  721.         return PART_Nx2N;
  722.     if (get_cabac_bypass(&s->HEVClc->cc)) // 0001
  723.         return PART_nRx2N;
  724.     return PART_nLx2N;  // 0000
  725. }
  726.  
  727. int ff_hevc_pcm_flag_decode(HEVCContext *s)
  728. {
  729.     return get_cabac_terminate(&s->HEVClc->cc);
  730. }
  731.  
  732. int ff_hevc_prev_intra_luma_pred_flag_decode(HEVCContext *s)
  733. {
  734.     return GET_CABAC(elem_offset[PREV_INTRA_LUMA_PRED_FLAG]);
  735. }
  736.  
  737. int ff_hevc_mpm_idx_decode(HEVCContext *s)
  738. {
  739.     int i = 0;
  740.     while (i < 2 && get_cabac_bypass(&s->HEVClc->cc))
  741.         i++;
  742.     return i;
  743. }
  744.  
  745. int ff_hevc_rem_intra_luma_pred_mode_decode(HEVCContext *s)
  746. {
  747.     int i;
  748.     int value = get_cabac_bypass(&s->HEVClc->cc);
  749.  
  750.     for (i = 0; i < 4; i++)
  751.         value = (value << 1) | get_cabac_bypass(&s->HEVClc->cc);
  752.     return value;
  753. }
  754.  
  755. int ff_hevc_intra_chroma_pred_mode_decode(HEVCContext *s)
  756. {
  757.     int ret;
  758.     if (!GET_CABAC(elem_offset[INTRA_CHROMA_PRED_MODE]))
  759.         return 4;
  760.  
  761.     ret  = get_cabac_bypass(&s->HEVClc->cc) << 1;
  762.     ret |= get_cabac_bypass(&s->HEVClc->cc);
  763.     return ret;
  764. }
  765.  
  766. int ff_hevc_merge_idx_decode(HEVCContext *s)
  767. {
  768.     int i = GET_CABAC(elem_offset[MERGE_IDX]);
  769.  
  770.     if (i != 0) {
  771.         while (i < s->sh.max_num_merge_cand-1 && get_cabac_bypass(&s->HEVClc->cc))
  772.             i++;
  773.     }
  774.     return i;
  775. }
  776.  
  777. int ff_hevc_merge_flag_decode(HEVCContext *s)
  778. {
  779.     return GET_CABAC(elem_offset[MERGE_FLAG]);
  780. }
  781.  
  782. int ff_hevc_inter_pred_idc_decode(HEVCContext *s, int nPbW, int nPbH)
  783. {
  784.     if (nPbW + nPbH == 12)
  785.         return GET_CABAC(elem_offset[INTER_PRED_IDC] + 4);
  786.     if (GET_CABAC(elem_offset[INTER_PRED_IDC] + s->HEVClc->ct_depth))
  787.         return PRED_BI;
  788.  
  789.     return GET_CABAC(elem_offset[INTER_PRED_IDC] + 4);
  790. }
  791.  
  792. int ff_hevc_ref_idx_lx_decode(HEVCContext *s, int num_ref_idx_lx)
  793. {
  794.     int i = 0;
  795.     int max = num_ref_idx_lx - 1;
  796.     int max_ctx = FFMIN(max, 2);
  797.  
  798.     while (i < max_ctx && GET_CABAC(elem_offset[REF_IDX_L0] + i))
  799.         i++;
  800.     if (i == 2) {
  801.         while (i < max && get_cabac_bypass(&s->HEVClc->cc))
  802.             i++;
  803.     }
  804.  
  805.     return i;
  806. }
  807.  
  808. int ff_hevc_mvp_lx_flag_decode(HEVCContext *s)
  809. {
  810.     return GET_CABAC(elem_offset[MVP_LX_FLAG]);
  811. }
  812.  
  813. int ff_hevc_no_residual_syntax_flag_decode(HEVCContext *s)
  814. {
  815.     return GET_CABAC(elem_offset[NO_RESIDUAL_DATA_FLAG]);
  816. }
  817.  
  818. static av_always_inline int abs_mvd_greater0_flag_decode(HEVCContext *s)
  819. {
  820.     return GET_CABAC(elem_offset[ABS_MVD_GREATER0_FLAG]);
  821. }
  822.  
  823. static av_always_inline int abs_mvd_greater1_flag_decode(HEVCContext *s)
  824. {
  825.     return GET_CABAC(elem_offset[ABS_MVD_GREATER1_FLAG] + 1);
  826. }
  827.  
  828. static av_always_inline int mvd_decode(HEVCContext *s)
  829. {
  830.     int ret = 2;
  831.     int k = 1;
  832.  
  833.     while (k < CABAC_MAX_BIN && get_cabac_bypass(&s->HEVClc->cc)) {
  834.         ret += 1U << k;
  835.         k++;
  836.     }
  837.     if (k == CABAC_MAX_BIN) {
  838.         av_log(s->avctx, AV_LOG_ERROR, "CABAC_MAX_BIN : %d\n", k);
  839.         return 0;
  840.     }
  841.     while (k--)
  842.         ret += get_cabac_bypass(&s->HEVClc->cc) << k;
  843.     return get_cabac_bypass_sign(&s->HEVClc->cc, -ret);
  844. }
  845.  
  846. static av_always_inline int mvd_sign_flag_decode(HEVCContext *s)
  847. {
  848.     return get_cabac_bypass_sign(&s->HEVClc->cc, -1);
  849. }
  850.  
  851. int ff_hevc_split_transform_flag_decode(HEVCContext *s, int log2_trafo_size)
  852. {
  853.     return GET_CABAC(elem_offset[SPLIT_TRANSFORM_FLAG] + 5 - log2_trafo_size);
  854. }
  855.  
  856. int ff_hevc_cbf_cb_cr_decode(HEVCContext *s, int trafo_depth)
  857. {
  858.     return GET_CABAC(elem_offset[CBF_CB_CR] + trafo_depth);
  859. }
  860.  
  861. int ff_hevc_cbf_luma_decode(HEVCContext *s, int trafo_depth)
  862. {
  863.     return GET_CABAC(elem_offset[CBF_LUMA] + !trafo_depth);
  864. }
  865.  
  866. static int hevc_transform_skip_flag_decode(HEVCContext *s, int c_idx)
  867. {
  868.     return GET_CABAC(elem_offset[TRANSFORM_SKIP_FLAG] + !!c_idx);
  869. }
  870.  
  871. static int explicit_rdpcm_flag_decode(HEVCContext *s, int c_idx)
  872. {
  873.     return GET_CABAC(elem_offset[EXPLICIT_RDPCM_FLAG] + !!c_idx);
  874. }
  875.  
  876. static int explicit_rdpcm_dir_flag_decode(HEVCContext *s, int c_idx)
  877. {
  878.     return GET_CABAC(elem_offset[EXPLICIT_RDPCM_DIR_FLAG] + !!c_idx);
  879. }
  880.  
  881. int ff_hevc_log2_res_scale_abs(HEVCContext *s, int idx) {
  882.     int i =0;
  883.  
  884.     while (i < 4 && GET_CABAC(elem_offset[LOG2_RES_SCALE_ABS] + 4 * idx + i))
  885.         i++;
  886.  
  887.     return i;
  888. }
  889.  
  890. int ff_hevc_res_scale_sign_flag(HEVCContext *s, int idx) {
  891.     return GET_CABAC(elem_offset[RES_SCALE_SIGN_FLAG] + idx);
  892. }
  893.  
  894. static av_always_inline void last_significant_coeff_xy_prefix_decode(HEVCContext *s, int c_idx,
  895.                                                    int log2_size, int *last_scx_prefix, int *last_scy_prefix)
  896. {
  897.     int i = 0;
  898.     int max = (log2_size << 1) - 1;
  899.     int ctx_offset, ctx_shift;
  900.  
  901.     if (!c_idx) {
  902.         ctx_offset = 3 * (log2_size - 2)  + ((log2_size - 1) >> 2);
  903.         ctx_shift = (log2_size + 1) >> 2;
  904.     } else {
  905.         ctx_offset = 15;
  906.         ctx_shift = log2_size - 2;
  907.     }
  908.     while (i < max &&
  909.            GET_CABAC(elem_offset[LAST_SIGNIFICANT_COEFF_X_PREFIX] + (i >> ctx_shift) + ctx_offset))
  910.         i++;
  911.     *last_scx_prefix = i;
  912.  
  913.     i = 0;
  914.     while (i < max &&
  915.            GET_CABAC(elem_offset[LAST_SIGNIFICANT_COEFF_Y_PREFIX] + (i >> ctx_shift) + ctx_offset))
  916.         i++;
  917.     *last_scy_prefix = i;
  918. }
  919.  
  920. static av_always_inline int last_significant_coeff_suffix_decode(HEVCContext *s,
  921.                                                  int last_significant_coeff_prefix)
  922. {
  923.     int i;
  924.     int length = (last_significant_coeff_prefix >> 1) - 1;
  925.     int value = get_cabac_bypass(&s->HEVClc->cc);
  926.  
  927.     for (i = 1; i < length; i++)
  928.         value = (value << 1) | get_cabac_bypass(&s->HEVClc->cc);
  929.     return value;
  930. }
  931.  
  932. static av_always_inline int significant_coeff_group_flag_decode(HEVCContext *s, int c_idx, int ctx_cg)
  933. {
  934.     int inc;
  935.  
  936.     inc = FFMIN(ctx_cg, 1) + (c_idx>0 ? 2 : 0);
  937.  
  938.     return GET_CABAC(elem_offset[SIGNIFICANT_COEFF_GROUP_FLAG] + inc);
  939. }
  940. static av_always_inline int significant_coeff_flag_decode(HEVCContext *s, int x_c, int y_c,
  941.                                            int offset, const uint8_t *ctx_idx_map)
  942. {
  943.     int inc = ctx_idx_map[(y_c << 2) + x_c] + offset;
  944.     return GET_CABAC(elem_offset[SIGNIFICANT_COEFF_FLAG] + inc);
  945. }
  946.  
  947. static av_always_inline int significant_coeff_flag_decode_0(HEVCContext *s, int c_idx, int offset)
  948. {
  949.     return GET_CABAC(elem_offset[SIGNIFICANT_COEFF_FLAG] + offset);
  950. }
  951.  
  952. static av_always_inline int coeff_abs_level_greater1_flag_decode(HEVCContext *s, int c_idx, int inc)
  953. {
  954.  
  955.     if (c_idx > 0)
  956.         inc += 16;
  957.  
  958.     return GET_CABAC(elem_offset[COEFF_ABS_LEVEL_GREATER1_FLAG] + inc);
  959. }
  960.  
  961. static av_always_inline int coeff_abs_level_greater2_flag_decode(HEVCContext *s, int c_idx, int inc)
  962. {
  963.     if (c_idx > 0)
  964.         inc += 4;
  965.  
  966.     return GET_CABAC(elem_offset[COEFF_ABS_LEVEL_GREATER2_FLAG] + inc);
  967. }
  968.  
  969. static av_always_inline int coeff_abs_level_remaining_decode(HEVCContext *s, int rc_rice_param)
  970. {
  971.     int prefix = 0;
  972.     int suffix = 0;
  973.     int last_coeff_abs_level_remaining;
  974.     int i;
  975.  
  976.     while (prefix < CABAC_MAX_BIN && get_cabac_bypass(&s->HEVClc->cc))
  977.         prefix++;
  978.     if (prefix == CABAC_MAX_BIN) {
  979.         av_log(s->avctx, AV_LOG_ERROR, "CABAC_MAX_BIN : %d\n", prefix);
  980.         return 0;
  981.     }
  982.     if (prefix < 3) {
  983.         for (i = 0; i < rc_rice_param; i++)
  984.             suffix = (suffix << 1) | get_cabac_bypass(&s->HEVClc->cc);
  985.         last_coeff_abs_level_remaining = (prefix << rc_rice_param) + suffix;
  986.     } else {
  987.         int prefix_minus3 = prefix - 3;
  988.         for (i = 0; i < prefix_minus3 + rc_rice_param; i++)
  989.             suffix = (suffix << 1) | get_cabac_bypass(&s->HEVClc->cc);
  990.         last_coeff_abs_level_remaining = (((1 << prefix_minus3) + 3 - 1)
  991.                                               << rc_rice_param) + suffix;
  992.     }
  993.     return last_coeff_abs_level_remaining;
  994. }
  995.  
  996. static av_always_inline int coeff_sign_flag_decode(HEVCContext *s, uint8_t nb)
  997. {
  998.     int i;
  999.     int ret = 0;
  1000.  
  1001.     for (i = 0; i < nb; i++)
  1002.         ret = (ret << 1) | get_cabac_bypass(&s->HEVClc->cc);
  1003.     return ret;
  1004. }
  1005.  
  1006. void ff_hevc_hls_residual_coding(HEVCContext *s, int x0, int y0,
  1007.                                 int log2_trafo_size, enum ScanType scan_idx,
  1008.                                 int c_idx)
  1009. {
  1010. #define GET_COORD(offset, n)                                    \
  1011.     do {                                                        \
  1012.         x_c = (x_cg << 2) + scan_x_off[n];                      \
  1013.         y_c = (y_cg << 2) + scan_y_off[n];                      \
  1014.     } while (0)
  1015.     HEVCLocalContext *lc = s->HEVClc;
  1016.     int transform_skip_flag = 0;
  1017.  
  1018.     int last_significant_coeff_x, last_significant_coeff_y;
  1019.     int last_scan_pos;
  1020.     int n_end;
  1021.     int num_coeff = 0;
  1022.     int greater1_ctx = 1;
  1023.  
  1024.     int num_last_subset;
  1025.     int x_cg_last_sig, y_cg_last_sig;
  1026.  
  1027.     const uint8_t *scan_x_cg, *scan_y_cg, *scan_x_off, *scan_y_off;
  1028.  
  1029.     ptrdiff_t stride = s->frame->linesize[c_idx];
  1030.     int hshift = s->ps.sps->hshift[c_idx];
  1031.     int vshift = s->ps.sps->vshift[c_idx];
  1032.     uint8_t *dst = &s->frame->data[c_idx][(y0 >> vshift) * stride +
  1033.                                           ((x0 >> hshift) << s->ps.sps->pixel_shift)];
  1034.     int16_t *coeffs = (int16_t*)(c_idx ? lc->edge_emu_buffer2 : lc->edge_emu_buffer);
  1035.     uint8_t significant_coeff_group_flag[8][8] = {{0}};
  1036.     int explicit_rdpcm_flag = 0;
  1037.     int explicit_rdpcm_dir_flag;
  1038.  
  1039.     int trafo_size = 1 << log2_trafo_size;
  1040.     int i;
  1041.     int qp,shift,add,scale,scale_m;
  1042.     const uint8_t level_scale[] = { 40, 45, 51, 57, 64, 72 };
  1043.     const uint8_t *scale_matrix = NULL;
  1044.     uint8_t dc_scale;
  1045.     int pred_mode_intra = (c_idx == 0) ? lc->tu.intra_pred_mode :
  1046.                                          lc->tu.intra_pred_mode_c;
  1047.  
  1048.     memset(coeffs, 0, trafo_size * trafo_size * sizeof(int16_t));
  1049.  
  1050.     // Derive QP for dequant
  1051.     if (!lc->cu.cu_transquant_bypass_flag) {
  1052.         static const int qp_c[] = { 29, 30, 31, 32, 33, 33, 34, 34, 35, 35, 36, 36, 37, 37 };
  1053.         static const uint8_t rem6[51 + 4 * 6 + 1] = {
  1054.             0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2,
  1055.             3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5,
  1056.             0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3,
  1057.             4, 5, 0, 1, 2, 3, 4, 5, 0, 1
  1058.         };
  1059.  
  1060.         static const uint8_t div6[51 + 4 * 6 + 1] = {
  1061.             0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 3,  3,  3,
  1062.             3, 3, 3, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6,  6,  6,
  1063.             7, 7, 7, 7, 7, 7, 8, 8, 8, 8, 8, 8, 9, 9, 9, 9, 9, 9, 10, 10, 10, 10,
  1064.             10, 10, 11, 11, 11, 11, 11, 11, 12, 12
  1065.         };
  1066.         int qp_y = lc->qp_y;
  1067.  
  1068.         if (s->ps.pps->transform_skip_enabled_flag &&
  1069.             log2_trafo_size <= s->ps.pps->log2_max_transform_skip_block_size) {
  1070.             transform_skip_flag = hevc_transform_skip_flag_decode(s, c_idx);
  1071.         }
  1072.  
  1073.         if (c_idx == 0) {
  1074.             qp = qp_y + s->ps.sps->qp_bd_offset;
  1075.         } else {
  1076.             int qp_i, offset;
  1077.  
  1078.             if (c_idx == 1)
  1079.                 offset = s->ps.pps->cb_qp_offset + s->sh.slice_cb_qp_offset +
  1080.                          lc->tu.cu_qp_offset_cb;
  1081.             else
  1082.                 offset = s->ps.pps->cr_qp_offset + s->sh.slice_cr_qp_offset +
  1083.                          lc->tu.cu_qp_offset_cr;
  1084.  
  1085.             qp_i = av_clip(qp_y + offset, - s->ps.sps->qp_bd_offset, 57);
  1086.             if (s->ps.sps->chroma_format_idc == 1) {
  1087.                 if (qp_i < 30)
  1088.                     qp = qp_i;
  1089.                 else if (qp_i > 43)
  1090.                     qp = qp_i - 6;
  1091.                 else
  1092.                     qp = qp_c[qp_i - 30];
  1093.             } else {
  1094.                 if (qp_i > 51)
  1095.                     qp = 51;
  1096.                 else
  1097.                     qp = qp_i;
  1098.             }
  1099.  
  1100.             qp += s->ps.sps->qp_bd_offset;
  1101.         }
  1102.  
  1103.         shift    = s->ps.sps->bit_depth + log2_trafo_size - 5;
  1104.         add      = 1 << (shift-1);
  1105.         scale    = level_scale[rem6[qp]] << (div6[qp]);
  1106.         scale_m  = 16; // default when no custom scaling lists.
  1107.         dc_scale = 16;
  1108.  
  1109.         if (s->ps.sps->scaling_list_enable_flag && !(transform_skip_flag && log2_trafo_size > 2)) {
  1110.             const ScalingList *sl = s->ps.pps->scaling_list_data_present_flag ?
  1111.             &s->ps.pps->scaling_list : &s->ps.sps->scaling_list;
  1112.             int matrix_id = lc->cu.pred_mode != MODE_INTRA;
  1113.  
  1114.             matrix_id = 3 * matrix_id + c_idx;
  1115.  
  1116.             scale_matrix = sl->sl[log2_trafo_size - 2][matrix_id];
  1117.             if (log2_trafo_size >= 4)
  1118.                 dc_scale = sl->sl_dc[log2_trafo_size - 4][matrix_id];
  1119.         }
  1120.     } else {
  1121.         shift        = 0;
  1122.         add          = 0;
  1123.         scale        = 0;
  1124.         dc_scale     = 0;
  1125.     }
  1126.  
  1127.     if (lc->cu.pred_mode == MODE_INTER && s->ps.sps->explicit_rdpcm_enabled_flag &&
  1128.         (transform_skip_flag || lc->cu.cu_transquant_bypass_flag)) {
  1129.         explicit_rdpcm_flag = explicit_rdpcm_flag_decode(s, c_idx);
  1130.         if (explicit_rdpcm_flag) {
  1131.             explicit_rdpcm_dir_flag = explicit_rdpcm_dir_flag_decode(s, c_idx);
  1132.         }
  1133.     }
  1134.  
  1135.     last_significant_coeff_xy_prefix_decode(s, c_idx, log2_trafo_size,
  1136.                                            &last_significant_coeff_x, &last_significant_coeff_y);
  1137.  
  1138.     if (last_significant_coeff_x > 3) {
  1139.         int suffix = last_significant_coeff_suffix_decode(s, last_significant_coeff_x);
  1140.         last_significant_coeff_x = (1 << ((last_significant_coeff_x >> 1) - 1)) *
  1141.         (2 + (last_significant_coeff_x & 1)) +
  1142.         suffix;
  1143.     }
  1144.  
  1145.     if (last_significant_coeff_y > 3) {
  1146.         int suffix = last_significant_coeff_suffix_decode(s, last_significant_coeff_y);
  1147.         last_significant_coeff_y = (1 << ((last_significant_coeff_y >> 1) - 1)) *
  1148.         (2 + (last_significant_coeff_y & 1)) +
  1149.         suffix;
  1150.     }
  1151.  
  1152.     if (scan_idx == SCAN_VERT)
  1153.         FFSWAP(int, last_significant_coeff_x, last_significant_coeff_y);
  1154.  
  1155.     x_cg_last_sig = last_significant_coeff_x >> 2;
  1156.     y_cg_last_sig = last_significant_coeff_y >> 2;
  1157.  
  1158.     switch (scan_idx) {
  1159.     case SCAN_DIAG: {
  1160.         int last_x_c = last_significant_coeff_x & 3;
  1161.         int last_y_c = last_significant_coeff_y & 3;
  1162.  
  1163.         scan_x_off = ff_hevc_diag_scan4x4_x;
  1164.         scan_y_off = ff_hevc_diag_scan4x4_y;
  1165.         num_coeff = diag_scan4x4_inv[last_y_c][last_x_c];
  1166.         if (trafo_size == 4) {
  1167.             scan_x_cg = scan_1x1;
  1168.             scan_y_cg = scan_1x1;
  1169.         } else if (trafo_size == 8) {
  1170.             num_coeff += diag_scan2x2_inv[y_cg_last_sig][x_cg_last_sig] << 4;
  1171.             scan_x_cg = diag_scan2x2_x;
  1172.             scan_y_cg = diag_scan2x2_y;
  1173.         } else if (trafo_size == 16) {
  1174.             num_coeff += diag_scan4x4_inv[y_cg_last_sig][x_cg_last_sig] << 4;
  1175.             scan_x_cg = ff_hevc_diag_scan4x4_x;
  1176.             scan_y_cg = ff_hevc_diag_scan4x4_y;
  1177.         } else { // trafo_size == 32
  1178.             num_coeff += diag_scan8x8_inv[y_cg_last_sig][x_cg_last_sig] << 4;
  1179.             scan_x_cg = ff_hevc_diag_scan8x8_x;
  1180.             scan_y_cg = ff_hevc_diag_scan8x8_y;
  1181.         }
  1182.         break;
  1183.     }
  1184.     case SCAN_HORIZ:
  1185.         scan_x_cg = horiz_scan2x2_x;
  1186.         scan_y_cg = horiz_scan2x2_y;
  1187.         scan_x_off = horiz_scan4x4_x;
  1188.         scan_y_off = horiz_scan4x4_y;
  1189.         num_coeff = horiz_scan8x8_inv[last_significant_coeff_y][last_significant_coeff_x];
  1190.         break;
  1191.     default: //SCAN_VERT
  1192.         scan_x_cg = horiz_scan2x2_y;
  1193.         scan_y_cg = horiz_scan2x2_x;
  1194.         scan_x_off = horiz_scan4x4_y;
  1195.         scan_y_off = horiz_scan4x4_x;
  1196.         num_coeff = horiz_scan8x8_inv[last_significant_coeff_x][last_significant_coeff_y];
  1197.         break;
  1198.     }
  1199.     num_coeff++;
  1200.     num_last_subset = (num_coeff - 1) >> 4;
  1201.  
  1202.     for (i = num_last_subset; i >= 0; i--) {
  1203.         int n, m;
  1204.         int x_cg, y_cg, x_c, y_c, pos;
  1205.         int implicit_non_zero_coeff = 0;
  1206.         int64_t trans_coeff_level;
  1207.         int prev_sig = 0;
  1208.         int offset = i << 4;
  1209.         int rice_init = 0;
  1210.  
  1211.         uint8_t significant_coeff_flag_idx[16];
  1212.         uint8_t nb_significant_coeff_flag = 0;
  1213.  
  1214.         x_cg = scan_x_cg[i];
  1215.         y_cg = scan_y_cg[i];
  1216.  
  1217.         if ((i < num_last_subset) && (i > 0)) {
  1218.             int ctx_cg = 0;
  1219.             if (x_cg < (1 << (log2_trafo_size - 2)) - 1)
  1220.                 ctx_cg += significant_coeff_group_flag[x_cg + 1][y_cg];
  1221.             if (y_cg < (1 << (log2_trafo_size - 2)) - 1)
  1222.                 ctx_cg += significant_coeff_group_flag[x_cg][y_cg + 1];
  1223.  
  1224.             significant_coeff_group_flag[x_cg][y_cg] =
  1225.                 significant_coeff_group_flag_decode(s, c_idx, ctx_cg);
  1226.             implicit_non_zero_coeff = 1;
  1227.         } else {
  1228.             significant_coeff_group_flag[x_cg][y_cg] =
  1229.             ((x_cg == x_cg_last_sig && y_cg == y_cg_last_sig) ||
  1230.              (x_cg == 0 && y_cg == 0));
  1231.         }
  1232.  
  1233.         last_scan_pos = num_coeff - offset - 1;
  1234.  
  1235.         if (i == num_last_subset) {
  1236.             n_end = last_scan_pos - 1;
  1237.             significant_coeff_flag_idx[0] = last_scan_pos;
  1238.             nb_significant_coeff_flag = 1;
  1239.         } else {
  1240.             n_end = 15;
  1241.         }
  1242.  
  1243.         if (x_cg < ((1 << log2_trafo_size) - 1) >> 2)
  1244.             prev_sig = !!significant_coeff_group_flag[x_cg + 1][y_cg];
  1245.         if (y_cg < ((1 << log2_trafo_size) - 1) >> 2)
  1246.             prev_sig += (!!significant_coeff_group_flag[x_cg][y_cg + 1] << 1);
  1247.  
  1248.         if (significant_coeff_group_flag[x_cg][y_cg] && n_end >= 0) {
  1249.             static const uint8_t ctx_idx_map[] = {
  1250.                 0, 1, 4, 5, 2, 3, 4, 5, 6, 6, 8, 8, 7, 7, 8, 8, // log2_trafo_size == 2
  1251.                 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, // prev_sig == 0
  1252.                 2, 2, 2, 2, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, // prev_sig == 1
  1253.                 2, 1, 0, 0, 2, 1, 0, 0, 2, 1, 0, 0, 2, 1, 0, 0, // prev_sig == 2
  1254.                 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2  // default
  1255.             };
  1256.             const uint8_t *ctx_idx_map_p;
  1257.             int scf_offset = 0;
  1258.             if (s->ps.sps->transform_skip_context_enabled_flag &&
  1259.                 (transform_skip_flag || lc->cu.cu_transquant_bypass_flag)) {
  1260.                 ctx_idx_map_p = (uint8_t*) &ctx_idx_map[4 * 16];
  1261.                 if (c_idx == 0) {
  1262.                     scf_offset = 40;
  1263.                 } else {
  1264.                     scf_offset = 14 + 27;
  1265.                 }
  1266.             } else {
  1267.                 if (c_idx != 0)
  1268.                     scf_offset = 27;
  1269.                 if (log2_trafo_size == 2) {
  1270.                     ctx_idx_map_p = (uint8_t*) &ctx_idx_map[0];
  1271.                 } else {
  1272.                     ctx_idx_map_p = (uint8_t*) &ctx_idx_map[(prev_sig + 1) << 4];
  1273.                     if (c_idx == 0) {
  1274.                         if ((x_cg > 0 || y_cg > 0))
  1275.                             scf_offset += 3;
  1276.                         if (log2_trafo_size == 3) {
  1277.                             scf_offset += (scan_idx == SCAN_DIAG) ? 9 : 15;
  1278.                         } else {
  1279.                             scf_offset += 21;
  1280.                         }
  1281.                     } else {
  1282.                         if (log2_trafo_size == 3)
  1283.                             scf_offset += 9;
  1284.                         else
  1285.                             scf_offset += 12;
  1286.                     }
  1287.                 }
  1288.             }
  1289.             for (n = n_end; n > 0; n--) {
  1290.                 x_c = scan_x_off[n];
  1291.                 y_c = scan_y_off[n];
  1292.                 if (significant_coeff_flag_decode(s, x_c, y_c, scf_offset, ctx_idx_map_p)) {
  1293.                     significant_coeff_flag_idx[nb_significant_coeff_flag] = n;
  1294.                     nb_significant_coeff_flag++;
  1295.                     implicit_non_zero_coeff = 0;
  1296.                 }
  1297.             }
  1298.             if (implicit_non_zero_coeff == 0) {
  1299.                 if (s->ps.sps->transform_skip_context_enabled_flag &&
  1300.                     (transform_skip_flag || lc->cu.cu_transquant_bypass_flag)) {
  1301.                     if (c_idx == 0) {
  1302.                         scf_offset = 42;
  1303.                     } else {
  1304.                         scf_offset = 16 + 27;
  1305.                     }
  1306.                 } else {
  1307.                     if (i == 0) {
  1308.                         if (c_idx == 0)
  1309.                             scf_offset = 0;
  1310.                         else
  1311.                             scf_offset = 27;
  1312.                     } else {
  1313.                         scf_offset = 2 + scf_offset;
  1314.                     }
  1315.                 }
  1316.                 if (significant_coeff_flag_decode_0(s, c_idx, scf_offset) == 1) {
  1317.                     significant_coeff_flag_idx[nb_significant_coeff_flag] = 0;
  1318.                     nb_significant_coeff_flag++;
  1319.                 }
  1320.             } else {
  1321.                 significant_coeff_flag_idx[nb_significant_coeff_flag] = 0;
  1322.                 nb_significant_coeff_flag++;
  1323.             }
  1324.         }
  1325.  
  1326.         n_end = nb_significant_coeff_flag;
  1327.  
  1328.  
  1329.         if (n_end) {
  1330.             int first_nz_pos_in_cg;
  1331.             int last_nz_pos_in_cg;
  1332.             int c_rice_param = 0;
  1333.             int first_greater1_coeff_idx = -1;
  1334.             uint8_t coeff_abs_level_greater1_flag[8];
  1335.             uint16_t coeff_sign_flag;
  1336.             int sum_abs = 0;
  1337.             int sign_hidden;
  1338.             int sb_type;
  1339.  
  1340.  
  1341.             // initialize first elem of coeff_bas_level_greater1_flag
  1342.             int ctx_set = (i > 0 && c_idx == 0) ? 2 : 0;
  1343.  
  1344.             if (s->ps.sps->persistent_rice_adaptation_enabled_flag) {
  1345.                 if (!transform_skip_flag && !lc->cu.cu_transquant_bypass_flag)
  1346.                     sb_type = 2 * (c_idx == 0 ? 1 : 0);
  1347.                 else
  1348.                     sb_type = 2 * (c_idx == 0 ? 1 : 0) + 1;
  1349.                 c_rice_param = lc->stat_coeff[sb_type] / 4;
  1350.             }
  1351.  
  1352.             if (!(i == num_last_subset) && greater1_ctx == 0)
  1353.                 ctx_set++;
  1354.             greater1_ctx = 1;
  1355.             last_nz_pos_in_cg = significant_coeff_flag_idx[0];
  1356.  
  1357.             for (m = 0; m < (n_end > 8 ? 8 : n_end); m++) {
  1358.                 int inc = (ctx_set << 2) + greater1_ctx;
  1359.                 coeff_abs_level_greater1_flag[m] =
  1360.                     coeff_abs_level_greater1_flag_decode(s, c_idx, inc);
  1361.                 if (coeff_abs_level_greater1_flag[m]) {
  1362.                     greater1_ctx = 0;
  1363.                     if (first_greater1_coeff_idx == -1)
  1364.                         first_greater1_coeff_idx = m;
  1365.                 } else if (greater1_ctx > 0 && greater1_ctx < 3) {
  1366.                     greater1_ctx++;
  1367.                 }
  1368.             }
  1369.             first_nz_pos_in_cg = significant_coeff_flag_idx[n_end - 1];
  1370.  
  1371.             if (lc->cu.cu_transquant_bypass_flag ||
  1372.                 (lc->cu.pred_mode ==  MODE_INTRA  &&
  1373.                  s->ps.sps->implicit_rdpcm_enabled_flag  &&  transform_skip_flag  &&
  1374.                  (pred_mode_intra == 10 || pred_mode_intra  ==  26 )) ||
  1375.                  explicit_rdpcm_flag)
  1376.                 sign_hidden = 0;
  1377.             else
  1378.                 sign_hidden = (last_nz_pos_in_cg - first_nz_pos_in_cg >= 4);
  1379.  
  1380.             if (first_greater1_coeff_idx != -1) {
  1381.                 coeff_abs_level_greater1_flag[first_greater1_coeff_idx] += coeff_abs_level_greater2_flag_decode(s, c_idx, ctx_set);
  1382.             }
  1383.             if (!s->ps.pps->sign_data_hiding_flag || !sign_hidden ) {
  1384.                 coeff_sign_flag = coeff_sign_flag_decode(s, nb_significant_coeff_flag) << (16 - nb_significant_coeff_flag);
  1385.             } else {
  1386.                 coeff_sign_flag = coeff_sign_flag_decode(s, nb_significant_coeff_flag - 1) << (16 - (nb_significant_coeff_flag - 1));
  1387.             }
  1388.  
  1389.             for (m = 0; m < n_end; m++) {
  1390.                 n = significant_coeff_flag_idx[m];
  1391.                 GET_COORD(offset, n);
  1392.                 if (m < 8) {
  1393.                     trans_coeff_level = 1 + coeff_abs_level_greater1_flag[m];
  1394.                     if (trans_coeff_level == ((m == first_greater1_coeff_idx) ? 3 : 2)) {
  1395.                         int last_coeff_abs_level_remaining = coeff_abs_level_remaining_decode(s, c_rice_param);
  1396.  
  1397.                         trans_coeff_level += last_coeff_abs_level_remaining;
  1398.                         if (trans_coeff_level > (3 << c_rice_param))
  1399.                             c_rice_param = s->ps.sps->persistent_rice_adaptation_enabled_flag ? c_rice_param + 1 : FFMIN(c_rice_param + 1, 4);
  1400.                         if (s->ps.sps->persistent_rice_adaptation_enabled_flag && !rice_init) {
  1401.                             int c_rice_p_init = lc->stat_coeff[sb_type] / 4;
  1402.                             if (last_coeff_abs_level_remaining >= (3 << c_rice_p_init))
  1403.                                 lc->stat_coeff[sb_type]++;
  1404.                             else if (2 * last_coeff_abs_level_remaining < (1 << c_rice_p_init))
  1405.                                 if (lc->stat_coeff[sb_type] > 0)
  1406.                                     lc->stat_coeff[sb_type]--;
  1407.                             rice_init = 1;
  1408.                         }
  1409.                     }
  1410.                 } else {
  1411.                     int last_coeff_abs_level_remaining = coeff_abs_level_remaining_decode(s, c_rice_param);
  1412.  
  1413.                     trans_coeff_level = 1 + last_coeff_abs_level_remaining;
  1414.                     if (trans_coeff_level > (3 << c_rice_param))
  1415.                         c_rice_param = s->ps.sps->persistent_rice_adaptation_enabled_flag ? c_rice_param + 1 : FFMIN(c_rice_param + 1, 4);
  1416.                     if (s->ps.sps->persistent_rice_adaptation_enabled_flag && !rice_init) {
  1417.                         int c_rice_p_init = lc->stat_coeff[sb_type] / 4;
  1418.                         if (last_coeff_abs_level_remaining >= (3 << c_rice_p_init))
  1419.                             lc->stat_coeff[sb_type]++;
  1420.                         else if (2 * last_coeff_abs_level_remaining < (1 << c_rice_p_init))
  1421.                             if (lc->stat_coeff[sb_type] > 0)
  1422.                                 lc->stat_coeff[sb_type]--;
  1423.                         rice_init = 1;
  1424.                     }
  1425.                 }
  1426.                 if (s->ps.pps->sign_data_hiding_flag && sign_hidden) {
  1427.                     sum_abs += trans_coeff_level;
  1428.                     if (n == first_nz_pos_in_cg && (sum_abs&1))
  1429.                         trans_coeff_level = -trans_coeff_level;
  1430.                 }
  1431.                 if (coeff_sign_flag >> 15)
  1432.                     trans_coeff_level = -trans_coeff_level;
  1433.                 coeff_sign_flag <<= 1;
  1434.                 if(!lc->cu.cu_transquant_bypass_flag) {
  1435.                     if (s->ps.sps->scaling_list_enable_flag && !(transform_skip_flag && log2_trafo_size > 2)) {
  1436.                         if(y_c || x_c || log2_trafo_size < 4) {
  1437.                             switch(log2_trafo_size) {
  1438.                                 case 3: pos = (y_c << 3) + x_c; break;
  1439.                                 case 4: pos = ((y_c >> 1) << 3) + (x_c >> 1); break;
  1440.                                 case 5: pos = ((y_c >> 2) << 3) + (x_c >> 2); break;
  1441.                                 default: pos = (y_c << 2) + x_c; break;
  1442.                             }
  1443.                             scale_m = scale_matrix[pos];
  1444.                         } else {
  1445.                             scale_m = dc_scale;
  1446.                         }
  1447.                     }
  1448.                     trans_coeff_level = (trans_coeff_level * (int64_t)scale * (int64_t)scale_m + add) >> shift;
  1449.                     if(trans_coeff_level < 0) {
  1450.                         if((~trans_coeff_level) & 0xFffffffffff8000)
  1451.                             trans_coeff_level = -32768;
  1452.                     } else {
  1453.                         if(trans_coeff_level & 0xffffffffffff8000)
  1454.                             trans_coeff_level = 32767;
  1455.                     }
  1456.                 }
  1457.                 coeffs[y_c * trafo_size + x_c] = trans_coeff_level;
  1458.             }
  1459.         }
  1460.     }
  1461.  
  1462.     if (lc->cu.cu_transquant_bypass_flag) {
  1463.         if (explicit_rdpcm_flag || (s->ps.sps->implicit_rdpcm_enabled_flag &&
  1464.                                     (pred_mode_intra == 10 || pred_mode_intra == 26))) {
  1465.             int mode = s->ps.sps->implicit_rdpcm_enabled_flag ? (pred_mode_intra == 26) : explicit_rdpcm_dir_flag;
  1466.  
  1467.             s->hevcdsp.transform_rdpcm(coeffs, log2_trafo_size, mode);
  1468.         }
  1469.     } else {
  1470.         if (transform_skip_flag) {
  1471.             int rot = s->ps.sps->transform_skip_rotation_enabled_flag &&
  1472.                       log2_trafo_size == 2 &&
  1473.                       lc->cu.pred_mode == MODE_INTRA;
  1474.             if (rot) {
  1475.                 for (i = 0; i < 8; i++)
  1476.                     FFSWAP(int16_t, coeffs[i], coeffs[16 - i - 1]);
  1477.             }
  1478.  
  1479.             s->hevcdsp.transform_skip(coeffs, log2_trafo_size);
  1480.  
  1481.             if (explicit_rdpcm_flag || (s->ps.sps->implicit_rdpcm_enabled_flag &&
  1482.                                         lc->cu.pred_mode == MODE_INTRA &&
  1483.                                         (pred_mode_intra == 10 || pred_mode_intra == 26))) {
  1484.                 int mode = explicit_rdpcm_flag ? explicit_rdpcm_dir_flag : (pred_mode_intra == 26);
  1485.  
  1486.                 s->hevcdsp.transform_rdpcm(coeffs, log2_trafo_size, mode);
  1487.             }
  1488.         } else if (lc->cu.pred_mode == MODE_INTRA && c_idx == 0 && log2_trafo_size == 2) {
  1489.             s->hevcdsp.idct_4x4_luma(coeffs);
  1490.         } else {
  1491.             int max_xy = FFMAX(last_significant_coeff_x, last_significant_coeff_y);
  1492.             if (max_xy == 0)
  1493.                 s->hevcdsp.idct_dc[log2_trafo_size-2](coeffs);
  1494.             else {
  1495.                 int col_limit = last_significant_coeff_x + last_significant_coeff_y + 4;
  1496.                 if (max_xy < 4)
  1497.                     col_limit = FFMIN(4, col_limit);
  1498.                 else if (max_xy < 8)
  1499.                     col_limit = FFMIN(8, col_limit);
  1500.                 else if (max_xy < 12)
  1501.                     col_limit = FFMIN(24, col_limit);
  1502.                 s->hevcdsp.idct[log2_trafo_size-2](coeffs, col_limit);
  1503.             }
  1504.         }
  1505.     }
  1506.     if (lc->tu.cross_pf) {
  1507.         int16_t *coeffs_y = (int16_t*)lc->edge_emu_buffer;
  1508.  
  1509.         for (i = 0; i < (trafo_size * trafo_size); i++) {
  1510.             coeffs[i] = coeffs[i] + ((lc->tu.res_scale_val * coeffs_y[i]) >> 3);
  1511.         }
  1512.     }
  1513.     s->hevcdsp.transform_add[log2_trafo_size-2](dst, coeffs, stride);
  1514. }
  1515.  
  1516. void ff_hevc_hls_mvd_coding(HEVCContext *s, int x0, int y0, int log2_cb_size)
  1517. {
  1518.     HEVCLocalContext *lc = s->HEVClc;
  1519.     int x = abs_mvd_greater0_flag_decode(s);
  1520.     int y = abs_mvd_greater0_flag_decode(s);
  1521.  
  1522.     if (x)
  1523.         x += abs_mvd_greater1_flag_decode(s);
  1524.     if (y)
  1525.         y += abs_mvd_greater1_flag_decode(s);
  1526.  
  1527.     switch (x) {
  1528.     case 2: lc->pu.mvd.x = mvd_decode(s);           break;
  1529.     case 1: lc->pu.mvd.x = mvd_sign_flag_decode(s); break;
  1530.     case 0: lc->pu.mvd.x = 0;                       break;
  1531.     }
  1532.  
  1533.     switch (y) {
  1534.     case 2: lc->pu.mvd.y = mvd_decode(s);           break;
  1535.     case 1: lc->pu.mvd.y = mvd_sign_flag_decode(s); break;
  1536.     case 0: lc->pu.mvd.y = 0;                       break;
  1537.     }
  1538. }
  1539.  
  1540.