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

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