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