git.sesse.net Git - ffmpeg/blob - libavcodec/hevc_cabac.c

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