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

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