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 Libav.
   8  *
   9  * Libav 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  * Libav 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 Libav; if not, write to the Free Software
  21  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  22  */
  23
  24 #include "libavutil/attributes.h"
  25 #include "libavutil/common.h"
  26
  27 #include "cabac_functions.h"
  28 #include "hevc.h"
  29 #include "hevcdec.h"
  30
  31 #define CABAC_MAX_BIN 31
  32
  33 /**
  34  * number of bin by SyntaxElement.
  35  */
  36 static const int8_t num_bins_in_se[] = {
  37      1, // sao_merge_flag
  38      1, // sao_type_idx
  39      0, // sao_eo_class
  40      0, // sao_band_position
  41      0, // sao_offset_abs
  42      0, // sao_offset_sign
  43      0, // end_of_slice_flag
  44      3, // split_coding_unit_flag
  45      1, // cu_transquant_bypass_flag
  46      3, // skip_flag
  47      3, // cu_qp_delta
  48      1, // pred_mode
  49      4, // part_mode
  50      0, // pcm_flag
  51      1, // prev_intra_luma_pred_mode
  52      0, // mpm_idx
  53      0, // rem_intra_luma_pred_mode
  54      2, // intra_chroma_pred_mode
  55      1, // merge_flag
  56      1, // merge_idx
  57      5, // inter_pred_idc
  58      2, // ref_idx_l0
  59      2, // ref_idx_l1
  60      2, // abs_mvd_greater0_flag
  61      2, // abs_mvd_greater1_flag
  62      0, // abs_mvd_minus2
  63      0, // mvd_sign_flag
  64      1, // mvp_lx_flag
  65      1, // no_residual_data_flag
  66      3, // split_transform_flag
  67      2, // cbf_luma
  68      4, // cbf_cb, cbf_cr
  69      2, // transform_skip_flag[][]
  70     18, // last_significant_coeff_x_prefix
  71     18, // last_significant_coeff_y_prefix
  72      0, // last_significant_coeff_x_suffix
  73      0, // last_significant_coeff_y_suffix
  74      4, // significant_coeff_group_flag
  75     42, // significant_coeff_flag
  76     24, // coeff_abs_level_greater1_flag
  77      6, // coeff_abs_level_greater2_flag
  78      0, // coeff_abs_level_remaining
  79      0, // coeff_sign_flag
  80 };
  81
  82 /**
  83  * Offset to ctxIdx 0 in init_values and states, indexed by SyntaxElement.
  84  */
  85 static const int elem_offset[sizeof(num_bins_in_se)] = {
  86       0,
  87       1,
  88       2,
  89       2,
  90       2,
  91       2,
  92       2,
  93       2,
  94       5,
  95       6,
  96       9,
  97      12,
  98      13,
  99      17,
 100      17,
 101      18,
 102      18,
 103      18,
 104      20,
 105      21,
 106      22,
 107      27,
 108      29,
 109      31,
 110      33,
 111      35,
 112      35,
 113      35,
 114      36,
 115      37,
 116      40,
 117      42,
 118      46,
 119      48,
 120      66,
 121      84,
 122      84,
 123      84,
 124      88,
 125     130,
 126     154,
 127     160,
 128     160,
 129 };
 130
 131 #define CNU 154
 132 /**
 133  * Indexed by init_type
 134  */
 135 static const uint8_t init_values[3][HEVC_CONTEXTS] = {
 136     { // sao_merge_flag
 137       153,
 138       // sao_type_idx
 139       200,
 140       // split_coding_unit_flag
 141       139, 141, 157,
 142       // cu_transquant_bypass_flag
 143       154,
 144       // skip_flag
 145       CNU, CNU, CNU,
 146       // cu_qp_delta
 147       154, 154, 154,
 148       // pred_mode
 149       CNU,
 150       // part_mode
 151       184, CNU, CNU, CNU,
 152       // prev_intra_luma_pred_mode
 153       184,
 154       // intra_chroma_pred_mode
 155       63, 139,
 156       // merge_flag
 157       CNU,
 158       // merge_idx
 159       CNU,
 160       // inter_pred_idc
 161       CNU, CNU, CNU, CNU, CNU,
 162       // ref_idx_l0
 163       CNU, CNU,
 164       // ref_idx_l1
 165       CNU, CNU,
 166       // abs_mvd_greater1_flag
 167       CNU, CNU,
 168       // abs_mvd_greater1_flag
 169       CNU, CNU,
 170       // mvp_lx_flag
 171       CNU,
 172       // no_residual_data_flag
 173       CNU,
 174       // split_transform_flag
 175       153, 138, 138,
 176       // cbf_luma
 177       111, 141,
 178       // cbf_cb, cbf_cr
 179       94, 138, 182, 154,
 180       // transform_skip_flag
 181       139, 139,
 182       // last_significant_coeff_x_prefix
 183       110, 110, 124, 125, 140, 153, 125, 127, 140, 109, 111, 143, 127, 111,
 184        79, 108, 123,  63,
 185       // last_significant_coeff_y_prefix
 186       110, 110, 124, 125, 140, 153, 125, 127, 140, 109, 111, 143, 127, 111,
 187        79, 108, 123,  63,
 188       // significant_coeff_group_flag
 189       91, 171, 134, 141,
 190       // significant_coeff_flag
 191       111, 111, 125, 110, 110,  94, 124, 108, 124, 107, 125, 141, 179, 153,
 192       125, 107, 125, 141, 179, 153, 125, 107, 125, 141, 179, 153, 125, 140,
 193       139, 182, 182, 152, 136, 152, 136, 153, 136, 139, 111, 136, 139, 111,
 194       // coeff_abs_level_greater1_flag
 195       140,  92, 137, 138, 140, 152, 138, 139, 153,  74, 149,  92, 139, 107,
 196       122, 152, 140, 179, 166, 182, 140, 227, 122, 197,
 197       // coeff_abs_level_greater2_flag
 198       138, 153, 136, 167, 152, 152, },
 199     { // sao_merge_flag
 200       153,
 201       // sao_type_idx
 202       185,
 203       // split_coding_unit_flag
 204       107, 139, 126,
 205       // cu_transquant_bypass_flag
 206       154,
 207       // skip_flag
 208       197, 185, 201,
 209       // cu_qp_delta
 210       154, 154, 154,
 211       // pred_mode
 212       149,
 213       // part_mode
 214       154, 139, 154, 154,
 215       // prev_intra_luma_pred_mode
 216       154,
 217       // intra_chroma_pred_mode
 218       152, 139,
 219       // merge_flag
 220       110,
 221       // merge_idx
 222       122,
 223       // inter_pred_idc
 224       95, 79, 63, 31, 31,
 225       // ref_idx_l0
 226       153, 153,
 227       // ref_idx_l1
 228       153, 153,
 229       // abs_mvd_greater1_flag
 230       140, 198,
 231       // abs_mvd_greater1_flag
 232       140, 198,
 233       // mvp_lx_flag
 234       168,
 235       // no_residual_data_flag
 236       79,
 237       // split_transform_flag
 238       124, 138, 94,
 239       // cbf_luma
 240       153, 111,
 241       // cbf_cb, cbf_cr
 242       149, 107, 167, 154,
 243       // transform_skip_flag
 244       139, 139,
 245       // last_significant_coeff_x_prefix
 246       125, 110,  94, 110,  95,  79, 125, 111, 110,  78, 110, 111, 111,  95,
 247        94, 108, 123, 108,
 248       // last_significant_coeff_y_prefix
 249       125, 110,  94, 110,  95,  79, 125, 111, 110,  78, 110, 111, 111,  95,
 250        94, 108, 123, 108,
 251       // significant_coeff_group_flag
 252       121, 140, 61, 154,
 253       // significant_coeff_flag
 254       155, 154, 139, 153, 139, 123, 123,  63, 153, 166, 183, 140, 136, 153,
 255       154, 166, 183, 140, 136, 153, 154, 166, 183, 140, 136, 153, 154, 170,
 256       153, 123, 123, 107, 121, 107, 121, 167, 151, 183, 140, 151, 183, 140,
 257       // coeff_abs_level_greater1_flag
 258       154, 196, 196, 167, 154, 152, 167, 182, 182, 134, 149, 136, 153, 121,
 259       136, 137, 169, 194, 166, 167, 154, 167, 137, 182,
 260       // coeff_abs_level_greater2_flag
 261       107, 167, 91, 122, 107, 167, },
 262     { // sao_merge_flag
 263       153,
 264       // sao_type_idx
 265       160,
 266       // split_coding_unit_flag
 267       107, 139, 126,
 268       // cu_transquant_bypass_flag
 269       154,
 270       // skip_flag
 271       197, 185, 201,
 272       // cu_qp_delta
 273       154, 154, 154,
 274       // pred_mode
 275       134,
 276       // part_mode
 277       154, 139, 154, 154,
 278       // prev_intra_luma_pred_mode
 279       183,
 280       // intra_chroma_pred_mode
 281       152, 139,
 282       // merge_flag
 283       154,
 284       // merge_idx
 285       137,
 286       // inter_pred_idc
 287       95, 79, 63, 31, 31,
 288       // ref_idx_l0
 289       153, 153,
 290       // ref_idx_l1
 291       153, 153,
 292       // abs_mvd_greater1_flag
 293       169, 198,
 294       // abs_mvd_greater1_flag
 295       169, 198,
 296       // mvp_lx_flag
 297       168,
 298       // no_residual_data_flag
 299       79,
 300       // split_transform_flag
 301       224, 167, 122,
 302       // cbf_luma
 303       153, 111,
 304       // cbf_cb, cbf_cr
 305       149, 92, 167, 154,
 306       // transform_skip_flag
 307       139, 139,
 308       // last_significant_coeff_x_prefix
 309       125, 110, 124, 110,  95,  94, 125, 111, 111,  79, 125, 126, 111, 111,
 310        79, 108, 123,  93,
 311       // last_significant_coeff_y_prefix
 312       125, 110, 124, 110,  95,  94, 125, 111, 111,  79, 125, 126, 111, 111,
 313        79, 108, 123,  93,
 314       // significant_coeff_group_flag
 315       121, 140, 61, 154,
 316       // significant_coeff_flag
 317       170, 154, 139, 153, 139, 123, 123,  63, 124, 166, 183, 140, 136, 153,
 318       154, 166, 183, 140, 136, 153, 154, 166, 183, 140, 136, 153, 154, 170,
 319       153, 138, 138, 122, 121, 122, 121, 167, 151, 183, 140, 151, 183, 140,
 320       // coeff_abs_level_greater1_flag
 321       154, 196, 167, 167, 154, 152, 167, 182, 182, 134, 149, 136, 153, 121,
 322       136, 122, 169, 208, 166, 167, 154, 152, 167, 182,
 323       // coeff_abs_level_greater2_flag
 324       107, 167, 91, 107, 107, 167, },
 325 };
 326
 327 void ff_hevc_save_states(HEVCContext *s, int ctb_addr_ts)
 328 {
 329     if (s->ps.pps->entropy_coding_sync_enabled_flag &&
 330         (ctb_addr_ts % s->ps.sps->ctb_width == 2 ||
 331          (s->ps.sps->ctb_width == 2 &&
 332           ctb_addr_ts % s->ps.sps->ctb_width == 0))) {
 333         memcpy(s->cabac_state, s->HEVClc.cabac_state, HEVC_CONTEXTS);
 334     }
 335 }
 336
 337 static void load_states(HEVCContext *s)
 338 {
 339     memcpy(s->HEVClc.cabac_state, s->cabac_state, HEVC_CONTEXTS);
 340 }
 341
 342 static void cabac_reinit(HEVCLocalContext *lc)
 343 {
 344     skip_bytes(&lc->cc, 0);
 345 }
 346
 347 static void cabac_init_decoder(HEVCContext *s)
 348 {
 349     GetBitContext *gb = &s->HEVClc.gb;
 350     skip_bits(gb, 1);
 351     align_get_bits(gb);
 352     ff_init_cabac_decoder(&s->HEVClc.cc,
 353                           gb->buffer + get_bits_count(gb) / 8,
 354                           (get_bits_left(gb) + 7) / 8);
 355 }
 356
 357 static void cabac_init_state(HEVCContext *s)
 358 {
 359     int init_type = 2 - s->sh.slice_type;
 360     int i;
 361
 362     if (s->sh.cabac_init_flag && s->sh.slice_type != HEVC_SLICE_I)
 363         init_type ^= 3;
 364
 365     for (i = 0; i < HEVC_CONTEXTS; i++) {
 366         int init_value = init_values[init_type][i];
 367         int m = (init_value >> 4) * 5 - 45;
 368         int n = ((init_value & 15) << 3) - 16;
 369         int pre = 2 * (((m * av_clip(s->sh.slice_qp, 0, 51)) >> 4) + n) - 127;
 370
 371         pre ^= pre >> 31;
 372         if (pre > 124)
 373             pre = 124 + (pre & 1);
 374         s->HEVClc.cabac_state[i] = pre;
 375     }
 376 }
 377
 378 void ff_hevc_cabac_init(HEVCContext *s, int ctb_addr_ts)
 379 {
 380     if (ctb_addr_ts == s->ps.pps->ctb_addr_rs_to_ts[s->sh.slice_ctb_addr_rs]) {
 381         cabac_init_decoder(s);
 382         if (s->sh.dependent_slice_segment_flag == 0 ||
 383             (s->ps.pps->tiles_enabled_flag &&
 384              s->ps.pps->tile_id[ctb_addr_ts] != s->ps.pps->tile_id[ctb_addr_ts - 1]))
 385             cabac_init_state(s);
 386
 387         if (!s->sh.first_slice_in_pic_flag &&
 388             s->ps.pps->entropy_coding_sync_enabled_flag) {
 389             if (ctb_addr_ts % s->ps.sps->ctb_width == 0) {
 390                 if (s->ps.sps->ctb_width == 1)
 391                     cabac_init_state(s);
 392                 else if (s->sh.dependent_slice_segment_flag == 1)
 393                     load_states(s);
 394             }
 395         }
 396     } else {
 397         if (s->ps.pps->tiles_enabled_flag &&
 398             s->ps.pps->tile_id[ctb_addr_ts] != s->ps.pps->tile_id[ctb_addr_ts - 1]) {
 399             cabac_reinit(&s->HEVClc);
 400             cabac_init_state(s);
 401         }
 402         if (s->ps.pps->entropy_coding_sync_enabled_flag) {
 403             if (ctb_addr_ts % s->ps.sps->ctb_width == 0) {
 404                 get_cabac_terminate(&s->HEVClc.cc);
 405                 cabac_reinit(&s->HEVClc);
 406
 407                 if (s->ps.sps->ctb_width == 1)
 408                     cabac_init_state(s);
 409                 else
 410                     load_states(s);
 411             }
 412         }
 413     }
 414 }
 415
 416 #define GET_CABAC(ctx) get_cabac(&s->HEVClc.cc, &s->HEVClc.cabac_state[ctx])
 417
 418 int ff_hevc_sao_merge_flag_decode(HEVCContext *s)
 419 {
 420     return GET_CABAC(elem_offset[SAO_MERGE_FLAG]);
 421 }
 422
 423 int ff_hevc_sao_type_idx_decode(HEVCContext *s)
 424 {
 425     if (!GET_CABAC(elem_offset[SAO_TYPE_IDX]))
 426         return 0;
 427
 428     if (!get_cabac_bypass(&s->HEVClc.cc))
 429         return SAO_BAND;
 430     return SAO_EDGE;
 431 }
 432
 433 int ff_hevc_sao_band_position_decode(HEVCContext *s)
 434 {
 435     int i;
 436     int value = get_cabac_bypass(&s->HEVClc.cc);
 437
 438     for (i = 0; i < 4; i++)
 439         value = (value << 1) | get_cabac_bypass(&s->HEVClc.cc);
 440     return value;
 441 }
 442
 443 int ff_hevc_sao_offset_abs_decode(HEVCContext *s)
 444 {
 445     int i = 0;
 446     int length = (1 << (FFMIN(s->ps.sps->bit_depth, 10) - 5)) - 1;
 447
 448     while (i < length && get_cabac_bypass(&s->HEVClc.cc))
 449         i++;
 450     return i;
 451 }
 452
 453 int ff_hevc_sao_offset_sign_decode(HEVCContext *s)
 454 {
 455     return get_cabac_bypass(&s->HEVClc.cc);
 456 }
 457
 458 int ff_hevc_sao_eo_class_decode(HEVCContext *s)
 459 {
 460     int ret = get_cabac_bypass(&s->HEVClc.cc) << 1;
 461     ret    |= get_cabac_bypass(&s->HEVClc.cc);
 462     return ret;
 463 }
 464
 465 int ff_hevc_end_of_slice_flag_decode(HEVCContext *s)
 466 {
 467     return get_cabac_terminate(&s->HEVClc.cc);
 468 }
 469
 470 int ff_hevc_cu_transquant_bypass_flag_decode(HEVCContext *s)
 471 {
 472     return GET_CABAC(elem_offset[CU_TRANSQUANT_BYPASS_FLAG]);
 473 }
 474
 475 int ff_hevc_skip_flag_decode(HEVCContext *s, int x0, int y0, int x_cb, int y_cb)
 476 {
 477     int min_cb_width = s->ps.sps->min_cb_width;
 478     int inc = 0;
 479     int x0b = x0 & ((1 << s->ps.sps->log2_ctb_size) - 1);
 480     int y0b = y0 & ((1 << s->ps.sps->log2_ctb_size) - 1);
 481
 482     if (s->HEVClc.ctb_left_flag || x0b)
 483         inc = !!SAMPLE_CTB(s->skip_flag, x_cb - 1, y_cb);
 484     if (s->HEVClc.ctb_up_flag || y0b)
 485         inc += !!SAMPLE_CTB(s->skip_flag, x_cb, y_cb - 1);
 486
 487     return GET_CABAC(elem_offset[SKIP_FLAG] + inc);
 488 }
 489
 490 int ff_hevc_cu_qp_delta_abs(HEVCContext *s)
 491 {
 492     int prefix_val = 0;
 493     int suffix_val = 0;
 494     int inc = 0;
 495
 496     while (prefix_val < 5 && GET_CABAC(elem_offset[CU_QP_DELTA] + inc)) {
 497         prefix_val++;
 498         inc = 1;
 499     }
 500     if (prefix_val >= 5) {
 501         int k = 0;
 502         while (k < CABAC_MAX_BIN && get_cabac_bypass(&s->HEVClc.cc)) {
 503             suffix_val += 1 << k;
 504             k++;
 505         }
 506         if (k == CABAC_MAX_BIN)
 507             av_log(s->avctx, AV_LOG_ERROR, "CABAC_MAX_BIN : %d\n", k);
 508
 509         while (k--)
 510             suffix_val += get_cabac_bypass(&s->HEVClc.cc) << k;
 511     }
 512     return prefix_val + suffix_val;
 513 }
 514
 515 int ff_hevc_cu_qp_delta_sign_flag(HEVCContext *s)
 516 {
 517     return get_cabac_bypass(&s->HEVClc.cc);
 518 }
 519
 520 int ff_hevc_pred_mode_decode(HEVCContext *s)
 521 {
 522     return GET_CABAC(elem_offset[PRED_MODE_FLAG]);
 523 }
 524
 525 int ff_hevc_split_coding_unit_flag_decode(HEVCContext *s, int ct_depth, int x0, int y0)
 526 {
 527     int inc = 0, depth_left = 0, depth_top = 0;
 528     int x0b  = x0 & ((1 << s->ps.sps->log2_ctb_size) - 1);
 529     int y0b  = y0 & ((1 << s->ps.sps->log2_ctb_size) - 1);
 530     int x_cb = x0 >> s->ps.sps->log2_min_cb_size;
 531     int y_cb = y0 >> s->ps.sps->log2_min_cb_size;
 532
 533     if (s->HEVClc.ctb_left_flag || x0b)
 534         depth_left = s->tab_ct_depth[(y_cb) * s->ps.sps->min_cb_width + x_cb - 1];
 535     if (s->HEVClc.ctb_up_flag || y0b)
 536         depth_top = s->tab_ct_depth[(y_cb - 1) * s->ps.sps->min_cb_width + x_cb];
 537
 538     inc += (depth_left > ct_depth);
 539     inc += (depth_top  > ct_depth);
 540
 541     return GET_CABAC(elem_offset[SPLIT_CODING_UNIT_FLAG] + inc);
 542 }
 543
 544 int ff_hevc_part_mode_decode(HEVCContext *s, int log2_cb_size)
 545 {
 546     if (GET_CABAC(elem_offset[PART_MODE])) // 1
 547         return PART_2Nx2N;
 548     if (log2_cb_size == s->ps.sps->log2_min_cb_size) {
 549         if (s->HEVClc.cu.pred_mode == MODE_INTRA) // 0
 550             return PART_NxN;
 551         if (GET_CABAC(elem_offset[PART_MODE] + 1)) // 01
 552             return PART_2NxN;
 553         if (log2_cb_size == 3) // 00
 554             return PART_Nx2N;
 555         if (GET_CABAC(elem_offset[PART_MODE] + 2)) // 001
 556             return PART_Nx2N;
 557         return PART_NxN; // 000
 558     }
 559
 560     if (!s->ps.sps->amp_enabled_flag) {
 561         if (GET_CABAC(elem_offset[PART_MODE] + 1)) // 01
 562             return PART_2NxN;
 563         return PART_Nx2N;
 564     }
 565
 566     if (GET_CABAC(elem_offset[PART_MODE] + 1)) { // 01X, 01XX
 567         if (GET_CABAC(elem_offset[PART_MODE] + 3)) // 011
 568             return PART_2NxN;
 569         if (get_cabac_bypass(&s->HEVClc.cc)) // 0101
 570             return PART_2NxnD;
 571         return PART_2NxnU; // 0100
 572     }
 573
 574     if (GET_CABAC(elem_offset[PART_MODE] + 3)) // 001
 575         return PART_Nx2N;
 576     if (get_cabac_bypass(&s->HEVClc.cc)) // 0001
 577         return PART_nRx2N;
 578     return PART_nLx2N;  // 0000
 579 }
 580
 581 int ff_hevc_pcm_flag_decode(HEVCContext *s)
 582 {
 583     return get_cabac_terminate(&s->HEVClc.cc);
 584 }
 585
 586 int ff_hevc_prev_intra_luma_pred_flag_decode(HEVCContext *s)
 587 {
 588     return GET_CABAC(elem_offset[PREV_INTRA_LUMA_PRED_FLAG]);
 589 }
 590
 591 int ff_hevc_mpm_idx_decode(HEVCContext *s)
 592 {
 593     int i = 0;
 594     while (i < 2 && get_cabac_bypass(&s->HEVClc.cc))
 595         i++;
 596     return i;
 597 }
 598
 599 int ff_hevc_rem_intra_luma_pred_mode_decode(HEVCContext *s)
 600 {
 601     int i;
 602     int value = get_cabac_bypass(&s->HEVClc.cc);
 603
 604     for (i = 0; i < 4; i++)
 605         value = (value << 1) | get_cabac_bypass(&s->HEVClc.cc);
 606     return value;
 607 }
 608
 609 int ff_hevc_intra_chroma_pred_mode_decode(HEVCContext *s)
 610 {
 611     int ret;
 612     if (!GET_CABAC(elem_offset[INTRA_CHROMA_PRED_MODE]))
 613         return 4;
 614
 615     ret  = get_cabac_bypass(&s->HEVClc.cc) << 1;
 616     ret |= get_cabac_bypass(&s->HEVClc.cc);
 617     return ret;
 618 }
 619
 620 int ff_hevc_merge_idx_decode(HEVCContext *s)
 621 {
 622     int i = GET_CABAC(elem_offset[MERGE_IDX]);
 623
 624     if (i != 0) {
 625         while (i < s->sh.max_num_merge_cand-1 && get_cabac_bypass(&s->HEVClc.cc))
 626             i++;
 627     }
 628     return i;
 629 }
 630
 631 int ff_hevc_merge_flag_decode(HEVCContext *s)
 632 {
 633     return GET_CABAC(elem_offset[MERGE_FLAG]);
 634 }
 635
 636 int ff_hevc_inter_pred_idc_decode(HEVCContext *s, int nPbW, int nPbH)
 637 {
 638     if (nPbW + nPbH == 12)
 639         return GET_CABAC(elem_offset[INTER_PRED_IDC] + 4);
 640     if (GET_CABAC(elem_offset[INTER_PRED_IDC] + s->HEVClc.ct.depth))
 641         return PRED_BI;
 642
 643     return GET_CABAC(elem_offset[INTER_PRED_IDC] + 4);
 644 }
 645
 646 int ff_hevc_ref_idx_lx_decode(HEVCContext *s, int num_ref_idx_lx)
 647 {
 648     int i = 0;
 649     int max = num_ref_idx_lx - 1;
 650     int max_ctx = FFMIN(max, 2);
 651
 652     while (i < max_ctx && GET_CABAC(elem_offset[REF_IDX_L0] + i))
 653         i++;
 654     if (i == 2) {
 655         while (i < max && get_cabac_bypass(&s->HEVClc.cc))
 656             i++;
 657     }
 658
 659     return i;
 660 }
 661
 662 int ff_hevc_mvp_lx_flag_decode(HEVCContext *s)
 663 {
 664     return GET_CABAC(elem_offset[MVP_LX_FLAG]);
 665 }
 666
 667 int ff_hevc_no_residual_syntax_flag_decode(HEVCContext *s)
 668 {
 669     return GET_CABAC(elem_offset[NO_RESIDUAL_DATA_FLAG]);
 670 }
 671
 672 int ff_hevc_abs_mvd_greater0_flag_decode(HEVCContext *s)
 673 {
 674     return GET_CABAC(elem_offset[ABS_MVD_GREATER0_FLAG]);
 675 }
 676
 677 int ff_hevc_abs_mvd_greater1_flag_decode(HEVCContext *s)
 678 {
 679     return GET_CABAC(elem_offset[ABS_MVD_GREATER1_FLAG] + 1);
 680 }
 681
 682 int ff_hevc_mvd_decode(HEVCContext *s)
 683 {
 684     int ret = 2;
 685     int k = 1;
 686
 687     while (k < CABAC_MAX_BIN && get_cabac_bypass(&s->HEVClc.cc)) {
 688         ret += 1 << k;
 689         k++;
 690     }
 691     if (k == CABAC_MAX_BIN)
 692         av_log(s->avctx, AV_LOG_ERROR, "CABAC_MAX_BIN : %d\n", k);
 693     while (k--)
 694         ret += get_cabac_bypass(&s->HEVClc.cc) << k;
 695     return get_cabac_bypass_sign(&s->HEVClc.cc, -ret);
 696 }
 697
 698 int ff_hevc_mvd_sign_flag_decode(HEVCContext *s)
 699 {
 700     return get_cabac_bypass_sign(&s->HEVClc.cc, -1);
 701 }
 702
 703 int ff_hevc_split_transform_flag_decode(HEVCContext *s, int log2_trafo_size)
 704 {
 705     return GET_CABAC(elem_offset[SPLIT_TRANSFORM_FLAG] + 5 - log2_trafo_size);
 706 }
 707
 708 int ff_hevc_cbf_cb_cr_decode(HEVCContext *s, int trafo_depth)
 709 {
 710     return GET_CABAC(elem_offset[CBF_CB_CR] + trafo_depth);
 711 }
 712
 713 int ff_hevc_cbf_luma_decode(HEVCContext *s, int trafo_depth)
 714 {
 715     return GET_CABAC(elem_offset[CBF_LUMA] + !trafo_depth);
 716 }
 717
 718 int ff_hevc_transform_skip_flag_decode(HEVCContext *s, int c_idx)
 719 {
 720     return GET_CABAC(elem_offset[TRANSFORM_SKIP_FLAG] + !!c_idx);
 721 }
 722
 723 #define LAST_SIG_COEFF(elem)                                                    \
 724     int i = 0;                                                                  \
 725     int max = (log2_size << 1) - 1;                                             \
 726     int ctx_offset, ctx_shift;                                                  \
 727                                                                                 \
 728     if (c_idx == 0) {                                                           \
 729         ctx_offset = 3 * (log2_size - 2)  + ((log2_size - 1) >> 2);             \
 730         ctx_shift = (log2_size + 1) >> 2;                                       \
 731     } else {                                                                    \
 732         ctx_offset = 15;                                                        \
 733         ctx_shift = log2_size - 2;                                              \
 734     }                                                                           \
 735     while (i < max &&                                                           \
 736            GET_CABAC(elem_offset[elem] + (i >> ctx_shift) + ctx_offset))        \
 737         i++;                                                                    \
 738     return i;
 739
 740 int ff_hevc_last_significant_coeff_x_prefix_decode(HEVCContext *s, int c_idx,
 741                                                    int log2_size)
 742 {
 743     LAST_SIG_COEFF(LAST_SIGNIFICANT_COEFF_X_PREFIX)
 744 }
 745
 746 int ff_hevc_last_significant_coeff_y_prefix_decode(HEVCContext *s, int c_idx,
 747                                                    int log2_size)
 748 {
 749     LAST_SIG_COEFF(LAST_SIGNIFICANT_COEFF_Y_PREFIX)
 750 }
 751
 752 int ff_hevc_last_significant_coeff_suffix_decode(HEVCContext *s,
 753                                                  int last_significant_coeff_prefix)
 754 {
 755     int i;
 756     int length = (last_significant_coeff_prefix >> 1) - 1;
 757     int value = get_cabac_bypass(&s->HEVClc.cc);
 758
 759     for (i = 1; i < length; i++)
 760         value = (value << 1) | get_cabac_bypass(&s->HEVClc.cc);
 761     return value;
 762 }
 763
 764 int ff_hevc_significant_coeff_group_flag_decode(HEVCContext *s, int c_idx, int ctx_cg)
 765 {
 766     int inc;
 767
 768     inc = FFMIN(ctx_cg, 1) + (c_idx>0 ? 2 : 0);
 769
 770     return GET_CABAC(elem_offset[SIGNIFICANT_COEFF_GROUP_FLAG] + inc);
 771 }
 772
 773 int ff_hevc_significant_coeff_flag_decode(HEVCContext *s, int c_idx, int x_c, int y_c,
 774                                           int log2_trafo_size, int scan_idx, int prev_sig)
 775 {
 776     static const uint8_t ctx_idx_map[] = {
 777         0, 1, 4, 5, 2, 3, 4, 5, 6, 6, 8, 8, 7, 7, 8, 8
 778     };
 779     int x_cg = x_c >> 2;
 780     int y_cg = y_c >> 2;
 781     int sig_ctx, inc;
 782
 783     if (x_c + y_c == 0) {
 784         sig_ctx = 0;
 785     } else if (log2_trafo_size == 2) {
 786         sig_ctx = ctx_idx_map[(y_c << 2) + x_c];
 787     } else {
 788         switch (prev_sig) {
 789         case 0: {
 790                 int x_off = x_c & 3;
 791                 int y_off = y_c & 3;
 792                 sig_ctx   = ((x_off + y_off) == 0) ? 2 : ((x_off + y_off) <= 2) ? 1 : 0;
 793             }
 794             break;
 795         case 1:
 796             sig_ctx = 2 - FFMIN(y_c & 3, 2);
 797             break;
 798         case 2:
 799             sig_ctx = 2 - FFMIN(x_c & 3, 2);
 800             break;
 801         default:
 802             sig_ctx = 2;
 803         }
 804
 805         if (c_idx == 0 && (x_cg > 0 || y_cg > 0))
 806             sig_ctx += 3;
 807
 808         if (log2_trafo_size == 3) {
 809             sig_ctx += (scan_idx == SCAN_DIAG) ? 9 : 15;
 810         } else {
 811             sig_ctx += c_idx ? 12 : 21;
 812         }
 813     }
 814
 815     if (c_idx == 0)
 816         inc = sig_ctx;
 817     else
 818         inc = sig_ctx + 27;
 819
 820     return GET_CABAC(elem_offset[SIGNIFICANT_COEFF_FLAG] + inc);
 821 }
 822
 823 int ff_hevc_coeff_abs_level_greater1_flag_decode(HEVCContext *s, int c_idx, int inc)
 824 {
 825
 826     if (c_idx > 0)
 827         inc += 16;
 828
 829     return GET_CABAC(elem_offset[COEFF_ABS_LEVEL_GREATER1_FLAG] + inc);
 830 }
 831
 832 int ff_hevc_coeff_abs_level_greater2_flag_decode(HEVCContext *s, int c_idx, int inc)
 833 {
 834     if (c_idx > 0)
 835         inc += 4;
 836
 837     return GET_CABAC(elem_offset[COEFF_ABS_LEVEL_GREATER2_FLAG] + inc);
 838 }
 839
 840 int ff_hevc_coeff_abs_level_remaining(HEVCContext *s, int base_level, int rc_rice_param)
 841 {
 842     int prefix = 0;
 843     int suffix = 0;
 844     int last_coeff_abs_level_remaining;
 845     int i;
 846
 847     while (prefix < CABAC_MAX_BIN && get_cabac_bypass(&s->HEVClc.cc))
 848         prefix++;
 849     if (prefix == CABAC_MAX_BIN)
 850         av_log(s->avctx, AV_LOG_ERROR, "CABAC_MAX_BIN : %d\n", prefix);
 851     if (prefix < 3) {
 852         for (i = 0; i < rc_rice_param; i++)
 853             suffix = (suffix << 1) | get_cabac_bypass(&s->HEVClc.cc);
 854         last_coeff_abs_level_remaining = (prefix << rc_rice_param) + suffix;
 855     } else {
 856         int prefix_minus3 = prefix - 3;
 857         for (i = 0; i < prefix_minus3 + rc_rice_param; i++)
 858             suffix = (suffix << 1) | get_cabac_bypass(&s->HEVClc.cc);
 859         last_coeff_abs_level_remaining = (((1 << prefix_minus3) + 3 - 1)
 860                                               << rc_rice_param) + suffix;
 861     }
 862     return last_coeff_abs_level_remaining;
 863 }
 864
 865 int ff_hevc_coeff_sign_flag(HEVCContext *s, uint8_t nb)
 866 {
 867     int i;
 868     int ret = 0;
 869
 870     for (i = 0; i < nb; i++)
 871         ret = (ret << 1) | get_cabac_bypass(&s->HEVClc.cc);
 872     return ret;
 873 }