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