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

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