Subversion Repositories Kolibri OS

Rev

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