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