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

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