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