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 int cabac_reinit(HEVCLocalContext *lc)
 466 {
 467     return skip_bytes(&lc->cc, 0) == NULL ? AVERROR_INVALIDDATA : 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             int ret;
 528             if (s->threads_number == 1)
 529                 ret = cabac_reinit(s->HEVClc);
 530             else {
 531                 ret = cabac_init_decoder(s);
 532             }
 533             if (ret < 0)
 534                 return ret;
 535             cabac_init_state(s);
 536         }
 537         if (s->ps.pps->entropy_coding_sync_enabled_flag) {
 538             if (ctb_addr_ts % s->ps.sps->ctb_width == 0) {
 539                 int ret;
 540                 get_cabac_terminate(&s->HEVClc->cc);
 541                 if (s->threads_number == 1)
 542                     ret = cabac_reinit(s->HEVClc);
 543                 else {
 544                     ret = cabac_init_decoder(s);
 545                 }
 546                 if (ret < 0)
 547                     return ret;
 548
 549                 if (s->ps.sps->ctb_width == 1)
 550                     cabac_init_state(s);
 551                 else
 552                     load_states(s);
 553             }
 554         }
 555     }
 556     return 0;
 557 }
 558
 559 #define GET_CABAC(ctx) get_cabac(&s->HEVClc->cc, &s->HEVClc->cabac_state[ctx])
 560
 561 int ff_hevc_sao_merge_flag_decode(HEVCContext *s)
 562 {
 563     return GET_CABAC(elem_offset[SAO_MERGE_FLAG]);
 564 }
 565
 566 int ff_hevc_sao_type_idx_decode(HEVCContext *s)
 567 {
 568     if (!GET_CABAC(elem_offset[SAO_TYPE_IDX]))
 569         return 0;
 570
 571     if (!get_cabac_bypass(&s->HEVClc->cc))
 572         return SAO_BAND;
 573     return SAO_EDGE;
 574 }
 575
 576 int ff_hevc_sao_band_position_decode(HEVCContext *s)
 577 {
 578     int i;
 579     int value = get_cabac_bypass(&s->HEVClc->cc);
 580
 581     for (i = 0; i < 4; i++)
 582         value = (value << 1) | get_cabac_bypass(&s->HEVClc->cc);
 583     return value;
 584 }
 585
 586 int ff_hevc_sao_offset_abs_decode(HEVCContext *s)
 587 {
 588     int i = 0;
 589     int length = (1 << (FFMIN(s->ps.sps->bit_depth, 10) - 5)) - 1;
 590
 591     while (i < length && get_cabac_bypass(&s->HEVClc->cc))
 592         i++;
 593     return i;
 594 }
 595
 596 int ff_hevc_sao_offset_sign_decode(HEVCContext *s)
 597 {
 598     return get_cabac_bypass(&s->HEVClc->cc);
 599 }
 600
 601 int ff_hevc_sao_eo_class_decode(HEVCContext *s)
 602 {
 603     int ret = get_cabac_bypass(&s->HEVClc->cc) << 1;
 604     ret    |= get_cabac_bypass(&s->HEVClc->cc);
 605     return ret;
 606 }
 607
 608 int ff_hevc_end_of_slice_flag_decode(HEVCContext *s)
 609 {
 610     return get_cabac_terminate(&s->HEVClc->cc);
 611 }
 612
 613 int ff_hevc_cu_transquant_bypass_flag_decode(HEVCContext *s)
 614 {
 615     return GET_CABAC(elem_offset[CU_TRANSQUANT_BYPASS_FLAG]);
 616 }
 617
 618 int ff_hevc_skip_flag_decode(HEVCContext *s, int x0, int y0, int x_cb, int y_cb)
 619 {
 620     int min_cb_width = s->ps.sps->min_cb_width;
 621     int inc = 0;
 622     int x0b = av_mod_uintp2(x0, s->ps.sps->log2_ctb_size);
 623     int y0b = av_mod_uintp2(y0, s->ps.sps->log2_ctb_size);
 624
 625     if (s->HEVClc->ctb_left_flag || x0b)
 626         inc = !!SAMPLE_CTB(s->skip_flag, x_cb - 1, y_cb);
 627     if (s->HEVClc->ctb_up_flag || y0b)
 628         inc += !!SAMPLE_CTB(s->skip_flag, x_cb, y_cb - 1);
 629
 630     return GET_CABAC(elem_offset[SKIP_FLAG] + inc);
 631 }
 632
 633 int ff_hevc_cu_qp_delta_abs(HEVCContext *s)
 634 {
 635     int prefix_val = 0;
 636     int suffix_val = 0;
 637     int inc = 0;
 638
 639     while (prefix_val < 5 && GET_CABAC(elem_offset[CU_QP_DELTA] + inc)) {
 640         prefix_val++;
 641         inc = 1;
 642     }
 643     if (prefix_val >= 5) {
 644         int k = 0;
 645         while (k < CABAC_MAX_BIN && get_cabac_bypass(&s->HEVClc->cc)) {
 646             suffix_val += 1 << k;
 647             k++;
 648         }
 649         if (k == CABAC_MAX_BIN) {
 650             av_log(s->avctx, AV_LOG_ERROR, "CABAC_MAX_BIN : %d\n", k);
 651             return AVERROR_INVALIDDATA;
 652         }
 653
 654         while (k--)
 655             suffix_val += get_cabac_bypass(&s->HEVClc->cc) << k;
 656     }
 657     return prefix_val + suffix_val;
 658 }
 659
 660 int ff_hevc_cu_qp_delta_sign_flag(HEVCContext *s)
 661 {
 662     return get_cabac_bypass(&s->HEVClc->cc);
 663 }
 664
 665 int ff_hevc_cu_chroma_qp_offset_flag(HEVCContext *s)
 666 {
 667     return GET_CABAC(elem_offset[CU_CHROMA_QP_OFFSET_FLAG]);
 668 }
 669
 670 int ff_hevc_cu_chroma_qp_offset_idx(HEVCContext *s)
 671 {
 672     int c_max= FFMAX(5, s->ps.pps->chroma_qp_offset_list_len_minus1);
 673     int i = 0;
 674
 675     while (i < c_max && GET_CABAC(elem_offset[CU_CHROMA_QP_OFFSET_IDX]))
 676         i++;
 677
 678     return i;
 679 }
 680
 681 int ff_hevc_pred_mode_decode(HEVCContext *s)
 682 {
 683     return GET_CABAC(elem_offset[PRED_MODE_FLAG]);
 684 }
 685
 686 int ff_hevc_split_coding_unit_flag_decode(HEVCContext *s, int ct_depth, int x0, int y0)
 687 {
 688     int inc = 0, depth_left = 0, depth_top = 0;
 689     int x0b  = av_mod_uintp2(x0, s->ps.sps->log2_ctb_size);
 690     int y0b  = av_mod_uintp2(y0, s->ps.sps->log2_ctb_size);
 691     int x_cb = x0 >> s->ps.sps->log2_min_cb_size;
 692     int y_cb = y0 >> s->ps.sps->log2_min_cb_size;
 693
 694     if (s->HEVClc->ctb_left_flag || x0b)
 695         depth_left = s->tab_ct_depth[(y_cb) * s->ps.sps->min_cb_width + x_cb - 1];
 696     if (s->HEVClc->ctb_up_flag || y0b)
 697         depth_top = s->tab_ct_depth[(y_cb - 1) * s->ps.sps->min_cb_width + x_cb];
 698
 699     inc += (depth_left > ct_depth);
 700     inc += (depth_top  > ct_depth);
 701
 702     return GET_CABAC(elem_offset[SPLIT_CODING_UNIT_FLAG] + inc);
 703 }
 704
 705 int ff_hevc_part_mode_decode(HEVCContext *s, int log2_cb_size)
 706 {
 707     if (GET_CABAC(elem_offset[PART_MODE])) // 1
 708         return PART_2Nx2N;
 709     if (log2_cb_size == s->ps.sps->log2_min_cb_size) {
 710         if (s->HEVClc->cu.pred_mode == MODE_INTRA) // 0
 711             return PART_NxN;
 712         if (GET_CABAC(elem_offset[PART_MODE] + 1)) // 01
 713             return PART_2NxN;
 714         if (log2_cb_size == 3) // 00
 715             return PART_Nx2N;
 716         if (GET_CABAC(elem_offset[PART_MODE] + 2)) // 001
 717             return PART_Nx2N;
 718         return PART_NxN; // 000
 719     }
 720
 721     if (!s->ps.sps->amp_enabled_flag) {
 722         if (GET_CABAC(elem_offset[PART_MODE] + 1)) // 01
 723             return PART_2NxN;
 724         return PART_Nx2N;
 725     }
 726
 727     if (GET_CABAC(elem_offset[PART_MODE] + 1)) { // 01X, 01XX
 728         if (GET_CABAC(elem_offset[PART_MODE] + 3)) // 011
 729             return PART_2NxN;
 730         if (get_cabac_bypass(&s->HEVClc->cc)) // 0101
 731             return PART_2NxnD;
 732         return PART_2NxnU; // 0100
 733     }
 734
 735     if (GET_CABAC(elem_offset[PART_MODE] + 3)) // 001
 736         return PART_Nx2N;
 737     if (get_cabac_bypass(&s->HEVClc->cc)) // 0001
 738         return PART_nRx2N;
 739     return PART_nLx2N;  // 0000
 740 }
 741
 742 int ff_hevc_pcm_flag_decode(HEVCContext *s)
 743 {
 744     return get_cabac_terminate(&s->HEVClc->cc);
 745 }
 746
 747 int ff_hevc_prev_intra_luma_pred_flag_decode(HEVCContext *s)
 748 {
 749     return GET_CABAC(elem_offset[PREV_INTRA_LUMA_PRED_FLAG]);
 750 }
 751
 752 int ff_hevc_mpm_idx_decode(HEVCContext *s)
 753 {
 754     int i = 0;
 755     while (i < 2 && get_cabac_bypass(&s->HEVClc->cc))
 756         i++;
 757     return i;
 758 }
 759
 760 int ff_hevc_rem_intra_luma_pred_mode_decode(HEVCContext *s)
 761 {
 762     int i;
 763     int value = get_cabac_bypass(&s->HEVClc->cc);
 764
 765     for (i = 0; i < 4; i++)
 766         value = (value << 1) | get_cabac_bypass(&s->HEVClc->cc);
 767     return value;
 768 }
 769
 770 int ff_hevc_intra_chroma_pred_mode_decode(HEVCContext *s)
 771 {
 772     int ret;
 773     if (!GET_CABAC(elem_offset[INTRA_CHROMA_PRED_MODE]))
 774         return 4;
 775
 776     ret  = get_cabac_bypass(&s->HEVClc->cc) << 1;
 777     ret |= get_cabac_bypass(&s->HEVClc->cc);
 778     return ret;
 779 }
 780
 781 int ff_hevc_merge_idx_decode(HEVCContext *s)
 782 {
 783     int i = GET_CABAC(elem_offset[MERGE_IDX]);
 784
 785     if (i != 0) {
 786         while (i < s->sh.max_num_merge_cand-1 && get_cabac_bypass(&s->HEVClc->cc))
 787             i++;
 788     }
 789     return i;
 790 }
 791
 792 int ff_hevc_merge_flag_decode(HEVCContext *s)
 793 {
 794     return GET_CABAC(elem_offset[MERGE_FLAG]);
 795 }
 796
 797 int ff_hevc_inter_pred_idc_decode(HEVCContext *s, int nPbW, int nPbH)
 798 {
 799     if (nPbW + nPbH == 12)
 800         return GET_CABAC(elem_offset[INTER_PRED_IDC] + 4);
 801     if (GET_CABAC(elem_offset[INTER_PRED_IDC] + s->HEVClc->ct_depth))
 802         return PRED_BI;
 803
 804     return GET_CABAC(elem_offset[INTER_PRED_IDC] + 4);
 805 }
 806
 807 int ff_hevc_ref_idx_lx_decode(HEVCContext *s, int num_ref_idx_lx)
 808 {
 809     int i = 0;
 810     int max = num_ref_idx_lx - 1;
 811     int max_ctx = FFMIN(max, 2);
 812
 813     while (i < max_ctx && GET_CABAC(elem_offset[REF_IDX_L0] + i))
 814         i++;
 815     if (i == 2) {
 816         while (i < max && get_cabac_bypass(&s->HEVClc->cc))
 817             i++;
 818     }
 819
 820     return i;
 821 }
 822
 823 int ff_hevc_mvp_lx_flag_decode(HEVCContext *s)
 824 {
 825     return GET_CABAC(elem_offset[MVP_LX_FLAG]);
 826 }
 827
 828 int ff_hevc_no_residual_syntax_flag_decode(HEVCContext *s)
 829 {
 830     return GET_CABAC(elem_offset[NO_RESIDUAL_DATA_FLAG]);
 831 }
 832
 833 static av_always_inline int abs_mvd_greater0_flag_decode(HEVCContext *s)
 834 {
 835     return GET_CABAC(elem_offset[ABS_MVD_GREATER0_FLAG]);
 836 }
 837
 838 static av_always_inline int abs_mvd_greater1_flag_decode(HEVCContext *s)
 839 {
 840     return GET_CABAC(elem_offset[ABS_MVD_GREATER1_FLAG] + 1);
 841 }
 842
 843 static av_always_inline int mvd_decode(HEVCContext *s)
 844 {
 845     int ret = 2;
 846     int k = 1;
 847
 848     while (k < CABAC_MAX_BIN && get_cabac_bypass(&s->HEVClc->cc)) {
 849         ret += 1U << k;
 850         k++;
 851     }
 852     if (k == CABAC_MAX_BIN) {
 853         av_log(s->avctx, AV_LOG_ERROR, "CABAC_MAX_BIN : %d\n", k);
 854         return 0;
 855     }
 856     while (k--)
 857         ret += get_cabac_bypass(&s->HEVClc->cc) << k;
 858     return get_cabac_bypass_sign(&s->HEVClc->cc, -ret);
 859 }
 860
 861 static av_always_inline int mvd_sign_flag_decode(HEVCContext *s)
 862 {
 863     return get_cabac_bypass_sign(&s->HEVClc->cc, -1);
 864 }
 865
 866 int ff_hevc_split_transform_flag_decode(HEVCContext *s, int log2_trafo_size)
 867 {
 868     return GET_CABAC(elem_offset[SPLIT_TRANSFORM_FLAG] + 5 - log2_trafo_size);
 869 }
 870
 871 int ff_hevc_cbf_cb_cr_decode(HEVCContext *s, int trafo_depth)
 872 {
 873     return GET_CABAC(elem_offset[CBF_CB_CR] + trafo_depth);
 874 }
 875
 876 int ff_hevc_cbf_luma_decode(HEVCContext *s, int trafo_depth)
 877 {
 878     return GET_CABAC(elem_offset[CBF_LUMA] + !trafo_depth);
 879 }
 880
 881 static int hevc_transform_skip_flag_decode(HEVCContext *s, int c_idx)
 882 {
 883     return GET_CABAC(elem_offset[TRANSFORM_SKIP_FLAG] + !!c_idx);
 884 }
 885
 886 static int explicit_rdpcm_flag_decode(HEVCContext *s, int c_idx)
 887 {
 888     return GET_CABAC(elem_offset[EXPLICIT_RDPCM_FLAG] + !!c_idx);
 889 }
 890
 891 static int explicit_rdpcm_dir_flag_decode(HEVCContext *s, int c_idx)
 892 {
 893     return GET_CABAC(elem_offset[EXPLICIT_RDPCM_DIR_FLAG] + !!c_idx);
 894 }
 895
 896 int ff_hevc_log2_res_scale_abs(HEVCContext *s, int idx) {
 897     int i =0;
 898
 899     while (i < 4 && GET_CABAC(elem_offset[LOG2_RES_SCALE_ABS] + 4 * idx + i))
 900         i++;
 901
 902     return i;
 903 }
 904
 905 int ff_hevc_res_scale_sign_flag(HEVCContext *s, int idx) {
 906     return GET_CABAC(elem_offset[RES_SCALE_SIGN_FLAG] + idx);
 907 }
 908
 909 static av_always_inline void last_significant_coeff_xy_prefix_decode(HEVCContext *s, int c_idx,
 910                                                    int log2_size, int *last_scx_prefix, int *last_scy_prefix)
 911 {
 912     int i = 0;
 913     int max = (log2_size << 1) - 1;
 914     int ctx_offset, ctx_shift;
 915
 916     if (!c_idx) {
 917         ctx_offset = 3 * (log2_size - 2)  + ((log2_size - 1) >> 2);
 918         ctx_shift = (log2_size + 1) >> 2;
 919     } else {
 920         ctx_offset = 15;
 921         ctx_shift = log2_size - 2;
 922     }
 923     while (i < max &&
 924            GET_CABAC(elem_offset[LAST_SIGNIFICANT_COEFF_X_PREFIX] + (i >> ctx_shift) + ctx_offset))
 925         i++;
 926     *last_scx_prefix = i;
 927
 928     i = 0;
 929     while (i < max &&
 930            GET_CABAC(elem_offset[LAST_SIGNIFICANT_COEFF_Y_PREFIX] + (i >> ctx_shift) + ctx_offset))
 931         i++;
 932     *last_scy_prefix = i;
 933 }
 934
 935 static av_always_inline int last_significant_coeff_suffix_decode(HEVCContext *s,
 936                                                  int last_significant_coeff_prefix)
 937 {
 938     int i;
 939     int length = (last_significant_coeff_prefix >> 1) - 1;
 940     int value = get_cabac_bypass(&s->HEVClc->cc);
 941
 942     for (i = 1; i < length; i++)
 943         value = (value << 1) | get_cabac_bypass(&s->HEVClc->cc);
 944     return value;
 945 }
 946
 947 static av_always_inline int significant_coeff_group_flag_decode(HEVCContext *s, int c_idx, int ctx_cg)
 948 {
 949     int inc;
 950
 951     inc = FFMIN(ctx_cg, 1) + (c_idx>0 ? 2 : 0);
 952
 953     return GET_CABAC(elem_offset[SIGNIFICANT_COEFF_GROUP_FLAG] + inc);
 954 }
 955 static av_always_inline int significant_coeff_flag_decode(HEVCContext *s, int x_c, int y_c,
 956                                            int offset, const uint8_t *ctx_idx_map)
 957 {
 958     int inc = ctx_idx_map[(y_c << 2) + x_c] + offset;
 959     return GET_CABAC(elem_offset[SIGNIFICANT_COEFF_FLAG] + inc);
 960 }
 961
 962 static av_always_inline int significant_coeff_flag_decode_0(HEVCContext *s, int c_idx, int offset)
 963 {
 964     return GET_CABAC(elem_offset[SIGNIFICANT_COEFF_FLAG] + offset);
 965 }
 966
 967 static av_always_inline int coeff_abs_level_greater1_flag_decode(HEVCContext *s, int c_idx, int inc)
 968 {
 969
 970     if (c_idx > 0)
 971         inc += 16;
 972
 973     return GET_CABAC(elem_offset[COEFF_ABS_LEVEL_GREATER1_FLAG] + inc);
 974 }
 975
 976 static av_always_inline int coeff_abs_level_greater2_flag_decode(HEVCContext *s, int c_idx, int inc)
 977 {
 978     if (c_idx > 0)
 979         inc += 4;
 980
 981     return GET_CABAC(elem_offset[COEFF_ABS_LEVEL_GREATER2_FLAG] + inc);
 982 }
 983
 984 static av_always_inline int coeff_abs_level_remaining_decode(HEVCContext *s, int rc_rice_param)
 985 {
 986     int prefix = 0;
 987     int suffix = 0;
 988     int last_coeff_abs_level_remaining;
 989     int i;
 990
 991     while (prefix < CABAC_MAX_BIN && get_cabac_bypass(&s->HEVClc->cc))
 992         prefix++;
 993     if (prefix == CABAC_MAX_BIN) {
 994         av_log(s->avctx, AV_LOG_ERROR, "CABAC_MAX_BIN : %d\n", prefix);
 995         return 0;
 996     }
 997     if (prefix < 3) {
 998         for (i = 0; i < rc_rice_param; i++)
 999             suffix = (suffix << 1) | get_cabac_bypass(&s->HEVClc->cc);
1000         last_coeff_abs_level_remaining = (prefix << rc_rice_param) + suffix;
1001     } else {
1002         int prefix_minus3 = prefix - 3;
1003         for (i = 0; i < prefix_minus3 + rc_rice_param; i++)
1004             suffix = (suffix << 1) | get_cabac_bypass(&s->HEVClc->cc);
1005         last_coeff_abs_level_remaining = (((1 << prefix_minus3) + 3 - 1)
1006                                               << rc_rice_param) + suffix;
1007     }
1008     return last_coeff_abs_level_remaining;
1009 }
1010
1011 static av_always_inline int coeff_sign_flag_decode(HEVCContext *s, uint8_t nb)
1012 {
1013     int i;
1014     int ret = 0;
1015
1016     for (i = 0; i < nb; i++)
1017         ret = (ret << 1) | get_cabac_bypass(&s->HEVClc->cc);
1018     return ret;
1019 }
1020
1021 void ff_hevc_hls_residual_coding(HEVCContext *s, int x0, int y0,
1022                                 int log2_trafo_size, enum ScanType scan_idx,
1023                                 int c_idx)
1024 {
1025 #define GET_COORD(offset, n)                                    \
1026     do {                                                        \
1027         x_c = (x_cg << 2) + scan_x_off[n];                      \
1028         y_c = (y_cg << 2) + scan_y_off[n];                      \
1029     } while (0)
1030     HEVCLocalContext *lc = s->HEVClc;
1031     int transform_skip_flag = 0;
1032
1033     int last_significant_coeff_x, last_significant_coeff_y;
1034     int last_scan_pos;
1035     int n_end;
1036     int num_coeff = 0;
1037     int greater1_ctx = 1;
1038
1039     int num_last_subset;
1040     int x_cg_last_sig, y_cg_last_sig;
1041
1042     const uint8_t *scan_x_cg, *scan_y_cg, *scan_x_off, *scan_y_off;
1043
1044     ptrdiff_t stride = s->frame->linesize[c_idx];
1045     int hshift = s->ps.sps->hshift[c_idx];
1046     int vshift = s->ps.sps->vshift[c_idx];
1047     uint8_t *dst = &s->frame->data[c_idx][(y0 >> vshift) * stride +
1048                                           ((x0 >> hshift) << s->ps.sps->pixel_shift)];
1049     int16_t *coeffs = (int16_t*)(c_idx ? lc->edge_emu_buffer2 : lc->edge_emu_buffer);
1050     uint8_t significant_coeff_group_flag[8][8] = {{0}};
1051     int explicit_rdpcm_flag = 0;
1052     int explicit_rdpcm_dir_flag;
1053
1054     int trafo_size = 1 << log2_trafo_size;
1055     int i;
1056     int qp,shift,add,scale,scale_m;
1057     static const uint8_t level_scale[] = { 40, 45, 51, 57, 64, 72 };
1058     const uint8_t *scale_matrix = NULL;
1059     uint8_t dc_scale;
1060     int pred_mode_intra = (c_idx == 0) ? lc->tu.intra_pred_mode :
1061                                          lc->tu.intra_pred_mode_c;
1062
1063     memset(coeffs, 0, trafo_size * trafo_size * sizeof(int16_t));
1064
1065     // Derive QP for dequant
1066     if (!lc->cu.cu_transquant_bypass_flag) {
1067         static const int qp_c[] = { 29, 30, 31, 32, 33, 33, 34, 34, 35, 35, 36, 36, 37, 37 };
1068         static const uint8_t rem6[51 + 4 * 6 + 1] = {
1069             0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2,
1070             3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5,
1071             0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3,
1072             4, 5, 0, 1, 2, 3, 4, 5, 0, 1
1073         };
1074
1075         static const uint8_t div6[51 + 4 * 6 + 1] = {
1076             0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 3,  3,  3,
1077             3, 3, 3, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6,  6,  6,
1078             7, 7, 7, 7, 7, 7, 8, 8, 8, 8, 8, 8, 9, 9, 9, 9, 9, 9, 10, 10, 10, 10,
1079             10, 10, 11, 11, 11, 11, 11, 11, 12, 12
1080         };
1081         int qp_y = lc->qp_y;
1082
1083         if (s->ps.pps->transform_skip_enabled_flag &&
1084             log2_trafo_size <= s->ps.pps->log2_max_transform_skip_block_size) {
1085             transform_skip_flag = hevc_transform_skip_flag_decode(s, c_idx);
1086         }
1087
1088         if (c_idx == 0) {
1089             qp = qp_y + s->ps.sps->qp_bd_offset;
1090         } else {
1091             int qp_i, offset;
1092
1093             if (c_idx == 1)
1094                 offset = s->ps.pps->cb_qp_offset + s->sh.slice_cb_qp_offset +
1095                          lc->tu.cu_qp_offset_cb;
1096             else
1097                 offset = s->ps.pps->cr_qp_offset + s->sh.slice_cr_qp_offset +
1098                          lc->tu.cu_qp_offset_cr;
1099
1100             qp_i = av_clip(qp_y + offset, - s->ps.sps->qp_bd_offset, 57);
1101             if (s->ps.sps->chroma_format_idc == 1) {
1102                 if (qp_i < 30)
1103                     qp = qp_i;
1104                 else if (qp_i > 43)
1105                     qp = qp_i - 6;
1106                 else
1107                     qp = qp_c[qp_i - 30];
1108             } else {
1109                 if (qp_i > 51)
1110                     qp = 51;
1111                 else
1112                     qp = qp_i;
1113             }
1114
1115             qp += s->ps.sps->qp_bd_offset;
1116         }
1117
1118         shift    = s->ps.sps->bit_depth + log2_trafo_size - 5;
1119         add      = 1 << (shift-1);
1120         scale    = level_scale[rem6[qp]] << (div6[qp]);
1121         scale_m  = 16; // default when no custom scaling lists.
1122         dc_scale = 16;
1123
1124         if (s->ps.sps->scaling_list_enable_flag && !(transform_skip_flag && log2_trafo_size > 2)) {
1125             const ScalingList *sl = s->ps.pps->scaling_list_data_present_flag ?
1126             &s->ps.pps->scaling_list : &s->ps.sps->scaling_list;
1127             int matrix_id = lc->cu.pred_mode != MODE_INTRA;
1128
1129             matrix_id = 3 * matrix_id + c_idx;
1130
1131             scale_matrix = sl->sl[log2_trafo_size - 2][matrix_id];
1132             if (log2_trafo_size >= 4)
1133                 dc_scale = sl->sl_dc[log2_trafo_size - 4][matrix_id];
1134         }
1135     } else {
1136         shift        = 0;
1137         add          = 0;
1138         scale        = 0;
1139         dc_scale     = 0;
1140     }
1141
1142     if (lc->cu.pred_mode == MODE_INTER && s->ps.sps->explicit_rdpcm_enabled_flag &&
1143         (transform_skip_flag || lc->cu.cu_transquant_bypass_flag)) {
1144         explicit_rdpcm_flag = explicit_rdpcm_flag_decode(s, c_idx);
1145         if (explicit_rdpcm_flag) {
1146             explicit_rdpcm_dir_flag = explicit_rdpcm_dir_flag_decode(s, c_idx);
1147         }
1148     }
1149
1150     last_significant_coeff_xy_prefix_decode(s, c_idx, log2_trafo_size,
1151                                            &last_significant_coeff_x, &last_significant_coeff_y);
1152
1153     if (last_significant_coeff_x > 3) {
1154         int suffix = last_significant_coeff_suffix_decode(s, last_significant_coeff_x);
1155         last_significant_coeff_x = (1 << ((last_significant_coeff_x >> 1) - 1)) *
1156         (2 + (last_significant_coeff_x & 1)) +
1157         suffix;
1158     }
1159
1160     if (last_significant_coeff_y > 3) {
1161         int suffix = last_significant_coeff_suffix_decode(s, last_significant_coeff_y);
1162         last_significant_coeff_y = (1 << ((last_significant_coeff_y >> 1) - 1)) *
1163         (2 + (last_significant_coeff_y & 1)) +
1164         suffix;
1165     }
1166
1167     if (scan_idx == SCAN_VERT)
1168         FFSWAP(int, last_significant_coeff_x, last_significant_coeff_y);
1169
1170     x_cg_last_sig = last_significant_coeff_x >> 2;
1171     y_cg_last_sig = last_significant_coeff_y >> 2;
1172
1173     switch (scan_idx) {
1174     case SCAN_DIAG: {
1175         int last_x_c = last_significant_coeff_x & 3;
1176         int last_y_c = last_significant_coeff_y & 3;
1177
1178         scan_x_off = ff_hevc_diag_scan4x4_x;
1179         scan_y_off = ff_hevc_diag_scan4x4_y;
1180         num_coeff = diag_scan4x4_inv[last_y_c][last_x_c];
1181         if (trafo_size == 4) {
1182             scan_x_cg = scan_1x1;
1183             scan_y_cg = scan_1x1;
1184         } else if (trafo_size == 8) {
1185             num_coeff += diag_scan2x2_inv[y_cg_last_sig][x_cg_last_sig] << 4;
1186             scan_x_cg = diag_scan2x2_x;
1187             scan_y_cg = diag_scan2x2_y;
1188         } else if (trafo_size == 16) {
1189             num_coeff += diag_scan4x4_inv[y_cg_last_sig][x_cg_last_sig] << 4;
1190             scan_x_cg = ff_hevc_diag_scan4x4_x;
1191             scan_y_cg = ff_hevc_diag_scan4x4_y;
1192         } else { // trafo_size == 32
1193             num_coeff += diag_scan8x8_inv[y_cg_last_sig][x_cg_last_sig] << 4;
1194             scan_x_cg = ff_hevc_diag_scan8x8_x;
1195             scan_y_cg = ff_hevc_diag_scan8x8_y;
1196         }
1197         break;
1198     }
1199     case SCAN_HORIZ:
1200         scan_x_cg = horiz_scan2x2_x;
1201         scan_y_cg = horiz_scan2x2_y;
1202         scan_x_off = horiz_scan4x4_x;
1203         scan_y_off = horiz_scan4x4_y;
1204         num_coeff = horiz_scan8x8_inv[last_significant_coeff_y][last_significant_coeff_x];
1205         break;
1206     default: //SCAN_VERT
1207         scan_x_cg = horiz_scan2x2_y;
1208         scan_y_cg = horiz_scan2x2_x;
1209         scan_x_off = horiz_scan4x4_y;
1210         scan_y_off = horiz_scan4x4_x;
1211         num_coeff = horiz_scan8x8_inv[last_significant_coeff_x][last_significant_coeff_y];
1212         break;
1213     }
1214     num_coeff++;
1215     num_last_subset = (num_coeff - 1) >> 4;
1216
1217     for (i = num_last_subset; i >= 0; i--) {
1218         int n, m;
1219         int x_cg, y_cg, x_c, y_c, pos;
1220         int implicit_non_zero_coeff = 0;
1221         int64_t trans_coeff_level;
1222         int prev_sig = 0;
1223         int offset = i << 4;
1224         int rice_init = 0;
1225
1226         uint8_t significant_coeff_flag_idx[16];
1227         uint8_t nb_significant_coeff_flag = 0;
1228
1229         x_cg = scan_x_cg[i];
1230         y_cg = scan_y_cg[i];
1231
1232         if ((i < num_last_subset) && (i > 0)) {
1233             int ctx_cg = 0;
1234             if (x_cg < (1 << (log2_trafo_size - 2)) - 1)
1235                 ctx_cg += significant_coeff_group_flag[x_cg + 1][y_cg];
1236             if (y_cg < (1 << (log2_trafo_size - 2)) - 1)
1237                 ctx_cg += significant_coeff_group_flag[x_cg][y_cg + 1];
1238
1239             significant_coeff_group_flag[x_cg][y_cg] =
1240                 significant_coeff_group_flag_decode(s, c_idx, ctx_cg);
1241             implicit_non_zero_coeff = 1;
1242         } else {
1243             significant_coeff_group_flag[x_cg][y_cg] =
1244             ((x_cg == x_cg_last_sig && y_cg == y_cg_last_sig) ||
1245              (x_cg == 0 && y_cg == 0));
1246         }
1247
1248         last_scan_pos = num_coeff - offset - 1;
1249
1250         if (i == num_last_subset) {
1251             n_end = last_scan_pos - 1;
1252             significant_coeff_flag_idx[0] = last_scan_pos;
1253             nb_significant_coeff_flag = 1;
1254         } else {
1255             n_end = 15;
1256         }
1257
1258         if (x_cg < ((1 << log2_trafo_size) - 1) >> 2)
1259             prev_sig = !!significant_coeff_group_flag[x_cg + 1][y_cg];
1260         if (y_cg < ((1 << log2_trafo_size) - 1) >> 2)
1261             prev_sig += (!!significant_coeff_group_flag[x_cg][y_cg + 1] << 1);
1262
1263         if (significant_coeff_group_flag[x_cg][y_cg] && n_end >= 0) {
1264             static const uint8_t ctx_idx_map[] = {
1265                 0, 1, 4, 5, 2, 3, 4, 5, 6, 6, 8, 8, 7, 7, 8, 8, // log2_trafo_size == 2
1266                 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, // prev_sig == 0
1267                 2, 2, 2, 2, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, // prev_sig == 1
1268                 2, 1, 0, 0, 2, 1, 0, 0, 2, 1, 0, 0, 2, 1, 0, 0, // prev_sig == 2
1269                 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2  // default
1270             };
1271             const uint8_t *ctx_idx_map_p;
1272             int scf_offset = 0;
1273             if (s->ps.sps->transform_skip_context_enabled_flag &&
1274                 (transform_skip_flag || lc->cu.cu_transquant_bypass_flag)) {
1275                 ctx_idx_map_p = (uint8_t*) &ctx_idx_map[4 * 16];
1276                 if (c_idx == 0) {
1277                     scf_offset = 40;
1278                 } else {
1279                     scf_offset = 14 + 27;
1280                 }
1281             } else {
1282                 if (c_idx != 0)
1283                     scf_offset = 27;
1284                 if (log2_trafo_size == 2) {
1285                     ctx_idx_map_p = (uint8_t*) &ctx_idx_map[0];
1286                 } else {
1287                     ctx_idx_map_p = (uint8_t*) &ctx_idx_map[(prev_sig + 1) << 4];
1288                     if (c_idx == 0) {
1289                         if ((x_cg > 0 || y_cg > 0))
1290                             scf_offset += 3;
1291                         if (log2_trafo_size == 3) {
1292                             scf_offset += (scan_idx == SCAN_DIAG) ? 9 : 15;
1293                         } else {
1294                             scf_offset += 21;
1295                         }
1296                     } else {
1297                         if (log2_trafo_size == 3)
1298                             scf_offset += 9;
1299                         else
1300                             scf_offset += 12;
1301                     }
1302                 }
1303             }
1304             for (n = n_end; n > 0; n--) {
1305                 x_c = scan_x_off[n];
1306                 y_c = scan_y_off[n];
1307                 if (significant_coeff_flag_decode(s, x_c, y_c, scf_offset, ctx_idx_map_p)) {
1308                     significant_coeff_flag_idx[nb_significant_coeff_flag] = n;
1309                     nb_significant_coeff_flag++;
1310                     implicit_non_zero_coeff = 0;
1311                 }
1312             }
1313             if (implicit_non_zero_coeff == 0) {
1314                 if (s->ps.sps->transform_skip_context_enabled_flag &&
1315                     (transform_skip_flag || lc->cu.cu_transquant_bypass_flag)) {
1316                     if (c_idx == 0) {
1317                         scf_offset = 42;
1318                     } else {
1319                         scf_offset = 16 + 27;
1320                     }
1321                 } else {
1322                     if (i == 0) {
1323                         if (c_idx == 0)
1324                             scf_offset = 0;
1325                         else
1326                             scf_offset = 27;
1327                     } else {
1328                         scf_offset = 2 + scf_offset;
1329                     }
1330                 }
1331                 if (significant_coeff_flag_decode_0(s, c_idx, scf_offset) == 1) {
1332                     significant_coeff_flag_idx[nb_significant_coeff_flag] = 0;
1333                     nb_significant_coeff_flag++;
1334                 }
1335             } else {
1336                 significant_coeff_flag_idx[nb_significant_coeff_flag] = 0;
1337                 nb_significant_coeff_flag++;
1338             }
1339         }
1340
1341         n_end = nb_significant_coeff_flag;
1342
1343
1344         if (n_end) {
1345             int first_nz_pos_in_cg;
1346             int last_nz_pos_in_cg;
1347             int c_rice_param = 0;
1348             int first_greater1_coeff_idx = -1;
1349             uint8_t coeff_abs_level_greater1_flag[8];
1350             uint16_t coeff_sign_flag;
1351             int sum_abs = 0;
1352             int sign_hidden;
1353             int sb_type;
1354
1355
1356             // initialize first elem of coeff_bas_level_greater1_flag
1357             int ctx_set = (i > 0 && c_idx == 0) ? 2 : 0;
1358
1359             if (s->ps.sps->persistent_rice_adaptation_enabled_flag) {
1360                 if (!transform_skip_flag && !lc->cu.cu_transquant_bypass_flag)
1361                     sb_type = 2 * (c_idx == 0 ? 1 : 0);
1362                 else
1363                     sb_type = 2 * (c_idx == 0 ? 1 : 0) + 1;
1364                 c_rice_param = lc->stat_coeff[sb_type] / 4;
1365             }
1366
1367             if (!(i == num_last_subset) && greater1_ctx == 0)
1368                 ctx_set++;
1369             greater1_ctx = 1;
1370             last_nz_pos_in_cg = significant_coeff_flag_idx[0];
1371
1372             for (m = 0; m < (n_end > 8 ? 8 : n_end); m++) {
1373                 int inc = (ctx_set << 2) + greater1_ctx;
1374                 coeff_abs_level_greater1_flag[m] =
1375                     coeff_abs_level_greater1_flag_decode(s, c_idx, inc);
1376                 if (coeff_abs_level_greater1_flag[m]) {
1377                     greater1_ctx = 0;
1378                     if (first_greater1_coeff_idx == -1)
1379                         first_greater1_coeff_idx = m;
1380                 } else if (greater1_ctx > 0 && greater1_ctx < 3) {
1381                     greater1_ctx++;
1382                 }
1383             }
1384             first_nz_pos_in_cg = significant_coeff_flag_idx[n_end - 1];
1385
1386             if (lc->cu.cu_transquant_bypass_flag ||
1387                 (lc->cu.pred_mode ==  MODE_INTRA  &&
1388                  s->ps.sps->implicit_rdpcm_enabled_flag  &&  transform_skip_flag  &&
1389                  (pred_mode_intra == 10 || pred_mode_intra  ==  26 )) ||
1390                  explicit_rdpcm_flag)
1391                 sign_hidden = 0;
1392             else
1393                 sign_hidden = (last_nz_pos_in_cg - first_nz_pos_in_cg >= 4);
1394
1395             if (first_greater1_coeff_idx != -1) {
1396                 coeff_abs_level_greater1_flag[first_greater1_coeff_idx] += coeff_abs_level_greater2_flag_decode(s, c_idx, ctx_set);
1397             }
1398             if (!s->ps.pps->sign_data_hiding_flag || !sign_hidden ) {
1399                 coeff_sign_flag = coeff_sign_flag_decode(s, nb_significant_coeff_flag) << (16 - nb_significant_coeff_flag);
1400             } else {
1401                 coeff_sign_flag = coeff_sign_flag_decode(s, nb_significant_coeff_flag - 1) << (16 - (nb_significant_coeff_flag - 1));
1402             }
1403
1404             for (m = 0; m < n_end; m++) {
1405                 n = significant_coeff_flag_idx[m];
1406                 GET_COORD(offset, n);
1407                 if (m < 8) {
1408                     trans_coeff_level = 1 + coeff_abs_level_greater1_flag[m];
1409                     if (trans_coeff_level == ((m == first_greater1_coeff_idx) ? 3 : 2)) {
1410                         int last_coeff_abs_level_remaining = coeff_abs_level_remaining_decode(s, c_rice_param);
1411
1412                         trans_coeff_level += last_coeff_abs_level_remaining;
1413                         if (trans_coeff_level > (3 << c_rice_param))
1414                             c_rice_param = s->ps.sps->persistent_rice_adaptation_enabled_flag ? c_rice_param + 1 : FFMIN(c_rice_param + 1, 4);
1415                         if (s->ps.sps->persistent_rice_adaptation_enabled_flag && !rice_init) {
1416                             int c_rice_p_init = lc->stat_coeff[sb_type] / 4;
1417                             if (last_coeff_abs_level_remaining >= (3 << c_rice_p_init))
1418                                 lc->stat_coeff[sb_type]++;
1419                             else if (2 * last_coeff_abs_level_remaining < (1 << c_rice_p_init))
1420                                 if (lc->stat_coeff[sb_type] > 0)
1421                                     lc->stat_coeff[sb_type]--;
1422                             rice_init = 1;
1423                         }
1424                     }
1425                 } else {
1426                     int last_coeff_abs_level_remaining = coeff_abs_level_remaining_decode(s, c_rice_param);
1427
1428                     trans_coeff_level = 1 + last_coeff_abs_level_remaining;
1429                     if (trans_coeff_level > (3 << c_rice_param))
1430                         c_rice_param = s->ps.sps->persistent_rice_adaptation_enabled_flag ? c_rice_param + 1 : FFMIN(c_rice_param + 1, 4);
1431                     if (s->ps.sps->persistent_rice_adaptation_enabled_flag && !rice_init) {
1432                         int c_rice_p_init = lc->stat_coeff[sb_type] / 4;
1433                         if (last_coeff_abs_level_remaining >= (3 << c_rice_p_init))
1434                             lc->stat_coeff[sb_type]++;
1435                         else if (2 * last_coeff_abs_level_remaining < (1 << c_rice_p_init))
1436                             if (lc->stat_coeff[sb_type] > 0)
1437                                 lc->stat_coeff[sb_type]--;
1438                         rice_init = 1;
1439                     }
1440                 }
1441                 if (s->ps.pps->sign_data_hiding_flag && sign_hidden) {
1442                     sum_abs += trans_coeff_level;
1443                     if (n == first_nz_pos_in_cg && (sum_abs&1))
1444                         trans_coeff_level = -trans_coeff_level;
1445                 }
1446                 if (coeff_sign_flag >> 15)
1447                     trans_coeff_level = -trans_coeff_level;
1448                 coeff_sign_flag <<= 1;
1449                 if(!lc->cu.cu_transquant_bypass_flag) {
1450                     if (s->ps.sps->scaling_list_enable_flag && !(transform_skip_flag && log2_trafo_size > 2)) {
1451                         if(y_c || x_c || log2_trafo_size < 4) {
1452                             switch(log2_trafo_size) {
1453                                 case 3: pos = (y_c << 3) + x_c; break;
1454                                 case 4: pos = ((y_c >> 1) << 3) + (x_c >> 1); break;
1455                                 case 5: pos = ((y_c >> 2) << 3) + (x_c >> 2); break;
1456                                 default: pos = (y_c << 2) + x_c; break;
1457                             }
1458                             scale_m = scale_matrix[pos];
1459                         } else {
1460                             scale_m = dc_scale;
1461                         }
1462                     }
1463                     trans_coeff_level = (trans_coeff_level * (int64_t)scale * (int64_t)scale_m + add) >> shift;
1464                     if(trans_coeff_level < 0) {
1465                         if((~trans_coeff_level) & 0xFffffffffff8000)
1466                             trans_coeff_level = -32768;
1467                     } else {
1468                         if(trans_coeff_level & 0xffffffffffff8000)
1469                             trans_coeff_level = 32767;
1470                     }
1471                 }
1472                 coeffs[y_c * trafo_size + x_c] = trans_coeff_level;
1473             }
1474         }
1475     }
1476
1477     if (lc->cu.cu_transquant_bypass_flag) {
1478         if (explicit_rdpcm_flag || (s->ps.sps->implicit_rdpcm_enabled_flag &&
1479                                     (pred_mode_intra == 10 || pred_mode_intra == 26))) {
1480             int mode = s->ps.sps->implicit_rdpcm_enabled_flag ? (pred_mode_intra == 26) : explicit_rdpcm_dir_flag;
1481
1482             s->hevcdsp.transform_rdpcm(coeffs, log2_trafo_size, mode);
1483         }
1484     } else {
1485         if (transform_skip_flag) {
1486             int rot = s->ps.sps->transform_skip_rotation_enabled_flag &&
1487                       log2_trafo_size == 2 &&
1488                       lc->cu.pred_mode == MODE_INTRA;
1489             if (rot) {
1490                 for (i = 0; i < 8; i++)
1491                     FFSWAP(int16_t, coeffs[i], coeffs[16 - i - 1]);
1492             }
1493
1494             s->hevcdsp.dequant(coeffs, log2_trafo_size);
1495
1496             if (explicit_rdpcm_flag || (s->ps.sps->implicit_rdpcm_enabled_flag &&
1497                                         lc->cu.pred_mode == MODE_INTRA &&
1498                                         (pred_mode_intra == 10 || pred_mode_intra == 26))) {
1499                 int mode = explicit_rdpcm_flag ? explicit_rdpcm_dir_flag : (pred_mode_intra == 26);
1500
1501                 s->hevcdsp.transform_rdpcm(coeffs, log2_trafo_size, mode);
1502             }
1503         } else if (lc->cu.pred_mode == MODE_INTRA && c_idx == 0 && log2_trafo_size == 2) {
1504             s->hevcdsp.transform_4x4_luma(coeffs);
1505         } else {
1506             int max_xy = FFMAX(last_significant_coeff_x, last_significant_coeff_y);
1507             if (max_xy == 0)
1508                 s->hevcdsp.idct_dc[log2_trafo_size - 2](coeffs);
1509             else {
1510                 int col_limit = last_significant_coeff_x + last_significant_coeff_y + 4;
1511                 if (max_xy < 4)
1512                     col_limit = FFMIN(4, col_limit);
1513                 else if (max_xy < 8)
1514                     col_limit = FFMIN(8, col_limit);
1515                 else if (max_xy < 12)
1516                     col_limit = FFMIN(24, col_limit);
1517                 s->hevcdsp.idct[log2_trafo_size - 2](coeffs, col_limit);
1518             }
1519         }
1520     }
1521     if (lc->tu.cross_pf) {
1522         int16_t *coeffs_y = (int16_t*)lc->edge_emu_buffer;
1523
1524         for (i = 0; i < (trafo_size * trafo_size); i++) {
1525             coeffs[i] = coeffs[i] + ((lc->tu.res_scale_val * coeffs_y[i]) >> 3);
1526         }
1527     }
1528     s->hevcdsp.add_residual[log2_trafo_size-2](dst, coeffs, stride);
1529 }
1530
1531 void ff_hevc_hls_mvd_coding(HEVCContext *s, int x0, int y0, int log2_cb_size)
1532 {
1533     HEVCLocalContext *lc = s->HEVClc;
1534     int x = abs_mvd_greater0_flag_decode(s);
1535     int y = abs_mvd_greater0_flag_decode(s);
1536
1537     if (x)
1538         x += abs_mvd_greater1_flag_decode(s);
1539     if (y)
1540         y += abs_mvd_greater1_flag_decode(s);
1541
1542     switch (x) {
1543     case 2: lc->pu.mvd.x = mvd_decode(s);           break;
1544     case 1: lc->pu.mvd.x = mvd_sign_flag_decode(s); break;
1545     case 0: lc->pu.mvd.x = 0;                       break;
1546     }
1547
1548     switch (y) {
1549     case 2: lc->pu.mvd.y = mvd_decode(s);           break;
1550     case 1: lc->pu.mvd.y = mvd_sign_flag_decode(s); break;
1551     case 0: lc->pu.mvd.y = 0;                       break;
1552     }
1553 }
1554