FFmpeg  3.3.8
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 av_unused 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  4, // 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  46, // transform_skip_flag[][]
126  48, // explicit_rdpcm_flag[][]
127  50, // explicit_rdpcm_dir_flag[][]
128  52, // last_significant_coeff_x_prefix
129  70, // last_significant_coeff_y_prefix
130  88, // last_significant_coeff_x_suffix
131  88, // last_significant_coeff_y_suffix
132  88, // significant_coeff_group_flag
133  92, // significant_coeff_flag
134  136, // coeff_abs_level_greater1_flag
135  160, // coeff_abs_level_greater2_flag
136  166, // coeff_abs_level_remaining
137  166, // coeff_sign_flag
138  166, // log2_res_scale_abs
139  174, // res_scale_sign_flag
140  176, // cu_chroma_qp_offset_flag
141  177, // 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,
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,
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,
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 {
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  }
458 }
459 
460 static void load_states(HEVCContext *s)
461 {
462  memcpy(s->HEVClc->cabac_state, s->cabac_state, HEVC_CONTEXTS);
463 }
464 
466 {
467  skip_bytes(&lc->cc, 0);
468 }
469 
471 {
472  GetBitContext *gb = &s->HEVClc->gb;
473  skip_bits(gb, 1);
474  align_get_bits(gb);
476  gb->buffer + get_bits_count(gb) / 8,
477  (get_bits_left(gb) + 7) / 8);
478 }
479 
481 {
482  int init_type = 2 - s->sh.slice_type;
483  int i;
484 
485  if (s->sh.cabac_init_flag && s->sh.slice_type != HEVC_SLICE_I)
486  init_type ^= 3;
487 
488  for (i = 0; i < HEVC_CONTEXTS; i++) {
489  int init_value = init_values[init_type][i];
490  int m = (init_value >> 4) * 5 - 45;
491  int n = ((init_value & 15) << 3) - 16;
492  int pre = 2 * (((m * av_clip(s->sh.slice_qp, 0, 51)) >> 4) + n) - 127;
493 
494  pre ^= pre >> 31;
495  if (pre > 124)
496  pre = 124 + (pre & 1);
497  s->HEVClc->cabac_state[i] = pre;
498  }
499 
500  for (i = 0; i < 4; i++)
501  s->HEVClc->stat_coeff[i] = 0;
502 }
503 
504 void ff_hevc_cabac_init(HEVCContext *s, int ctb_addr_ts)
505 {
506  if (ctb_addr_ts == s->ps.pps->ctb_addr_rs_to_ts[s->sh.slice_ctb_addr_rs]) {
508  if (s->sh.dependent_slice_segment_flag == 0 ||
509  (s->ps.pps->tiles_enabled_flag &&
510  s->ps.pps->tile_id[ctb_addr_ts] != s->ps.pps->tile_id[ctb_addr_ts - 1]))
511  cabac_init_state(s);
512 
513  if (!s->sh.first_slice_in_pic_flag &&
515  if (ctb_addr_ts % s->ps.sps->ctb_width == 0) {
516  if (s->ps.sps->ctb_width == 1)
517  cabac_init_state(s);
518  else if (s->sh.dependent_slice_segment_flag == 1)
519  load_states(s);
520  }
521  }
522  } else {
523  if (s->ps.pps->tiles_enabled_flag &&
524  s->ps.pps->tile_id[ctb_addr_ts] != s->ps.pps->tile_id[ctb_addr_ts - 1]) {
525  if (s->threads_number == 1)
526  cabac_reinit(s->HEVClc);
527  else
529  cabac_init_state(s);
530  }
532  if (ctb_addr_ts % s->ps.sps->ctb_width == 0) {
534  if (s->threads_number == 1)
535  cabac_reinit(s->HEVClc);
536  else
538 
539  if (s->ps.sps->ctb_width == 1)
540  cabac_init_state(s);
541  else
542  load_states(s);
543  }
544  }
545  }
546 }
547 
548 #define GET_CABAC(ctx) get_cabac(&s->HEVClc->cc, &s->HEVClc->cabac_state[ctx])
549 
551 {
553 }
554 
556 {
558  return 0;
559 
560  if (!get_cabac_bypass(&s->HEVClc->cc))
561  return SAO_BAND;
562  return SAO_EDGE;
563 }
564 
566 {
567  int i;
568  int value = get_cabac_bypass(&s->HEVClc->cc);
569 
570  for (i = 0; i < 4; i++)
571  value = (value << 1) | get_cabac_bypass(&s->HEVClc->cc);
572  return value;
573 }
574 
576 {
577  int i = 0;
578  int length = (1 << (FFMIN(s->ps.sps->bit_depth, 10) - 5)) - 1;
579 
580  while (i < length && get_cabac_bypass(&s->HEVClc->cc))
581  i++;
582  return i;
583 }
584 
586 {
587  return get_cabac_bypass(&s->HEVClc->cc);
588 }
589 
591 {
592  int ret = get_cabac_bypass(&s->HEVClc->cc) << 1;
593  ret |= get_cabac_bypass(&s->HEVClc->cc);
594  return ret;
595 }
596 
598 {
599  return get_cabac_terminate(&s->HEVClc->cc);
600 }
601 
603 {
605 }
606 
607 int ff_hevc_skip_flag_decode(HEVCContext *s, int x0, int y0, int x_cb, int y_cb)
608 {
609  int min_cb_width = s->ps.sps->min_cb_width;
610  int inc = 0;
611  int x0b = av_mod_uintp2(x0, s->ps.sps->log2_ctb_size);
612  int y0b = av_mod_uintp2(y0, s->ps.sps->log2_ctb_size);
613 
614  if (s->HEVClc->ctb_left_flag || x0b)
615  inc = !!SAMPLE_CTB(s->skip_flag, x_cb - 1, y_cb);
616  if (s->HEVClc->ctb_up_flag || y0b)
617  inc += !!SAMPLE_CTB(s->skip_flag, x_cb, y_cb - 1);
618 
619  return GET_CABAC(elem_offset[SKIP_FLAG] + inc);
620 }
621 
623 {
624  int prefix_val = 0;
625  int suffix_val = 0;
626  int inc = 0;
627 
628  while (prefix_val < 5 && GET_CABAC(elem_offset[CU_QP_DELTA] + inc)) {
629  prefix_val++;
630  inc = 1;
631  }
632  if (prefix_val >= 5) {
633  int k = 0;
634  while (k < CABAC_MAX_BIN && get_cabac_bypass(&s->HEVClc->cc)) {
635  suffix_val += 1 << k;
636  k++;
637  }
638  if (k == CABAC_MAX_BIN) {
639  av_log(s->avctx, AV_LOG_ERROR, "CABAC_MAX_BIN : %d\n", k);
640  return AVERROR_INVALIDDATA;
641  }
642 
643  while (k--)
644  suffix_val += get_cabac_bypass(&s->HEVClc->cc) << k;
645  }
646  return prefix_val + suffix_val;
647 }
648 
650 {
651  return get_cabac_bypass(&s->HEVClc->cc);
652 }
653 
655 {
657 }
658 
660 {
661  int c_max= FFMAX(5, s->ps.pps->chroma_qp_offset_list_len_minus1);
662  int i = 0;
663 
664  while (i < c_max && GET_CABAC(elem_offset[CU_CHROMA_QP_OFFSET_IDX]))
665  i++;
666 
667  return i;
668 }
669 
671 {
673 }
674 
675 int ff_hevc_split_coding_unit_flag_decode(HEVCContext *s, int ct_depth, int x0, int y0)
676 {
677  int inc = 0, depth_left = 0, depth_top = 0;
678  int x0b = av_mod_uintp2(x0, s->ps.sps->log2_ctb_size);
679  int y0b = av_mod_uintp2(y0, s->ps.sps->log2_ctb_size);
680  int x_cb = x0 >> s->ps.sps->log2_min_cb_size;
681  int y_cb = y0 >> s->ps.sps->log2_min_cb_size;
682 
683  if (s->HEVClc->ctb_left_flag || x0b)
684  depth_left = s->tab_ct_depth[(y_cb) * s->ps.sps->min_cb_width + x_cb - 1];
685  if (s->HEVClc->ctb_up_flag || y0b)
686  depth_top = s->tab_ct_depth[(y_cb - 1) * s->ps.sps->min_cb_width + x_cb];
687 
688  inc += (depth_left > ct_depth);
689  inc += (depth_top > ct_depth);
690 
692 }
693 
694 int ff_hevc_part_mode_decode(HEVCContext *s, int log2_cb_size)
695 {
696  if (GET_CABAC(elem_offset[PART_MODE])) // 1
697  return PART_2Nx2N;
698  if (log2_cb_size == s->ps.sps->log2_min_cb_size) {
699  if (s->HEVClc->cu.pred_mode == MODE_INTRA) // 0
700  return PART_NxN;
701  if (GET_CABAC(elem_offset[PART_MODE] + 1)) // 01
702  return PART_2NxN;
703  if (log2_cb_size == 3) // 00
704  return PART_Nx2N;
705  if (GET_CABAC(elem_offset[PART_MODE] + 2)) // 001
706  return PART_Nx2N;
707  return PART_NxN; // 000
708  }
709 
710  if (!s->ps.sps->amp_enabled_flag) {
711  if (GET_CABAC(elem_offset[PART_MODE] + 1)) // 01
712  return PART_2NxN;
713  return PART_Nx2N;
714  }
715 
716  if (GET_CABAC(elem_offset[PART_MODE] + 1)) { // 01X, 01XX
717  if (GET_CABAC(elem_offset[PART_MODE] + 3)) // 011
718  return PART_2NxN;
719  if (get_cabac_bypass(&s->HEVClc->cc)) // 0101
720  return PART_2NxnD;
721  return PART_2NxnU; // 0100
722  }
723 
724  if (GET_CABAC(elem_offset[PART_MODE] + 3)) // 001
725  return PART_Nx2N;
726  if (get_cabac_bypass(&s->HEVClc->cc)) // 0001
727  return PART_nRx2N;
728  return PART_nLx2N; // 0000
729 }
730 
732 {
733  return get_cabac_terminate(&s->HEVClc->cc);
734 }
735 
737 {
739 }
740 
742 {
743  int i = 0;
744  while (i < 2 && get_cabac_bypass(&s->HEVClc->cc))
745  i++;
746  return i;
747 }
748 
750 {
751  int i;
752  int value = get_cabac_bypass(&s->HEVClc->cc);
753 
754  for (i = 0; i < 4; i++)
755  value = (value << 1) | get_cabac_bypass(&s->HEVClc->cc);
756  return value;
757 }
758 
760 {
761  int ret;
763  return 4;
764 
765  ret = get_cabac_bypass(&s->HEVClc->cc) << 1;
766  ret |= get_cabac_bypass(&s->HEVClc->cc);
767  return ret;
768 }
769 
771 {
772  int i = GET_CABAC(elem_offset[MERGE_IDX]);
773 
774  if (i != 0) {
775  while (i < s->sh.max_num_merge_cand-1 && get_cabac_bypass(&s->HEVClc->cc))
776  i++;
777  }
778  return i;
779 }
780 
782 {
784 }
785 
786 int ff_hevc_inter_pred_idc_decode(HEVCContext *s, int nPbW, int nPbH)
787 {
788  if (nPbW + nPbH == 12)
789  return GET_CABAC(elem_offset[INTER_PRED_IDC] + 4);
791  return PRED_BI;
792 
793  return GET_CABAC(elem_offset[INTER_PRED_IDC] + 4);
794 }
795 
796 int ff_hevc_ref_idx_lx_decode(HEVCContext *s, int num_ref_idx_lx)
797 {
798  int i = 0;
799  int max = num_ref_idx_lx - 1;
800  int max_ctx = FFMIN(max, 2);
801 
802  while (i < max_ctx && GET_CABAC(elem_offset[REF_IDX_L0] + i))
803  i++;
804  if (i == 2) {
805  while (i < max && get_cabac_bypass(&s->HEVClc->cc))
806  i++;
807  }
808 
809  return i;
810 }
811 
813 {
815 }
816 
818 {
820 }
821 
823 {
825 }
826 
828 {
830 }
831 
833 {
834  int ret = 2;
835  int k = 1;
836 
837  while (k < CABAC_MAX_BIN && get_cabac_bypass(&s->HEVClc->cc)) {
838  ret += 1U << k;
839  k++;
840  }
841  if (k == CABAC_MAX_BIN) {
842  av_log(s->avctx, AV_LOG_ERROR, "CABAC_MAX_BIN : %d\n", k);
843  return 0;
844  }
845  while (k--)
846  ret += get_cabac_bypass(&s->HEVClc->cc) << k;
847  return get_cabac_bypass_sign(&s->HEVClc->cc, -ret);
848 }
849 
851 {
852  return get_cabac_bypass_sign(&s->HEVClc->cc, -1);
853 }
854 
856 {
857  return GET_CABAC(elem_offset[SPLIT_TRANSFORM_FLAG] + 5 - log2_trafo_size);
858 }
859 
860 int ff_hevc_cbf_cb_cr_decode(HEVCContext *s, int trafo_depth)
861 {
862  return GET_CABAC(elem_offset[CBF_CB_CR] + trafo_depth);
863 }
864 
865 int ff_hevc_cbf_luma_decode(HEVCContext *s, int trafo_depth)
866 {
867  return GET_CABAC(elem_offset[CBF_LUMA] + !trafo_depth);
868 }
869 
871 {
872  return GET_CABAC(elem_offset[TRANSFORM_SKIP_FLAG] + !!c_idx);
873 }
874 
875 static int explicit_rdpcm_flag_decode(HEVCContext *s, int c_idx)
876 {
877  return GET_CABAC(elem_offset[EXPLICIT_RDPCM_FLAG] + !!c_idx);
878 }
879 
881 {
882  return GET_CABAC(elem_offset[EXPLICIT_RDPCM_DIR_FLAG] + !!c_idx);
883 }
884 
886  int i =0;
887 
888  while (i < 4 && GET_CABAC(elem_offset[LOG2_RES_SCALE_ABS] + 4 * idx + i))
889  i++;
890 
891  return i;
892 }
893 
896 }
897 
899  int log2_size, int *last_scx_prefix, int *last_scy_prefix)
900 {
901  int i = 0;
902  int max = (log2_size << 1) - 1;
903  int ctx_offset, ctx_shift;
904 
905  if (!c_idx) {
906  ctx_offset = 3 * (log2_size - 2) + ((log2_size - 1) >> 2);
907  ctx_shift = (log2_size + 1) >> 2;
908  } else {
909  ctx_offset = 15;
910  ctx_shift = log2_size - 2;
911  }
912  while (i < max &&
913  GET_CABAC(elem_offset[LAST_SIGNIFICANT_COEFF_X_PREFIX] + (i >> ctx_shift) + ctx_offset))
914  i++;
915  *last_scx_prefix = i;
916 
917  i = 0;
918  while (i < max &&
919  GET_CABAC(elem_offset[LAST_SIGNIFICANT_COEFF_Y_PREFIX] + (i >> ctx_shift) + ctx_offset))
920  i++;
921  *last_scy_prefix = i;
922 }
923 
925  int last_significant_coeff_prefix)
926 {
927  int i;
928  int length = (last_significant_coeff_prefix >> 1) - 1;
929  int value = get_cabac_bypass(&s->HEVClc->cc);
930 
931  for (i = 1; i < length; i++)
932  value = (value << 1) | get_cabac_bypass(&s->HEVClc->cc);
933  return value;
934 }
935 
937 {
938  int inc;
939 
940  inc = FFMIN(ctx_cg, 1) + (c_idx>0 ? 2 : 0);
941 
943 }
945  int offset, const uint8_t *ctx_idx_map)
946 {
947  int inc = ctx_idx_map[(y_c << 2) + x_c] + offset;
949 }
950 
952 {
953  return GET_CABAC(elem_offset[SIGNIFICANT_COEFF_FLAG] + offset);
954 }
955 
957 {
958 
959  if (c_idx > 0)
960  inc += 16;
961 
963 }
964 
966 {
967  if (c_idx > 0)
968  inc += 4;
969 
971 }
972 
974 {
975  int prefix = 0;
976  int suffix = 0;
977  int last_coeff_abs_level_remaining;
978  int i;
979 
980  while (prefix < CABAC_MAX_BIN && get_cabac_bypass(&s->HEVClc->cc))
981  prefix++;
982 
983  if (prefix < 3) {
984  for (i = 0; i < rc_rice_param; i++)
985  suffix = (suffix << 1) | get_cabac_bypass(&s->HEVClc->cc);
986  last_coeff_abs_level_remaining = (prefix << rc_rice_param) + suffix;
987  } else {
988  int prefix_minus3 = prefix - 3;
989 
990  if (prefix == CABAC_MAX_BIN || prefix_minus3 + rc_rice_param >= 31) {
991  av_log(s->avctx, AV_LOG_ERROR, "CABAC_MAX_BIN : %d\n", prefix);
992  return 0;
993  }
994 
995  for (i = 0; i < prefix_minus3 + rc_rice_param; i++)
996  suffix = (suffix << 1) | get_cabac_bypass(&s->HEVClc->cc);
997  last_coeff_abs_level_remaining = (((1 << prefix_minus3) + 3 - 1)
998  << rc_rice_param) + suffix;
999  }
1000  return last_coeff_abs_level_remaining;
1001 }
1002 
1004 {
1005  int i;
1006  int ret = 0;
1007 
1008  for (i = 0; i < nb; i++)
1009  ret = (ret << 1) | get_cabac_bypass(&s->HEVClc->cc);
1010  return ret;
1011 }
1012 
1014  int log2_trafo_size, enum ScanType scan_idx,
1015  int c_idx)
1016 {
1017 #define GET_COORD(offset, n) \
1018  do { \
1019  x_c = (x_cg << 2) + scan_x_off[n]; \
1020  y_c = (y_cg << 2) + scan_y_off[n]; \
1021  } while (0)
1022  HEVCLocalContext *lc = s->HEVClc;
1023  int transform_skip_flag = 0;
1024 
1025  int last_significant_coeff_x, last_significant_coeff_y;
1026  int last_scan_pos;
1027  int n_end;
1028  int num_coeff = 0;
1029  int greater1_ctx = 1;
1030 
1031  int num_last_subset;
1032  int x_cg_last_sig, y_cg_last_sig;
1033 
1034  const uint8_t *scan_x_cg, *scan_y_cg, *scan_x_off, *scan_y_off;
1035 
1036  ptrdiff_t stride = s->frame->linesize[c_idx];
1037  int hshift = s->ps.sps->hshift[c_idx];
1038  int vshift = s->ps.sps->vshift[c_idx];
1039  uint8_t *dst = &s->frame->data[c_idx][(y0 >> vshift) * stride +
1040  ((x0 >> hshift) << s->ps.sps->pixel_shift)];
1041  int16_t *coeffs = (int16_t*)(c_idx ? lc->edge_emu_buffer2 : lc->edge_emu_buffer);
1042  uint8_t significant_coeff_group_flag[8][8] = {{0}};
1043  int explicit_rdpcm_flag = 0;
1044  int explicit_rdpcm_dir_flag;
1045 
1046  int trafo_size = 1 << log2_trafo_size;
1047  int i;
1048  int qp,shift,add,scale,scale_m;
1049  static const uint8_t level_scale[] = { 40, 45, 51, 57, 64, 72 };
1050  const uint8_t *scale_matrix = NULL;
1051  uint8_t dc_scale;
1052  int pred_mode_intra = (c_idx == 0) ? lc->tu.intra_pred_mode :
1053  lc->tu.intra_pred_mode_c;
1054 
1055  memset(coeffs, 0, trafo_size * trafo_size * sizeof(int16_t));
1056 
1057  // Derive QP for dequant
1058  if (!lc->cu.cu_transquant_bypass_flag) {
1059  static const int qp_c[] = { 29, 30, 31, 32, 33, 33, 34, 34, 35, 35, 36, 36, 37, 37 };
1060  static const uint8_t rem6[51 + 4 * 6 + 1] = {
1061  0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2,
1062  3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5,
1063  0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3,
1064  4, 5, 0, 1, 2, 3, 4, 5, 0, 1
1065  };
1066 
1067  static const uint8_t div6[51 + 4 * 6 + 1] = {
1068  0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 3, 3, 3,
1069  3, 3, 3, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6,
1070  7, 7, 7, 7, 7, 7, 8, 8, 8, 8, 8, 8, 9, 9, 9, 9, 9, 9, 10, 10, 10, 10,
1071  10, 10, 11, 11, 11, 11, 11, 11, 12, 12
1072  };
1073  int qp_y = lc->qp_y;
1074 
1076  log2_trafo_size <= s->ps.pps->log2_max_transform_skip_block_size) {
1077  transform_skip_flag = hevc_transform_skip_flag_decode(s, c_idx);
1078  }
1079 
1080  if (c_idx == 0) {
1081  qp = qp_y + s->ps.sps->qp_bd_offset;
1082  } else {
1083  int qp_i, offset;
1084 
1085  if (c_idx == 1)
1086  offset = s->ps.pps->cb_qp_offset + s->sh.slice_cb_qp_offset +
1087  lc->tu.cu_qp_offset_cb;
1088  else
1089  offset = s->ps.pps->cr_qp_offset + s->sh.slice_cr_qp_offset +
1090  lc->tu.cu_qp_offset_cr;
1091 
1092  qp_i = av_clip(qp_y + offset, - s->ps.sps->qp_bd_offset, 57);
1093  if (s->ps.sps->chroma_format_idc == 1) {
1094  if (qp_i < 30)
1095  qp = qp_i;
1096  else if (qp_i > 43)
1097  qp = qp_i - 6;
1098  else
1099  qp = qp_c[qp_i - 30];
1100  } else {
1101  if (qp_i > 51)
1102  qp = 51;
1103  else
1104  qp = qp_i;
1105  }
1106 
1107  qp += s->ps.sps->qp_bd_offset;
1108  }
1109 
1110  shift = s->ps.sps->bit_depth + log2_trafo_size - 5;
1111  add = 1 << (shift-1);
1112  scale = level_scale[rem6[qp]] << (div6[qp]);
1113  scale_m = 16; // default when no custom scaling lists.
1114  dc_scale = 16;
1115 
1116  if (s->ps.sps->scaling_list_enable_flag && !(transform_skip_flag && log2_trafo_size > 2)) {
1118  &s->ps.pps->scaling_list : &s->ps.sps->scaling_list;
1119  int matrix_id = lc->cu.pred_mode != MODE_INTRA;
1120 
1121  matrix_id = 3 * matrix_id + c_idx;
1122 
1123  scale_matrix = sl->sl[log2_trafo_size - 2][matrix_id];
1124  if (log2_trafo_size >= 4)
1125  dc_scale = sl->sl_dc[log2_trafo_size - 4][matrix_id];
1126  }
1127  } else {
1128  shift = 0;
1129  add = 0;
1130  scale = 0;
1131  dc_scale = 0;
1132  }
1133 
1135  (transform_skip_flag || lc->cu.cu_transquant_bypass_flag)) {
1136  explicit_rdpcm_flag = explicit_rdpcm_flag_decode(s, c_idx);
1137  if (explicit_rdpcm_flag) {
1138  explicit_rdpcm_dir_flag = explicit_rdpcm_dir_flag_decode(s, c_idx);
1139  }
1140  }
1141 
1142  last_significant_coeff_xy_prefix_decode(s, c_idx, log2_trafo_size,
1143  &last_significant_coeff_x, &last_significant_coeff_y);
1144 
1145  if (last_significant_coeff_x > 3) {
1146  int suffix = last_significant_coeff_suffix_decode(s, last_significant_coeff_x);
1147  last_significant_coeff_x = (1 << ((last_significant_coeff_x >> 1) - 1)) *
1148  (2 + (last_significant_coeff_x & 1)) +
1149  suffix;
1150  }
1151 
1152  if (last_significant_coeff_y > 3) {
1153  int suffix = last_significant_coeff_suffix_decode(s, last_significant_coeff_y);
1154  last_significant_coeff_y = (1 << ((last_significant_coeff_y >> 1) - 1)) *
1155  (2 + (last_significant_coeff_y & 1)) +
1156  suffix;
1157  }
1158 
1159  if (scan_idx == SCAN_VERT)
1160  FFSWAP(int, last_significant_coeff_x, last_significant_coeff_y);
1161 
1162  x_cg_last_sig = last_significant_coeff_x >> 2;
1163  y_cg_last_sig = last_significant_coeff_y >> 2;
1164 
1165  switch (scan_idx) {
1166  case SCAN_DIAG: {
1167  int last_x_c = last_significant_coeff_x & 3;
1168  int last_y_c = last_significant_coeff_y & 3;
1169 
1170  scan_x_off = ff_hevc_diag_scan4x4_x;
1171  scan_y_off = ff_hevc_diag_scan4x4_y;
1172  num_coeff = diag_scan4x4_inv[last_y_c][last_x_c];
1173  if (trafo_size == 4) {
1174  scan_x_cg = scan_1x1;
1175  scan_y_cg = scan_1x1;
1176  } else if (trafo_size == 8) {
1177  num_coeff += diag_scan2x2_inv[y_cg_last_sig][x_cg_last_sig] << 4;
1178  scan_x_cg = diag_scan2x2_x;
1179  scan_y_cg = diag_scan2x2_y;
1180  } else if (trafo_size == 16) {
1181  num_coeff += diag_scan4x4_inv[y_cg_last_sig][x_cg_last_sig] << 4;
1182  scan_x_cg = ff_hevc_diag_scan4x4_x;
1183  scan_y_cg = ff_hevc_diag_scan4x4_y;
1184  } else { // trafo_size == 32
1185  num_coeff += diag_scan8x8_inv[y_cg_last_sig][x_cg_last_sig] << 4;
1186  scan_x_cg = ff_hevc_diag_scan8x8_x;
1187  scan_y_cg = ff_hevc_diag_scan8x8_y;
1188  }
1189  break;
1190  }
1191  case SCAN_HORIZ:
1192  scan_x_cg = horiz_scan2x2_x;
1193  scan_y_cg = horiz_scan2x2_y;
1194  scan_x_off = horiz_scan4x4_x;
1195  scan_y_off = horiz_scan4x4_y;
1196  num_coeff = horiz_scan8x8_inv[last_significant_coeff_y][last_significant_coeff_x];
1197  break;
1198  default: //SCAN_VERT
1199  scan_x_cg = horiz_scan2x2_y;
1200  scan_y_cg = horiz_scan2x2_x;
1201  scan_x_off = horiz_scan4x4_y;
1202  scan_y_off = horiz_scan4x4_x;
1203  num_coeff = horiz_scan8x8_inv[last_significant_coeff_x][last_significant_coeff_y];
1204  break;
1205  }
1206  num_coeff++;
1207  num_last_subset = (num_coeff - 1) >> 4;
1208 
1209  for (i = num_last_subset; i >= 0; i--) {
1210  int n, m;
1211  int x_cg, y_cg, x_c, y_c, pos;
1212  int implicit_non_zero_coeff = 0;
1213  int64_t trans_coeff_level;
1214  int prev_sig = 0;
1215  int offset = i << 4;
1216  int rice_init = 0;
1217 
1218  uint8_t significant_coeff_flag_idx[16];
1219  uint8_t nb_significant_coeff_flag = 0;
1220 
1221  x_cg = scan_x_cg[i];
1222  y_cg = scan_y_cg[i];
1223 
1224  if ((i < num_last_subset) && (i > 0)) {
1225  int ctx_cg = 0;
1226  if (x_cg < (1 << (log2_trafo_size - 2)) - 1)
1227  ctx_cg += significant_coeff_group_flag[x_cg + 1][y_cg];
1228  if (y_cg < (1 << (log2_trafo_size - 2)) - 1)
1229  ctx_cg += significant_coeff_group_flag[x_cg][y_cg + 1];
1230 
1231  significant_coeff_group_flag[x_cg][y_cg] =
1232  significant_coeff_group_flag_decode(s, c_idx, ctx_cg);
1233  implicit_non_zero_coeff = 1;
1234  } else {
1235  significant_coeff_group_flag[x_cg][y_cg] =
1236  ((x_cg == x_cg_last_sig && y_cg == y_cg_last_sig) ||
1237  (x_cg == 0 && y_cg == 0));
1238  }
1239 
1240  last_scan_pos = num_coeff - offset - 1;
1241 
1242  if (i == num_last_subset) {
1243  n_end = last_scan_pos - 1;
1244  significant_coeff_flag_idx[0] = last_scan_pos;
1245  nb_significant_coeff_flag = 1;
1246  } else {
1247  n_end = 15;
1248  }
1249 
1250  if (x_cg < ((1 << log2_trafo_size) - 1) >> 2)
1251  prev_sig = !!significant_coeff_group_flag[x_cg + 1][y_cg];
1252  if (y_cg < ((1 << log2_trafo_size) - 1) >> 2)
1253  prev_sig += (!!significant_coeff_group_flag[x_cg][y_cg + 1] << 1);
1254 
1255  if (significant_coeff_group_flag[x_cg][y_cg] && n_end >= 0) {
1256  static const uint8_t ctx_idx_map[] = {
1257  0, 1, 4, 5, 2, 3, 4, 5, 6, 6, 8, 8, 7, 7, 8, 8, // log2_trafo_size == 2
1258  1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, // prev_sig == 0
1259  2, 2, 2, 2, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, // prev_sig == 1
1260  2, 1, 0, 0, 2, 1, 0, 0, 2, 1, 0, 0, 2, 1, 0, 0, // prev_sig == 2
1261  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2 // default
1262  };
1263  const uint8_t *ctx_idx_map_p;
1264  int scf_offset = 0;
1266  (transform_skip_flag || lc->cu.cu_transquant_bypass_flag)) {
1267  ctx_idx_map_p = (uint8_t*) &ctx_idx_map[4 * 16];
1268  if (c_idx == 0) {
1269  scf_offset = 40;
1270  } else {
1271  scf_offset = 14 + 27;
1272  }
1273  } else {
1274  if (c_idx != 0)
1275  scf_offset = 27;
1276  if (log2_trafo_size == 2) {
1277  ctx_idx_map_p = (uint8_t*) &ctx_idx_map[0];
1278  } else {
1279  ctx_idx_map_p = (uint8_t*) &ctx_idx_map[(prev_sig + 1) << 4];
1280  if (c_idx == 0) {
1281  if ((x_cg > 0 || y_cg > 0))
1282  scf_offset += 3;
1283  if (log2_trafo_size == 3) {
1284  scf_offset += (scan_idx == SCAN_DIAG) ? 9 : 15;
1285  } else {
1286  scf_offset += 21;
1287  }
1288  } else {
1289  if (log2_trafo_size == 3)
1290  scf_offset += 9;
1291  else
1292  scf_offset += 12;
1293  }
1294  }
1295  }
1296  for (n = n_end; n > 0; n--) {
1297  x_c = scan_x_off[n];
1298  y_c = scan_y_off[n];
1299  if (significant_coeff_flag_decode(s, x_c, y_c, scf_offset, ctx_idx_map_p)) {
1300  significant_coeff_flag_idx[nb_significant_coeff_flag] = n;
1301  nb_significant_coeff_flag++;
1302  implicit_non_zero_coeff = 0;
1303  }
1304  }
1305  if (implicit_non_zero_coeff == 0) {
1307  (transform_skip_flag || lc->cu.cu_transquant_bypass_flag)) {
1308  if (c_idx == 0) {
1309  scf_offset = 42;
1310  } else {
1311  scf_offset = 16 + 27;
1312  }
1313  } else {
1314  if (i == 0) {
1315  if (c_idx == 0)
1316  scf_offset = 0;
1317  else
1318  scf_offset = 27;
1319  } else {
1320  scf_offset = 2 + scf_offset;
1321  }
1322  }
1323  if (significant_coeff_flag_decode_0(s, c_idx, scf_offset) == 1) {
1324  significant_coeff_flag_idx[nb_significant_coeff_flag] = 0;
1325  nb_significant_coeff_flag++;
1326  }
1327  } else {
1328  significant_coeff_flag_idx[nb_significant_coeff_flag] = 0;
1329  nb_significant_coeff_flag++;
1330  }
1331  }
1332 
1333  n_end = nb_significant_coeff_flag;
1334 
1335 
1336  if (n_end) {
1337  int first_nz_pos_in_cg;
1338  int last_nz_pos_in_cg;
1339  int c_rice_param = 0;
1340  int first_greater1_coeff_idx = -1;
1341  uint8_t coeff_abs_level_greater1_flag[8];
1342  uint16_t coeff_sign_flag;
1343  int sum_abs = 0;
1344  int sign_hidden;
1345  int sb_type;
1346 
1347 
1348  // initialize first elem of coeff_bas_level_greater1_flag
1349  int ctx_set = (i > 0 && c_idx == 0) ? 2 : 0;
1350 
1352  if (!transform_skip_flag && !lc->cu.cu_transquant_bypass_flag)
1353  sb_type = 2 * (c_idx == 0 ? 1 : 0);
1354  else
1355  sb_type = 2 * (c_idx == 0 ? 1 : 0) + 1;
1356  c_rice_param = lc->stat_coeff[sb_type] / 4;
1357  }
1358 
1359  if (!(i == num_last_subset) && greater1_ctx == 0)
1360  ctx_set++;
1361  greater1_ctx = 1;
1362  last_nz_pos_in_cg = significant_coeff_flag_idx[0];
1363 
1364  for (m = 0; m < (n_end > 8 ? 8 : n_end); m++) {
1365  int inc = (ctx_set << 2) + greater1_ctx;
1366  coeff_abs_level_greater1_flag[m] =
1367  coeff_abs_level_greater1_flag_decode(s, c_idx, inc);
1368  if (coeff_abs_level_greater1_flag[m]) {
1369  greater1_ctx = 0;
1370  if (first_greater1_coeff_idx == -1)
1371  first_greater1_coeff_idx = m;
1372  } else if (greater1_ctx > 0 && greater1_ctx < 3) {
1373  greater1_ctx++;
1374  }
1375  }
1376  first_nz_pos_in_cg = significant_coeff_flag_idx[n_end - 1];
1377 
1378  if (lc->cu.cu_transquant_bypass_flag ||
1379  (lc->cu.pred_mode == MODE_INTRA &&
1380  s->ps.sps->implicit_rdpcm_enabled_flag && transform_skip_flag &&
1381  (pred_mode_intra == 10 || pred_mode_intra == 26 )) ||
1382  explicit_rdpcm_flag)
1383  sign_hidden = 0;
1384  else
1385  sign_hidden = (last_nz_pos_in_cg - first_nz_pos_in_cg >= 4);
1386 
1387  if (first_greater1_coeff_idx != -1) {
1388  coeff_abs_level_greater1_flag[first_greater1_coeff_idx] += coeff_abs_level_greater2_flag_decode(s, c_idx, ctx_set);
1389  }
1390  if (!s->ps.pps->sign_data_hiding_flag || !sign_hidden ) {
1391  coeff_sign_flag = coeff_sign_flag_decode(s, nb_significant_coeff_flag) << (16 - nb_significant_coeff_flag);
1392  } else {
1393  coeff_sign_flag = coeff_sign_flag_decode(s, nb_significant_coeff_flag - 1) << (16 - (nb_significant_coeff_flag - 1));
1394  }
1395 
1396  for (m = 0; m < n_end; m++) {
1397  n = significant_coeff_flag_idx[m];
1398  GET_COORD(offset, n);
1399  if (m < 8) {
1400  trans_coeff_level = 1 + coeff_abs_level_greater1_flag[m];
1401  if (trans_coeff_level == ((m == first_greater1_coeff_idx) ? 3 : 2)) {
1402  int last_coeff_abs_level_remaining = coeff_abs_level_remaining_decode(s, c_rice_param);
1403 
1404  trans_coeff_level += last_coeff_abs_level_remaining;
1405  if (trans_coeff_level > (3 << c_rice_param))
1406  c_rice_param = s->ps.sps->persistent_rice_adaptation_enabled_flag ? c_rice_param + 1 : FFMIN(c_rice_param + 1, 4);
1407  if (s->ps.sps->persistent_rice_adaptation_enabled_flag && !rice_init) {
1408  int c_rice_p_init = lc->stat_coeff[sb_type] / 4;
1409  if (last_coeff_abs_level_remaining >= (3 << c_rice_p_init))
1410  lc->stat_coeff[sb_type]++;
1411  else if (2 * last_coeff_abs_level_remaining < (1 << c_rice_p_init))
1412  if (lc->stat_coeff[sb_type] > 0)
1413  lc->stat_coeff[sb_type]--;
1414  rice_init = 1;
1415  }
1416  }
1417  } else {
1418  int last_coeff_abs_level_remaining = coeff_abs_level_remaining_decode(s, c_rice_param);
1419 
1420  trans_coeff_level = 1 + last_coeff_abs_level_remaining;
1421  if (trans_coeff_level > (3 << c_rice_param))
1422  c_rice_param = s->ps.sps->persistent_rice_adaptation_enabled_flag ? c_rice_param + 1 : FFMIN(c_rice_param + 1, 4);
1423  if (s->ps.sps->persistent_rice_adaptation_enabled_flag && !rice_init) {
1424  int c_rice_p_init = lc->stat_coeff[sb_type] / 4;
1425  if (last_coeff_abs_level_remaining >= (3 << c_rice_p_init))
1426  lc->stat_coeff[sb_type]++;
1427  else if (2 * last_coeff_abs_level_remaining < (1 << c_rice_p_init))
1428  if (lc->stat_coeff[sb_type] > 0)
1429  lc->stat_coeff[sb_type]--;
1430  rice_init = 1;
1431  }
1432  }
1433  if (s->ps.pps->sign_data_hiding_flag && sign_hidden) {
1434  sum_abs += trans_coeff_level;
1435  if (n == first_nz_pos_in_cg && (sum_abs&1))
1436  trans_coeff_level = -trans_coeff_level;
1437  }
1438  if (coeff_sign_flag >> 15)
1439  trans_coeff_level = -trans_coeff_level;
1440  coeff_sign_flag <<= 1;
1441  if(!lc->cu.cu_transquant_bypass_flag) {
1442  if (s->ps.sps->scaling_list_enable_flag && !(transform_skip_flag && log2_trafo_size > 2)) {
1443  if(y_c || x_c || log2_trafo_size < 4) {
1444  switch(log2_trafo_size) {
1445  case 3: pos = (y_c << 3) + x_c; break;
1446  case 4: pos = ((y_c >> 1) << 3) + (x_c >> 1); break;
1447  case 5: pos = ((y_c >> 2) << 3) + (x_c >> 2); break;
1448  default: pos = (y_c << 2) + x_c; break;
1449  }
1450  scale_m = scale_matrix[pos];
1451  } else {
1452  scale_m = dc_scale;
1453  }
1454  }
1455  trans_coeff_level = (trans_coeff_level * (int64_t)scale * (int64_t)scale_m + add) >> shift;
1456  if(trans_coeff_level < 0) {
1457  if((~trans_coeff_level) & 0xFffffffffff8000)
1458  trans_coeff_level = -32768;
1459  } else {
1460  if(trans_coeff_level & 0xffffffffffff8000)
1461  trans_coeff_level = 32767;
1462  }
1463  }
1464  coeffs[y_c * trafo_size + x_c] = trans_coeff_level;
1465  }
1466  }
1467  }
1468 
1469  if (lc->cu.cu_transquant_bypass_flag) {
1470  if (explicit_rdpcm_flag || (s->ps.sps->implicit_rdpcm_enabled_flag &&
1471  (pred_mode_intra == 10 || pred_mode_intra == 26))) {
1472  int mode = s->ps.sps->implicit_rdpcm_enabled_flag ? (pred_mode_intra == 26) : explicit_rdpcm_dir_flag;
1473 
1474  s->hevcdsp.transform_rdpcm(coeffs, log2_trafo_size, mode);
1475  }
1476  } else {
1477  if (transform_skip_flag) {
1479  log2_trafo_size == 2 &&
1480  lc->cu.pred_mode == MODE_INTRA;
1481  if (rot) {
1482  for (i = 0; i < 8; i++)
1483  FFSWAP(int16_t, coeffs[i], coeffs[16 - i - 1]);
1484  }
1485 
1486  s->hevcdsp.dequant(coeffs, log2_trafo_size);
1487 
1488  if (explicit_rdpcm_flag || (s->ps.sps->implicit_rdpcm_enabled_flag &&
1489  lc->cu.pred_mode == MODE_INTRA &&
1490  (pred_mode_intra == 10 || pred_mode_intra == 26))) {
1491  int mode = explicit_rdpcm_flag ? explicit_rdpcm_dir_flag : (pred_mode_intra == 26);
1492 
1493  s->hevcdsp.transform_rdpcm(coeffs, log2_trafo_size, mode);
1494  }
1495  } else if (lc->cu.pred_mode == MODE_INTRA && c_idx == 0 && log2_trafo_size == 2) {
1496  s->hevcdsp.transform_4x4_luma(coeffs);
1497  } else {
1498  int max_xy = FFMAX(last_significant_coeff_x, last_significant_coeff_y);
1499  if (max_xy == 0)
1500  s->hevcdsp.idct_dc[log2_trafo_size - 2](coeffs);
1501  else {
1502  int col_limit = last_significant_coeff_x + last_significant_coeff_y + 4;
1503  if (max_xy < 4)
1504  col_limit = FFMIN(4, col_limit);
1505  else if (max_xy < 8)
1506  col_limit = FFMIN(8, col_limit);
1507  else if (max_xy < 12)
1508  col_limit = FFMIN(24, col_limit);
1509  s->hevcdsp.idct[log2_trafo_size - 2](coeffs, col_limit);
1510  }
1511  }
1512  }
1513  if (lc->tu.cross_pf) {
1514  int16_t *coeffs_y = (int16_t*)lc->edge_emu_buffer;
1515 
1516  for (i = 0; i < (trafo_size * trafo_size); i++) {
1517  coeffs[i] = coeffs[i] + ((lc->tu.res_scale_val * coeffs_y[i]) >> 3);
1518  }
1519  }
1520  s->hevcdsp.add_residual[log2_trafo_size-2](dst, coeffs, stride);
1521 }
1522 
1523 void ff_hevc_hls_mvd_coding(HEVCContext *s, int x0, int y0, int log2_cb_size)
1524 {
1525  HEVCLocalContext *lc = s->HEVClc;
1526  int x = abs_mvd_greater0_flag_decode(s);
1527  int y = abs_mvd_greater0_flag_decode(s);
1528 
1529  if (x)
1531  if (y)
1533 
1534  switch (x) {
1535  case 2: lc->pu.mvd.x = mvd_decode(s); break;
1536  case 1: lc->pu.mvd.x = mvd_sign_flag_decode(s); break;
1537  case 0: lc->pu.mvd.x = 0; break;
1538  }
1539 
1540  switch (y) {
1541  case 2: lc->pu.mvd.y = mvd_decode(s); break;
1542  case 1: lc->pu.mvd.y = mvd_sign_flag_decode(s); break;
1543  case 0: lc->pu.mvd.y = 0; break;
1544  }
1545 }
1546 
static av_always_inline int significant_coeff_group_flag_decode(HEVCContext *s, int c_idx, int ctx_cg)
Definition: hevc_cabac.c:936
int8_t cu_qp_offset_cr
Definition: hevcdec.h:379
static av_unused const int8_t num_bins_in_se[]
number of bin by SyntaxElement.
Definition: hevc_cabac.c:37
uint8_t ctb_up_flag
Definition: hevcdec.h:442
const HEVCPPS * pps
Definition: hevc_ps.h:321
#define NULL
Definition: coverity.c:32
unsigned int log2_min_cb_size
Definition: hevc_ps.h:196
const char * s
Definition: avisynth_c.h:768
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
static int shift(int a, int b)
Definition: sonic.c:82
#define HEVC_CONTEXTS
Definition: hevcdec.h:54
int ff_hevc_split_coding_unit_flag_decode(HEVCContext *s, int ct_depth, int x0, int y0)
Definition: hevc_cabac.c:675
int transform_skip_rotation_enabled_flag
Definition: hevc_ps.h:206
int16_t x
horizontal component of motion vector
Definition: hevcdec.h:338
uint8_t * cabac_state
Definition: hevcdec.h:482
int vshift[3]
Definition: hevc_ps.h:228
int ff_hevc_cbf_luma_decode(HEVCContext *s, int trafo_depth)
Definition: hevc_cabac.c:865
int ff_hevc_sao_offset_sign_decode(HEVCContext *s)
Definition: hevc_cabac.c:585
const uint8_t * buffer
Definition: get_bits.h:57
PredictionUnit pu
Definition: hevcdec.h:455
HEVCParamSets ps
Definition: hevcdec.h:492
int explicit_rdpcm_enabled_flag
Definition: hevc_ps.h:209
void(* transform_rdpcm)(int16_t *coeffs, int16_t log2_size, int mode)
Definition: hevcdsp.h:53
int ff_hevc_merge_flag_decode(HEVCContext *s)
Definition: hevc_cabac.c:781
uint8_t dependent_slice_segment_flag
Definition: hevcdec.h:260
CABACContext cc
Definition: hevcdec.h:432
int stride
Definition: mace.c:144
Macro definitions for various function/variable attributes.
int qp_bd_offset
Definition: hevc_ps.h:230
void(* idct[4])(int16_t *coeffs, int col_limit)
Definition: hevcdsp.h:57
int pixel_shift
Definition: hevc_ps.h:155
uint8_t entropy_coding_sync_enabled_flag
Definition: hevc_ps.h:263
int ff_hevc_no_residual_syntax_flag_decode(HEVCContext *s)
Definition: hevc_cabac.c:817
int chroma_format_idc
Definition: hevc_ps.h:144
static av_always_inline int significant_coeff_flag_decode_0(HEVCContext *s, int c_idx, int offset)
Definition: hevc_cabac.c:951
enum HEVCSliceType slice_type
Definition: hevcdec.h:255
int ff_hevc_split_transform_flag_decode(HEVCContext *s, int log2_trafo_size)
Definition: hevc_cabac.c:855
int ff_hevc_sao_merge_flag_decode(HEVCContext *s)
Definition: hevc_cabac.c:550
int ff_hevc_rem_intra_luma_pred_mode_decode(HEVCContext *s)
Definition: hevc_cabac.c:749
uint8_t
static const uint8_t horiz_scan8x8_inv[8][8]
Definition: hevc_cabac.c:408
int ff_hevc_inter_pred_idc_decode(HEVCContext *s, int nPbW, int nPbH)
Definition: hevc_cabac.c:786
int ff_hevc_part_mode_decode(HEVCContext *s, int log2_cb_size)
Definition: hevc_cabac.c:694
const uint8_t ff_hevc_diag_scan8x8_x[64]
Definition: hevc_data.c:39
static int explicit_rdpcm_flag_decode(HEVCContext *s, int c_idx)
Definition: hevc_cabac.c:875
AVCodecContext * avctx
Definition: hevcdec.h:469
static void cabac_init_state(HEVCContext *s)
Definition: hevc_cabac.c:480
int min_cb_width
Definition: hevc_ps.h:219
int ff_hevc_prev_intra_luma_pred_flag_decode(HEVCContext *s)
Definition: hevc_cabac.c:736
static const uint8_t horiz_scan4x4_y[16]
Definition: hevc_cabac.c:401
uint8_t scaling_list_data_present_flag
Definition: hevc_ps.h:278
uint8_t first_slice_in_pic_flag
Definition: hevcdec.h:259
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:200
void ff_hevc_hls_mvd_coding(HEVCContext *s, int x0, int y0, int log2_cb_size)
Definition: hevc_cabac.c:1523
int ff_hevc_skip_flag_decode(HEVCContext *s, int x0, int y0, int x_cb, int y_cb)
Definition: hevc_cabac.c:607
uint8_t threads_number
Definition: hevcdec.h:477
int ff_hevc_cbf_cb_cr_decode(HEVCContext *s, int trafo_depth)
Definition: hevc_cabac.c:860
uint8_t * tab_ct_depth
Definition: hevcdec.h:531
uint8_t cu_transquant_bypass_flag
Definition: hevcdec.h:334
static av_unused const uint8_t * skip_bytes(CABACContext *c, int n)
Skip n bytes and reset the decoder.
int ff_hevc_log2_res_scale_abs(HEVCContext *s, int idx)
Definition: hevc_cabac.c:885
#define av_log(a,...)
HEVCDSPContext hevcdsp
Definition: hevcdec.h:520
void ff_hevc_cabac_init(HEVCContext *s, int ctb_addr_ts)
Definition: hevc_cabac.c:504
int ff_hevc_cu_chroma_qp_offset_idx(HEVCContext *s)
Definition: hevc_cabac.c:659
#define U(x)
Definition: vp56_arith.h:37
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:589
#define GET_CABAC(ctx)
Definition: hevc_cabac.c:548
const char * suffix
Definition: checkasm.c:138
int ff_hevc_cu_transquant_bypass_flag_decode(HEVCContext *s)
Definition: hevc_cabac.c:602
#define SAMPLE_CTB(tab, x, y)
Definition: hevcdec.h:74
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
static const uint8_t diag_scan4x4_inv[4][4]
Definition: hevc_cabac.c:432
int persistent_rice_adaptation_enabled_flag
coded frame dimension in various units
Definition: hevc_ps.h:211
uint8_t amp_enabled_flag
Definition: hevc_ps.h:178
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
unsigned int log2_ctb_size
Definition: hevc_ps.h:200
int8_t cu_qp_offset_cb
Definition: hevcdec.h:378
static const uint8_t offset[127][2]
Definition: vf_spp.c:92
int8_t slice_qp
Definition: hevcdec.h:305
#define FFMAX(a, b)
Definition: common.h:94
int ff_hevc_sao_band_position_decode(HEVCContext *s)
Definition: hevc_cabac.c:565
static int explicit_rdpcm_dir_flag_decode(HEVCContext *s, int c_idx)
Definition: hevc_cabac.c:880
uint8_t tiles_enabled_flag
Definition: hevc_ps.h:262
static const uint8_t diag_scan8x8_inv[8][8]
Definition: hevc_cabac.c:439
int intra_pred_mode
Definition: hevcdec.h:373
const HEVCSPS * sps
Definition: hevc_ps.h:320
int ff_hevc_sao_eo_class_decode(HEVCContext *s)
Definition: hevc_cabac.c:590
static av_always_inline int abs_mvd_greater1_flag_decode(HEVCContext *s)
Definition: hevc_cabac.c:827
int res_scale_val
Definition: hevcdec.h:370
int ff_hevc_res_scale_sign_flag(HEVCContext *s, int idx)
Definition: hevc_cabac.c:894
uint8_t cabac_state[HEVC_CONTEXTS]
Definition: hevcdec.h:425
#define FFMIN(a, b)
Definition: common.h:96
int slice_cr_qp_offset
Definition: hevcdec.h:291
int hshift[3]
Definition: hevc_ps.h:227
int ff_init_cabac_decoder(CABACContext *c, const uint8_t *buf, int buf_size)
Definition: cabac.c:177
void(* idct_dc[4])(int16_t *coeffs)
Definition: hevcdsp.h:59
static const uint8_t scan_1x1[1]
Definition: hevc_cabac.c:382
Context Adaptive Binary Arithmetic Coder inline functions.
int intra_pred_mode_c
Definition: hevcdec.h:374
int ctb_width
Definition: hevc_ps.h:216
uint8_t sl_dc[2][6]
Definition: hevc_ps.h:139
uint8_t sign_data_hiding_flag
Definition: hevc_ps.h:239
int n
Definition: avisynth_c.h:684
static av_always_inline int coeff_abs_level_greater1_flag_decode(HEVCContext *s, int c_idx, int inc)
Definition: hevc_cabac.c:956
static int av_unused get_cabac_terminate(CABACContext *c)
const uint8_t ff_hevc_diag_scan4x4_y[16]
Definition: hevc_data.c:32
if(ret< 0)
Definition: vf_mcdeint.c:282
static av_always_inline int mvd_decode(HEVCContext *s)
Definition: hevc_cabac.c:832
int implicit_rdpcm_enabled_flag
Definition: hevc_ps.h:208
static const uint8_t horiz_scan2x2_y[4]
Definition: hevc_cabac.c:390
uint8_t sl[4][6][64]
Definition: hevc_ps.h:138
static const uint8_t horiz_scan4x4_x[16]
Definition: hevc_cabac.c:394
static av_always_inline int coeff_abs_level_greater2_flag_decode(HEVCContext *s, int c_idx, int inc)
Definition: hevc_cabac.c:965
int ff_hevc_merge_idx_decode(HEVCContext *s)
Definition: hevc_cabac.c:770
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:898
int slice_cb_qp_offset
Definition: hevcdec.h:290
uint8_t transform_skip_enabled_flag
Definition: hevc_ps.h:248
static const uint8_t diag_scan2x2_x[4]
Definition: hevc_cabac.c:419
int * ctb_addr_rs_to_ts
CtbAddrRSToTS.
Definition: hevc_ps.h:302
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:218
int ff_hevc_end_of_slice_flag_decode(HEVCContext *s)
Definition: hevc_cabac.c:597
ScalingList scaling_list
Definition: hevc_ps.h:279
static av_always_inline int last_significant_coeff_suffix_decode(HEVCContext *s, int last_significant_coeff_prefix)
Definition: hevc_cabac.c:924
enum PredMode pred_mode
PredMode.
Definition: hevcdec.h:328
int16_t y
vertical component of motion vector
Definition: hevcdec.h:339
uint8_t cross_pf
Definition: hevcdec.h:380
void(* transform_4x4_luma)(int16_t *coeffs)
Definition: hevcdsp.h:55
TransformUnit tu
Definition: hevcdec.h:439
uint8_t ctb_left_flag
Definition: hevcdec.h:441
static const uint8_t horiz_scan2x2_x[4]
Definition: hevc_cabac.c:386
int transform_skip_context_enabled_flag
Definition: hevc_ps.h:207
int ff_hevc_cu_qp_delta_sign_flag(HEVCContext *s)
Definition: hevc_cabac.c:649
double value
Definition: eval.c:91
uint8_t cabac_init_flag
Definition: hevcdec.h:282
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:307
uint8_t stat_coeff[4]
Definition: hevcdec.h:427
AVFrame * frame
Definition: hevcdec.h:487
uint8_t edge_emu_buffer[(MAX_PB_SIZE+7) *EDGE_EMU_BUFFER_STRIDE *2]
Definition: hevcdec.h:448
void ff_hevc_save_states(HEVCContext *s, int ctb_addr_ts)
Definition: hevc_cabac.c:450
void(* add_residual[4])(uint8_t *dst, int16_t *res, ptrdiff_t stride)
Definition: hevcdsp.h:49
GetBitContext gb
Definition: hevcdec.h:431
uint8_t scaling_list_enable_flag
Definition: hevc_ps.h:172
int * tile_id
TileId.
Definition: hevc_ps.h:304
#define CNU
Definition: hevc_cabac.c:144
int ff_hevc_ref_idx_lx_decode(HEVCContext *s, int num_ref_idx_lx)
Definition: hevc_cabac.c:796
HEVCLocalContext * HEVClc
Definition: hevcdec.h:474
int cr_qp_offset
Definition: hevc_ps.h:254
static av_always_inline int abs_mvd_greater0_flag_decode(HEVCContext *s)
Definition: hevc_cabac.c:822
ScalingList scaling_list
Definition: hevc_ps.h:173
static const uint8_t diag_scan2x2_inv[2][2]
Definition: hevc_cabac.c:427
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:201
int ff_hevc_cu_chroma_qp_offset_flag(HEVCContext *s)
Definition: hevc_cabac.c:654
static av_always_inline int get_cabac_bypass_sign(CABACContext *c, int val)
static int av_unused get_cabac_bypass(CABACContext *c)
static void load_states(HEVCContext *s)
Definition: hevc_cabac.c:460
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:944
const uint8_t ff_hevc_diag_scan4x4_x[16]
Definition: hevc_data.c:25
uint8_t * skip_flag
Definition: hevcdec.h:530
#define CABAC_MAX_BIN
Definition: hevc_cabac.c:32
static int hevc_transform_skip_flag_decode(HEVCContext *s, int c_idx)
Definition: hevc_cabac.c:870
int ff_hevc_intra_chroma_pred_mode_decode(HEVCContext *s)
Definition: hevc_cabac.c:759
common internal and external API header
static av_always_inline int coeff_sign_flag_decode(HEVCContext *s, uint8_t nb)
Definition: hevc_cabac.c:1003
#define GET_COORD(offset, n)
int slice_ctb_addr_rs
Definition: hevcdec.h:321
int ff_hevc_sao_type_idx_decode(HEVCContext *s)
Definition: hevc_cabac.c:555
uint8_t edge_emu_buffer2[(MAX_PB_SIZE+7) *EDGE_EMU_BUFFER_STRIDE *2]
Definition: hevcdec.h:450
uint8_t chroma_qp_offset_list_len_minus1
Definition: hevc_ps.h:289
const uint8_t ff_hevc_diag_scan8x8_y[64]
Definition: hevc_data.c:58
int ff_hevc_pred_mode_decode(HEVCContext *s)
Definition: hevc_cabac.c:670
CodingUnit cu
Definition: hevcdec.h:454
static const int16_t coeffs[]
int ff_hevc_mpm_idx_decode(HEVCContext *s)
Definition: hevc_cabac.c:741
int ff_hevc_pcm_flag_decode(HEVCContext *s)
Definition: hevc_cabac.c:731
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:1013
static const uint8_t * align_get_bits(GetBitContext *s)
Definition: get_bits.h:465
static void cabac_init_decoder(HEVCContext *s)
Definition: hevc_cabac.c:470
#define av_always_inline
Definition: attributes.h:39
int cb_qp_offset
Definition: hevc_ps.h:253
#define FFSWAP(type, a, b)
Definition: common.h:99
const char int length
Definition: avisynth_c.h:768
int bit_depth
Definition: hevc_ps.h:153
static const uint8_t init_values[3][HEVC_CONTEXTS]
Indexed by init_type.
Definition: hevc_cabac.c:148
int ff_hevc_sao_offset_abs_decode(HEVCContext *s)
Definition: hevc_cabac.c:575
SliceHeader sh
Definition: hevcdec.h:500
static av_always_inline int coeff_abs_level_remaining_decode(HEVCContext *s, int rc_rice_param)
Definition: hevc_cabac.c:973
void(* dequant)(int16_t *coeffs, int16_t log2_size)
Definition: hevcdsp.h:51
ScanType
Definition: hevcdec.h:224
mode
Use these values in ebur128_init (or&#39;ed).
Definition: ebur128.h:83
static void cabac_reinit(HEVCLocalContext *lc)
Definition: hevc_cabac.c:465
static av_always_inline int mvd_sign_flag_decode(HEVCContext *s)
Definition: hevc_cabac.c:850
for(j=16;j >0;--j)
int ff_hevc_cu_qp_delta_abs(HEVCContext *s)
Definition: hevc_cabac.c:622
#define av_unused
Definition: attributes.h:125
static const uint8_t diag_scan2x2_y[4]
Definition: hevc_cabac.c:423
int ff_hevc_mvp_lx_flag_decode(HEVCContext *s)
Definition: hevc_cabac.c:812