Libav
hevc_cabac.c
Go to the documentation of this file.
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 100
31 
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 
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 
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 {
329  (ctb_addr_ts % s->sps->ctb_width == 2 ||
330  (s->sps->ctb_width == 2 &&
331  ctb_addr_ts % s->sps->ctb_width == 0))) {
333  }
334 }
335 
336 static void load_states(HEVCContext *s)
337 {
339 }
340 
342 {
343  skip_bytes(&lc->cc, 0);
344 }
345 
347 {
348  GetBitContext *gb = &s->HEVClc.gb;
349  skip_bits(gb, 1);
350  align_get_bits(gb);
352  gb->buffer + get_bits_count(gb) / 8,
353  (get_bits_left(gb) + 7) / 8);
354 }
355 
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_c(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->pps->ctb_addr_rs_to_ts[s->sh.slice_ctb_addr_rs]) {
381  if (s->sh.dependent_slice_segment_flag == 0 ||
382  (s->pps->tiles_enabled_flag &&
383  s->pps->tile_id[ctb_addr_ts] != s->pps->tile_id[ctb_addr_ts - 1]))
384  cabac_init_state(s);
385 
386  if (!s->sh.first_slice_in_pic_flag &&
388  if (ctb_addr_ts % s->sps->ctb_width == 0) {
389  if (s->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->pps->tiles_enabled_flag &&
397  s->pps->tile_id[ctb_addr_ts] != s->pps->tile_id[ctb_addr_ts - 1]) {
398  cabac_reinit(&s->HEVClc);
399  cabac_init_state(s);
400  }
402  if (ctb_addr_ts % s->sps->ctb_width == 0) {
404  cabac_reinit(&s->HEVClc);
405 
406  if (s->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 
418 {
420 }
421 
423 {
425  return 0;
426 
427  if (!get_cabac_bypass(&s->HEVClc.cc))
428  return SAO_BAND;
429  return SAO_EDGE;
430 }
431 
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 
443 {
444  int i = 0;
445  int length = (1 << (FFMIN(s->sps->bit_depth, 10) - 5)) - 1;
446 
447  while (i < length && get_cabac_bypass(&s->HEVClc.cc))
448  i++;
449  return i;
450 }
451 
453 {
454  return get_cabac_bypass(&s->HEVClc.cc);
455 }
456 
458 {
459  int ret = get_cabac_bypass(&s->HEVClc.cc) << 1;
460  ret |= get_cabac_bypass(&s->HEVClc.cc);
461  return ret;
462 }
463 
465 {
466  return get_cabac_terminate(&s->HEVClc.cc);
467 }
468 
470 {
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->sps->min_cb_width;
477  int inc = 0;
478  int x0b = x0 & ((1 << s->sps->log2_ctb_size) - 1);
479  int y0b = y0 & ((1 << s->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 
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 
515 {
516  return get_cabac_bypass(&s->HEVClc.cc);
517 }
518 
520 {
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->sps->log2_ctb_size) - 1);
528  int y0b = y0 & ((1 << s->sps->log2_ctb_size) - 1);
529  int x_cb = x0 >> s->sps->log2_min_cb_size;
530  int y_cb = y0 >> s->sps->log2_min_cb_size;
531 
532  if (s->HEVClc.ctb_left_flag || x0b)
533  depth_left = s->tab_ct_depth[(y_cb) * s->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->sps->min_cb_width + x_cb];
536 
537  inc += (depth_left > ct_depth);
538  inc += (depth_top > ct_depth);
539 
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->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->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 
581 {
582  return get_cabac_terminate(&s->HEVClc.cc);
583 }
584 
586 {
588 }
589 
591 {
592  int i = 0;
593  while (i < 2 && get_cabac_bypass(&s->HEVClc.cc))
594  i++;
595  return i;
596 }
597 
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 
609 {
610  int ret;
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 
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 
631 {
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);
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 
662 {
664 }
665 
667 {
669 }
670 
672 {
674 }
675 
677 {
679 }
680 
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 
698 {
699  return get_cabac_bypass_sign(&s->HEVClc.cc, -1);
700 }
701 
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 
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 
740  int log2_size)
741 {
743 }
744 
746  int log2_size)
747 {
749 }
750 
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 
764 {
765  int inc;
766 
767  inc = FFMIN(ctx_cg, 1) + (c_idx>0 ? 2 : 0);
768 
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 
820 }
821 
823 {
824 
825  if (c_idx > 0)
826  inc += 16;
827 
829 }
830 
832 {
833  if (c_idx > 0)
834  inc += 4;
835 
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 
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 }
int ff_hevc_abs_mvd_greater0_flag_decode(HEVCContext *s)
Definition: hevc_cabac.c:671
static av_unused const int8_t num_bins_in_se[]
number of bin by SyntaxElement.
Definition: hevc_cabac.c:35
uint8_t ctb_up_flag
Definition: hevc.h:730
unsigned int log2_min_cb_size
Definition: hevc.h:435
int ff_hevc_split_coding_unit_flag_decode(HEVCContext *s, int ct_depth, int x0, int y0)
Definition: hevc_cabac.c:524
static av_always_inline av_const int av_clip_c(int a, int amin, int amax)
Clip a signed integer value into the amin-amax range.
Definition: common.h:93
int ff_hevc_cbf_luma_decode(HEVCContext *s, int trafo_depth)
Definition: hevc_cabac.c:712
int ff_hevc_sao_offset_sign_decode(HEVCContext *s)
Definition: hevc_cabac.c:452
const uint8_t * buffer
Definition: get_bits.h:54
void av_log(void *avcl, int level, const char *fmt,...) av_printf_format(3
Send the specified message to the log if the level is less than or equal to the current av_log_level...
int ff_hevc_transform_skip_flag_decode(HEVCContext *s, int c_idx)
Definition: hevc_cabac.c:717
Definition: hevc.h:246
int ff_hevc_merge_flag_decode(HEVCContext *s)
Definition: hevc_cabac.c:630
uint8_t dependent_slice_segment_flag
Definition: hevc.h:541
CABACContext cc
Definition: hevc.h:722
#define LAST_SIG_COEFF(elem)
Definition: hevc_cabac.c:722
#define HEVC_CONTEXTS
Definition: hevc.h:63
uint8_t entropy_coding_sync_enabled_flag
Definition: hevc.h:491
int ff_hevc_no_residual_syntax_flag_decode(HEVCContext *s)
Definition: hevc_cabac.c:666
CodingTree ct
Definition: hevc.h:738
int ff_hevc_split_transform_flag_decode(HEVCContext *s, int log2_trafo_size)
Definition: hevc_cabac.c:702
int ff_hevc_sao_merge_flag_decode(HEVCContext *s)
Definition: hevc_cabac.c:417
int ff_hevc_rem_intra_luma_pred_mode_decode(HEVCContext *s)
Definition: hevc_cabac.c:598
uint8_t
int ff_hevc_mvd_sign_flag_decode(HEVCContext *s)
Definition: hevc_cabac.c:697
int ff_hevc_inter_pred_idc_decode(HEVCContext *s, int nPbW, int nPbH)
Definition: hevc_cabac.c:635
int depth
ctDepth
Definition: hevc.h:598
int ff_hevc_part_mode_decode(HEVCContext *s, int log2_cb_size)
Definition: hevc_cabac.c:543
AVCodecContext * avctx
Definition: hevc.h:754
static void cabac_init_state(HEVCContext *s)
Definition: hevc_cabac.c:356
int min_cb_width
Definition: hevc.h:451
int ff_hevc_prev_intra_luma_pred_flag_decode(HEVCContext *s)
Definition: hevc_cabac.c:585
uint8_t first_slice_in_pic_flag
Definition: hevc.h:540
int ff_hevc_coeff_sign_flag(HEVCContext *s, uint8_t nb)
Definition: hevc_cabac.c:864
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:194
int ff_hevc_skip_flag_decode(HEVCContext *s, int x0, int y0, int x_cb, int y_cb)
Definition: hevc_cabac.c:474
int ff_hevc_cbf_cb_cr_decode(HEVCContext *s, int trafo_depth)
Definition: hevc_cabac.c:707
uint8_t * tab_ct_depth
Definition: hevc.h:810
int ff_hevc_last_significant_coeff_y_prefix_decode(HEVCContext *s, int c_idx, int log2_size)
Definition: hevc_cabac.c:745
static av_unused const uint8_t * skip_bytes(CABACContext *c, int n)
Skip n bytes and reset the decoder.
void ff_hevc_cabac_init(HEVCContext *s, int ctb_addr_ts)
Definition: hevc_cabac.c:377
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:555
#define GET_CABAC(ctx)
Definition: hevc_cabac.c:415
const HEVCSPS * sps
Definition: hevc.h:769
int ff_hevc_cu_transquant_bypass_flag_decode(HEVCContext *s)
Definition: hevc_cabac.c:469
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:123
uint8_t amp_enabled_flag
Definition: hevc.h:417
Definition: hevc.h:186
HEVCLocalContext HEVClc
Definition: hevc.h:756
int ff_hevc_abs_mvd_greater1_flag_decode(HEVCContext *s)
Definition: hevc_cabac.c:676
static const int elem_offset[sizeof(num_bins_in_se)]
Offset to ctxIdx 0 in init_values and states, indexed by SyntaxElement.
Definition: hevc_cabac.c:84
unsigned int log2_ctb_size
Definition: hevc.h:439
int ff_hevc_coeff_abs_level_greater2_flag_decode(HEVCContext *s, int c_idx, int inc)
Definition: hevc_cabac.c:831
int8_t slice_qp
Definition: hevc.h:578
int ff_hevc_last_significant_coeff_x_prefix_decode(HEVCContext *s, int c_idx, int log2_size)
Definition: hevc_cabac.c:739
int ff_hevc_sao_band_position_decode(HEVCContext *s)
Definition: hevc_cabac.c:432
uint8_t tiles_enabled_flag
Definition: hevc.h:490
const HEVCPPS * pps
Definition: hevc.h:770
int ff_hevc_sao_eo_class_decode(HEVCContext *s)
Definition: hevc_cabac.c:457
uint8_t cabac_state[HEVC_CONTEXTS]
Definition: hevc.h:717
int ff_hevc_mvd_decode(HEVCContext *s)
Definition: hevc_cabac.c:681
int ff_hevc_significant_coeff_group_flag_decode(HEVCContext *s, int c_idx, int ctx_cg)
Definition: hevc_cabac.c:763
Definition: hevc.h:133
Context Adaptive Binary Arithmetic Coder inline functions.
Definition: hevc.h:202
int ctb_width
Definition: hevc.h:448
static int av_unused get_cabac_terminate(CABACContext *c)
if(ac->has_optimized_func)
int ff_hevc_merge_idx_decode(HEVCContext *s)
Definition: hevc_cabac.c:619
int * ctb_addr_rs_to_ts
CtbAddrRSToTS.
Definition: hevc.h:521
Definition: hevc.h:167
int ff_hevc_end_of_slice_flag_decode(HEVCContext *s)
Definition: hevc_cabac.c:464
int ff_hevc_coeff_abs_level_greater1_flag_decode(HEVCContext *s, int c_idx, int inc)
Definition: hevc_cabac.c:822
enum PredMode pred_mode
PredMode.
Definition: hevc.h:605
#define av_unused
Definition: attributes.h:86
uint8_t ctb_left_flag
Definition: hevc.h:729
int ff_hevc_cu_qp_delta_sign_flag(HEVCContext *s)
Definition: hevc_cabac.c:514
uint8_t cabac_init_flag
Definition: hevc.h:560
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:263
int ff_hevc_significant_coeff_flag_decode(HEVCContext *s, int c_idx, int x_c, int y_c, int log2_trafo_size, int scan_idx, int prev_sig)
Definition: hevc_cabac.c:772
void ff_hevc_save_states(HEVCContext *s, int ctb_addr_ts)
Definition: hevc_cabac.c:326
GetBitContext gb
Definition: hevc.h:721
int * tile_id
TileId.
Definition: hevc.h:523
#define CNU
Definition: hevc_cabac.c:130
int ff_hevc_ref_idx_lx_decode(HEVCContext *s, int num_ref_idx_lx)
Definition: hevc_cabac.c:645
int ff_hevc_coeff_abs_level_remaining(HEVCContext *s, int base_level, int rc_rice_param)
Definition: hevc_cabac.c:839
static av_always_inline int get_cabac_bypass_sign(CABACContext *c, int val)
static int av_unused get_cabac_bypass(CABACContext *c)
static void load_states(HEVCContext *s)
Definition: hevc_cabac.c:336
uint8_t * skip_flag
Definition: hevc.h:809
#define CABAC_MAX_BIN
Definition: hevc_cabac.c:30
int ff_hevc_intra_chroma_pred_mode_decode(HEVCContext *s)
Definition: hevc_cabac.c:608
uint8_t cabac_state[HEVC_CONTEXTS]
Definition: hevc.h:758
Definition: hevc.h:245
int ff_hevc_last_significant_coeff_suffix_decode(HEVCContext *s, int last_significant_coeff_prefix)
Definition: hevc_cabac.c:751
int slice_ctb_addr_rs
Definition: hevc.h:594
int ff_hevc_sao_type_idx_decode(HEVCContext *s)
Definition: hevc_cabac.c:422
void ff_init_cabac_decoder(CABACContext *c, const uint8_t *buf, int buf_size)
Definition: cabac.c:109
int ff_hevc_pred_mode_decode(HEVCContext *s)
Definition: hevc_cabac.c:519
CodingUnit cu
Definition: hevc.h:739
int ff_hevc_mpm_idx_decode(HEVCContext *s)
Definition: hevc_cabac.c:590
int ff_hevc_pcm_flag_decode(HEVCContext *s)
Definition: hevc_cabac.c:580
static const uint8_t * align_get_bits(GetBitContext *s)
Definition: get_bits.h:416
static void cabac_init_decoder(HEVCContext *s)
Definition: hevc_cabac.c:346
int bit_depth
Definition: hevc.h:394
enum SliceType slice_type
Definition: hevc.h:536
static const uint8_t init_values[3][HEVC_CONTEXTS]
Indexed by init_type.
Definition: hevc_cabac.c:134
int ff_hevc_sao_offset_abs_decode(HEVCContext *s)
Definition: hevc_cabac.c:442
SliceHeader sh
Definition: hevc.h:781
static void cabac_reinit(HEVCLocalContext *lc)
Definition: hevc_cabac.c:341
#define FFMIN(a, b)
Definition: common.h:57
int ff_hevc_cu_qp_delta_abs(HEVCContext *s)
Definition: hevc_cabac.c:489
int ff_hevc_mvp_lx_flag_decode(HEVCContext *s)
Definition: hevc_cabac.c:661
#define SAMPLE_CTB(tab, x, y)
Definition: hevc.h:80