LCOV - code coverage report
Current view: top level - libavcodec - hevc_cabac.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 641 662 96.8 %
Date: 2017-12-17 04:34:43 Functions: 55 56 98.2 %

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

Generated by: LCOV version 1.13