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