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