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