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_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  if (prefix == CABAC_MAX_BIN) {
983  av_log(s->avctx, AV_LOG_ERROR, "CABAC_MAX_BIN : %d\n", prefix);
984  return 0;
985  }
986  if (prefix < 3) {
987  for (i = 0; i < rc_rice_param; i++)
988  suffix = (suffix << 1) | get_cabac_bypass(&s->HEVClc->cc);
989  last_coeff_abs_level_remaining = (prefix << rc_rice_param) + suffix;
990  } else {
991  int prefix_minus3 = prefix - 3;
992  for (i = 0; i < prefix_minus3 + rc_rice_param; i++)
993  suffix = (suffix << 1) | get_cabac_bypass(&s->HEVClc->cc);
994  last_coeff_abs_level_remaining = (((1 << prefix_minus3) + 3 - 1)
995  << rc_rice_param) + suffix;
996  }
997  return last_coeff_abs_level_remaining;
998 }
999 
1001 {
1002  int i;
1003  int ret = 0;
1004 
1005  for (i = 0; i < nb; i++)
1006  ret = (ret << 1) | get_cabac_bypass(&s->HEVClc->cc);
1007  return ret;
1008 }
1009 
1011  int log2_trafo_size, enum ScanType scan_idx,
1012  int c_idx)
1013 {
1014 #define GET_COORD(offset, n) \
1015  do { \
1016  x_c = (x_cg << 2) + scan_x_off[n]; \
1017  y_c = (y_cg << 2) + scan_y_off[n]; \
1018  } while (0)
1019  HEVCLocalContext *lc = s->HEVClc;
1020  int transform_skip_flag = 0;
1021 
1022  int last_significant_coeff_x, last_significant_coeff_y;
1023  int last_scan_pos;
1024  int n_end;
1025  int num_coeff = 0;
1026  int greater1_ctx = 1;
1027 
1028  int num_last_subset;
1029  int x_cg_last_sig, y_cg_last_sig;
1030 
1031  const uint8_t *scan_x_cg, *scan_y_cg, *scan_x_off, *scan_y_off;
1032 
1033  ptrdiff_t stride = s->frame->linesize[c_idx];
1034  int hshift = s->ps.sps->hshift[c_idx];
1035  int vshift = s->ps.sps->vshift[c_idx];
1036  uint8_t *dst = &s->frame->data[c_idx][(y0 >> vshift) * stride +
1037  ((x0 >> hshift) << s->ps.sps->pixel_shift)];
1038  int16_t *coeffs = (int16_t*)(c_idx ? lc->edge_emu_buffer2 : lc->edge_emu_buffer);
1039  uint8_t significant_coeff_group_flag[8][8] = {{0}};
1040  int explicit_rdpcm_flag = 0;
1041  int explicit_rdpcm_dir_flag;
1042 
1043  int trafo_size = 1 << log2_trafo_size;
1044  int i;
1045  int qp,shift,add,scale,scale_m;
1046  static const uint8_t level_scale[] = { 40, 45, 51, 57, 64, 72 };
1047  const uint8_t *scale_matrix = NULL;
1048  uint8_t dc_scale;
1049  int pred_mode_intra = (c_idx == 0) ? lc->tu.intra_pred_mode :
1050  lc->tu.intra_pred_mode_c;
1051 
1052  memset(coeffs, 0, trafo_size * trafo_size * sizeof(int16_t));
1053 
1054  // Derive QP for dequant
1055  if (!lc->cu.cu_transquant_bypass_flag) {
1056  static const int qp_c[] = { 29, 30, 31, 32, 33, 33, 34, 34, 35, 35, 36, 36, 37, 37 };
1057  static const uint8_t rem6[51 + 4 * 6 + 1] = {
1058  0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2,
1059  3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5,
1060  0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3,
1061  4, 5, 0, 1, 2, 3, 4, 5, 0, 1
1062  };
1063 
1064  static const uint8_t div6[51 + 4 * 6 + 1] = {
1065  0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 3, 3, 3,
1066  3, 3, 3, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6,
1067  7, 7, 7, 7, 7, 7, 8, 8, 8, 8, 8, 8, 9, 9, 9, 9, 9, 9, 10, 10, 10, 10,
1068  10, 10, 11, 11, 11, 11, 11, 11, 12, 12
1069  };
1070  int qp_y = lc->qp_y;
1071 
1073  log2_trafo_size <= s->ps.pps->log2_max_transform_skip_block_size) {
1074  transform_skip_flag = hevc_transform_skip_flag_decode(s, c_idx);
1075  }
1076 
1077  if (c_idx == 0) {
1078  qp = qp_y + s->ps.sps->qp_bd_offset;
1079  } else {
1080  int qp_i, offset;
1081 
1082  if (c_idx == 1)
1083  offset = s->ps.pps->cb_qp_offset + s->sh.slice_cb_qp_offset +
1084  lc->tu.cu_qp_offset_cb;
1085  else
1086  offset = s->ps.pps->cr_qp_offset + s->sh.slice_cr_qp_offset +
1087  lc->tu.cu_qp_offset_cr;
1088 
1089  qp_i = av_clip(qp_y + offset, - s->ps.sps->qp_bd_offset, 57);
1090  if (s->ps.sps->chroma_format_idc == 1) {
1091  if (qp_i < 30)
1092  qp = qp_i;
1093  else if (qp_i > 43)
1094  qp = qp_i - 6;
1095  else
1096  qp = qp_c[qp_i - 30];
1097  } else {
1098  if (qp_i > 51)
1099  qp = 51;
1100  else
1101  qp = qp_i;
1102  }
1103 
1104  qp += s->ps.sps->qp_bd_offset;
1105  }
1106 
1107  shift = s->ps.sps->bit_depth + log2_trafo_size - 5;
1108  add = 1 << (shift-1);
1109  scale = level_scale[rem6[qp]] << (div6[qp]);
1110  scale_m = 16; // default when no custom scaling lists.
1111  dc_scale = 16;
1112 
1113  if (s->ps.sps->scaling_list_enable_flag && !(transform_skip_flag && log2_trafo_size > 2)) {
1115  &s->ps.pps->scaling_list : &s->ps.sps->scaling_list;
1116  int matrix_id = lc->cu.pred_mode != MODE_INTRA;
1117 
1118  matrix_id = 3 * matrix_id + c_idx;
1119 
1120  scale_matrix = sl->sl[log2_trafo_size - 2][matrix_id];
1121  if (log2_trafo_size >= 4)
1122  dc_scale = sl->sl_dc[log2_trafo_size - 4][matrix_id];
1123  }
1124  } else {
1125  shift = 0;
1126  add = 0;
1127  scale = 0;
1128  dc_scale = 0;
1129  }
1130 
1132  (transform_skip_flag || lc->cu.cu_transquant_bypass_flag)) {
1133  explicit_rdpcm_flag = explicit_rdpcm_flag_decode(s, c_idx);
1134  if (explicit_rdpcm_flag) {
1135  explicit_rdpcm_dir_flag = explicit_rdpcm_dir_flag_decode(s, c_idx);
1136  }
1137  }
1138 
1139  last_significant_coeff_xy_prefix_decode(s, c_idx, log2_trafo_size,
1140  &last_significant_coeff_x, &last_significant_coeff_y);
1141 
1142  if (last_significant_coeff_x > 3) {
1143  int suffix = last_significant_coeff_suffix_decode(s, last_significant_coeff_x);
1144  last_significant_coeff_x = (1 << ((last_significant_coeff_x >> 1) - 1)) *
1145  (2 + (last_significant_coeff_x & 1)) +
1146  suffix;
1147  }
1148 
1149  if (last_significant_coeff_y > 3) {
1150  int suffix = last_significant_coeff_suffix_decode(s, last_significant_coeff_y);
1151  last_significant_coeff_y = (1 << ((last_significant_coeff_y >> 1) - 1)) *
1152  (2 + (last_significant_coeff_y & 1)) +
1153  suffix;
1154  }
1155 
1156  if (scan_idx == SCAN_VERT)
1157  FFSWAP(int, last_significant_coeff_x, last_significant_coeff_y);
1158 
1159  x_cg_last_sig = last_significant_coeff_x >> 2;
1160  y_cg_last_sig = last_significant_coeff_y >> 2;
1161 
1162  switch (scan_idx) {
1163  case SCAN_DIAG: {
1164  int last_x_c = last_significant_coeff_x & 3;
1165  int last_y_c = last_significant_coeff_y & 3;
1166 
1167  scan_x_off = ff_hevc_diag_scan4x4_x;
1168  scan_y_off = ff_hevc_diag_scan4x4_y;
1169  num_coeff = diag_scan4x4_inv[last_y_c][last_x_c];
1170  if (trafo_size == 4) {
1171  scan_x_cg = scan_1x1;
1172  scan_y_cg = scan_1x1;
1173  } else if (trafo_size == 8) {
1174  num_coeff += diag_scan2x2_inv[y_cg_last_sig][x_cg_last_sig] << 4;
1175  scan_x_cg = diag_scan2x2_x;
1176  scan_y_cg = diag_scan2x2_y;
1177  } else if (trafo_size == 16) {
1178  num_coeff += diag_scan4x4_inv[y_cg_last_sig][x_cg_last_sig] << 4;
1179  scan_x_cg = ff_hevc_diag_scan4x4_x;
1180  scan_y_cg = ff_hevc_diag_scan4x4_y;
1181  } else { // trafo_size == 32
1182  num_coeff += diag_scan8x8_inv[y_cg_last_sig][x_cg_last_sig] << 4;
1183  scan_x_cg = ff_hevc_diag_scan8x8_x;
1184  scan_y_cg = ff_hevc_diag_scan8x8_y;
1185  }
1186  break;
1187  }
1188  case SCAN_HORIZ:
1189  scan_x_cg = horiz_scan2x2_x;
1190  scan_y_cg = horiz_scan2x2_y;
1191  scan_x_off = horiz_scan4x4_x;
1192  scan_y_off = horiz_scan4x4_y;
1193  num_coeff = horiz_scan8x8_inv[last_significant_coeff_y][last_significant_coeff_x];
1194  break;
1195  default: //SCAN_VERT
1196  scan_x_cg = horiz_scan2x2_y;
1197  scan_y_cg = horiz_scan2x2_x;
1198  scan_x_off = horiz_scan4x4_y;
1199  scan_y_off = horiz_scan4x4_x;
1200  num_coeff = horiz_scan8x8_inv[last_significant_coeff_x][last_significant_coeff_y];
1201  break;
1202  }
1203  num_coeff++;
1204  num_last_subset = (num_coeff - 1) >> 4;
1205 
1206  for (i = num_last_subset; i >= 0; i--) {
1207  int n, m;
1208  int x_cg, y_cg, x_c, y_c, pos;
1209  int implicit_non_zero_coeff = 0;
1210  int64_t trans_coeff_level;
1211  int prev_sig = 0;
1212  int offset = i << 4;
1213  int rice_init = 0;
1214 
1215  uint8_t significant_coeff_flag_idx[16];
1216  uint8_t nb_significant_coeff_flag = 0;
1217 
1218  x_cg = scan_x_cg[i];
1219  y_cg = scan_y_cg[i];
1220 
1221  if ((i < num_last_subset) && (i > 0)) {
1222  int ctx_cg = 0;
1223  if (x_cg < (1 << (log2_trafo_size - 2)) - 1)
1224  ctx_cg += significant_coeff_group_flag[x_cg + 1][y_cg];
1225  if (y_cg < (1 << (log2_trafo_size - 2)) - 1)
1226  ctx_cg += significant_coeff_group_flag[x_cg][y_cg + 1];
1227 
1228  significant_coeff_group_flag[x_cg][y_cg] =
1229  significant_coeff_group_flag_decode(s, c_idx, ctx_cg);
1230  implicit_non_zero_coeff = 1;
1231  } else {
1232  significant_coeff_group_flag[x_cg][y_cg] =
1233  ((x_cg == x_cg_last_sig && y_cg == y_cg_last_sig) ||
1234  (x_cg == 0 && y_cg == 0));
1235  }
1236 
1237  last_scan_pos = num_coeff - offset - 1;
1238 
1239  if (i == num_last_subset) {
1240  n_end = last_scan_pos - 1;
1241  significant_coeff_flag_idx[0] = last_scan_pos;
1242  nb_significant_coeff_flag = 1;
1243  } else {
1244  n_end = 15;
1245  }
1246 
1247  if (x_cg < ((1 << log2_trafo_size) - 1) >> 2)
1248  prev_sig = !!significant_coeff_group_flag[x_cg + 1][y_cg];
1249  if (y_cg < ((1 << log2_trafo_size) - 1) >> 2)
1250  prev_sig += (!!significant_coeff_group_flag[x_cg][y_cg + 1] << 1);
1251 
1252  if (significant_coeff_group_flag[x_cg][y_cg] && n_end >= 0) {
1253  static const uint8_t ctx_idx_map[] = {
1254  0, 1, 4, 5, 2, 3, 4, 5, 6, 6, 8, 8, 7, 7, 8, 8, // log2_trafo_size == 2
1255  1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, // prev_sig == 0
1256  2, 2, 2, 2, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, // prev_sig == 1
1257  2, 1, 0, 0, 2, 1, 0, 0, 2, 1, 0, 0, 2, 1, 0, 0, // prev_sig == 2
1258  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2 // default
1259  };
1260  const uint8_t *ctx_idx_map_p;
1261  int scf_offset = 0;
1263  (transform_skip_flag || lc->cu.cu_transquant_bypass_flag)) {
1264  ctx_idx_map_p = (uint8_t*) &ctx_idx_map[4 * 16];
1265  if (c_idx == 0) {
1266  scf_offset = 40;
1267  } else {
1268  scf_offset = 14 + 27;
1269  }
1270  } else {
1271  if (c_idx != 0)
1272  scf_offset = 27;
1273  if (log2_trafo_size == 2) {
1274  ctx_idx_map_p = (uint8_t*) &ctx_idx_map[0];
1275  } else {
1276  ctx_idx_map_p = (uint8_t*) &ctx_idx_map[(prev_sig + 1) << 4];
1277  if (c_idx == 0) {
1278  if ((x_cg > 0 || y_cg > 0))
1279  scf_offset += 3;
1280  if (log2_trafo_size == 3) {
1281  scf_offset += (scan_idx == SCAN_DIAG) ? 9 : 15;
1282  } else {
1283  scf_offset += 21;
1284  }
1285  } else {
1286  if (log2_trafo_size == 3)
1287  scf_offset += 9;
1288  else
1289  scf_offset += 12;
1290  }
1291  }
1292  }
1293  for (n = n_end; n > 0; n--) {
1294  x_c = scan_x_off[n];
1295  y_c = scan_y_off[n];
1296  if (significant_coeff_flag_decode(s, x_c, y_c, scf_offset, ctx_idx_map_p)) {
1297  significant_coeff_flag_idx[nb_significant_coeff_flag] = n;
1298  nb_significant_coeff_flag++;
1299  implicit_non_zero_coeff = 0;
1300  }
1301  }
1302  if (implicit_non_zero_coeff == 0) {
1304  (transform_skip_flag || lc->cu.cu_transquant_bypass_flag)) {
1305  if (c_idx == 0) {
1306  scf_offset = 42;
1307  } else {
1308  scf_offset = 16 + 27;
1309  }
1310  } else {
1311  if (i == 0) {
1312  if (c_idx == 0)
1313  scf_offset = 0;
1314  else
1315  scf_offset = 27;
1316  } else {
1317  scf_offset = 2 + scf_offset;
1318  }
1319  }
1320  if (significant_coeff_flag_decode_0(s, c_idx, scf_offset) == 1) {
1321  significant_coeff_flag_idx[nb_significant_coeff_flag] = 0;
1322  nb_significant_coeff_flag++;
1323  }
1324  } else {
1325  significant_coeff_flag_idx[nb_significant_coeff_flag] = 0;
1326  nb_significant_coeff_flag++;
1327  }
1328  }
1329 
1330  n_end = nb_significant_coeff_flag;
1331 
1332 
1333  if (n_end) {
1334  int first_nz_pos_in_cg;
1335  int last_nz_pos_in_cg;
1336  int c_rice_param = 0;
1337  int first_greater1_coeff_idx = -1;
1338  uint8_t coeff_abs_level_greater1_flag[8];
1339  uint16_t coeff_sign_flag;
1340  int sum_abs = 0;
1341  int sign_hidden;
1342  int sb_type;
1343 
1344 
1345  // initialize first elem of coeff_bas_level_greater1_flag
1346  int ctx_set = (i > 0 && c_idx == 0) ? 2 : 0;
1347 
1349  if (!transform_skip_flag && !lc->cu.cu_transquant_bypass_flag)
1350  sb_type = 2 * (c_idx == 0 ? 1 : 0);
1351  else
1352  sb_type = 2 * (c_idx == 0 ? 1 : 0) + 1;
1353  c_rice_param = lc->stat_coeff[sb_type] / 4;
1354  }
1355 
1356  if (!(i == num_last_subset) && greater1_ctx == 0)
1357  ctx_set++;
1358  greater1_ctx = 1;
1359  last_nz_pos_in_cg = significant_coeff_flag_idx[0];
1360 
1361  for (m = 0; m < (n_end > 8 ? 8 : n_end); m++) {
1362  int inc = (ctx_set << 2) + greater1_ctx;
1363  coeff_abs_level_greater1_flag[m] =
1364  coeff_abs_level_greater1_flag_decode(s, c_idx, inc);
1365  if (coeff_abs_level_greater1_flag[m]) {
1366  greater1_ctx = 0;
1367  if (first_greater1_coeff_idx == -1)
1368  first_greater1_coeff_idx = m;
1369  } else if (greater1_ctx > 0 && greater1_ctx < 3) {
1370  greater1_ctx++;
1371  }
1372  }
1373  first_nz_pos_in_cg = significant_coeff_flag_idx[n_end - 1];
1374 
1375  if (lc->cu.cu_transquant_bypass_flag ||
1376  (lc->cu.pred_mode == MODE_INTRA &&
1377  s->ps.sps->implicit_rdpcm_enabled_flag && transform_skip_flag &&
1378  (pred_mode_intra == 10 || pred_mode_intra == 26 )) ||
1379  explicit_rdpcm_flag)
1380  sign_hidden = 0;
1381  else
1382  sign_hidden = (last_nz_pos_in_cg - first_nz_pos_in_cg >= 4);
1383 
1384  if (first_greater1_coeff_idx != -1) {
1385  coeff_abs_level_greater1_flag[first_greater1_coeff_idx] += coeff_abs_level_greater2_flag_decode(s, c_idx, ctx_set);
1386  }
1387  if (!s->ps.pps->sign_data_hiding_flag || !sign_hidden ) {
1388  coeff_sign_flag = coeff_sign_flag_decode(s, nb_significant_coeff_flag) << (16 - nb_significant_coeff_flag);
1389  } else {
1390  coeff_sign_flag = coeff_sign_flag_decode(s, nb_significant_coeff_flag - 1) << (16 - (nb_significant_coeff_flag - 1));
1391  }
1392 
1393  for (m = 0; m < n_end; m++) {
1394  n = significant_coeff_flag_idx[m];
1395  GET_COORD(offset, n);
1396  if (m < 8) {
1397  trans_coeff_level = 1 + coeff_abs_level_greater1_flag[m];
1398  if (trans_coeff_level == ((m == first_greater1_coeff_idx) ? 3 : 2)) {
1399  int last_coeff_abs_level_remaining = coeff_abs_level_remaining_decode(s, c_rice_param);
1400 
1401  trans_coeff_level += last_coeff_abs_level_remaining;
1402  if (trans_coeff_level > (3 << c_rice_param))
1403  c_rice_param = s->ps.sps->persistent_rice_adaptation_enabled_flag ? c_rice_param + 1 : FFMIN(c_rice_param + 1, 4);
1404  if (s->ps.sps->persistent_rice_adaptation_enabled_flag && !rice_init) {
1405  int c_rice_p_init = lc->stat_coeff[sb_type] / 4;
1406  if (last_coeff_abs_level_remaining >= (3 << c_rice_p_init))
1407  lc->stat_coeff[sb_type]++;
1408  else if (2 * last_coeff_abs_level_remaining < (1 << c_rice_p_init))
1409  if (lc->stat_coeff[sb_type] > 0)
1410  lc->stat_coeff[sb_type]--;
1411  rice_init = 1;
1412  }
1413  }
1414  } else {
1415  int last_coeff_abs_level_remaining = coeff_abs_level_remaining_decode(s, c_rice_param);
1416 
1417  trans_coeff_level = 1 + last_coeff_abs_level_remaining;
1418  if (trans_coeff_level > (3 << c_rice_param))
1419  c_rice_param = s->ps.sps->persistent_rice_adaptation_enabled_flag ? c_rice_param + 1 : FFMIN(c_rice_param + 1, 4);
1420  if (s->ps.sps->persistent_rice_adaptation_enabled_flag && !rice_init) {
1421  int c_rice_p_init = lc->stat_coeff[sb_type] / 4;
1422  if (last_coeff_abs_level_remaining >= (3 << c_rice_p_init))
1423  lc->stat_coeff[sb_type]++;
1424  else if (2 * last_coeff_abs_level_remaining < (1 << c_rice_p_init))
1425  if (lc->stat_coeff[sb_type] > 0)
1426  lc->stat_coeff[sb_type]--;
1427  rice_init = 1;
1428  }
1429  }
1430  if (s->ps.pps->sign_data_hiding_flag && sign_hidden) {
1431  sum_abs += trans_coeff_level;
1432  if (n == first_nz_pos_in_cg && (sum_abs&1))
1433  trans_coeff_level = -trans_coeff_level;
1434  }
1435  if (coeff_sign_flag >> 15)
1436  trans_coeff_level = -trans_coeff_level;
1437  coeff_sign_flag <<= 1;
1438  if(!lc->cu.cu_transquant_bypass_flag) {
1439  if (s->ps.sps->scaling_list_enable_flag && !(transform_skip_flag && log2_trafo_size > 2)) {
1440  if(y_c || x_c || log2_trafo_size < 4) {
1441  switch(log2_trafo_size) {
1442  case 3: pos = (y_c << 3) + x_c; break;
1443  case 4: pos = ((y_c >> 1) << 3) + (x_c >> 1); break;
1444  case 5: pos = ((y_c >> 2) << 3) + (x_c >> 2); break;
1445  default: pos = (y_c << 2) + x_c; break;
1446  }
1447  scale_m = scale_matrix[pos];
1448  } else {
1449  scale_m = dc_scale;
1450  }
1451  }
1452  trans_coeff_level = (trans_coeff_level * (int64_t)scale * (int64_t)scale_m + add) >> shift;
1453  if(trans_coeff_level < 0) {
1454  if((~trans_coeff_level) & 0xFffffffffff8000)
1455  trans_coeff_level = -32768;
1456  } else {
1457  if(trans_coeff_level & 0xffffffffffff8000)
1458  trans_coeff_level = 32767;
1459  }
1460  }
1461  coeffs[y_c * trafo_size + x_c] = trans_coeff_level;
1462  }
1463  }
1464  }
1465 
1466  if (lc->cu.cu_transquant_bypass_flag) {
1467  if (explicit_rdpcm_flag || (s->ps.sps->implicit_rdpcm_enabled_flag &&
1468  (pred_mode_intra == 10 || pred_mode_intra == 26))) {
1469  int mode = s->ps.sps->implicit_rdpcm_enabled_flag ? (pred_mode_intra == 26) : explicit_rdpcm_dir_flag;
1470 
1471  s->hevcdsp.transform_rdpcm(coeffs, log2_trafo_size, mode);
1472  }
1473  } else {
1474  if (transform_skip_flag) {
1476  log2_trafo_size == 2 &&
1477  lc->cu.pred_mode == MODE_INTRA;
1478  if (rot) {
1479  for (i = 0; i < 8; i++)
1480  FFSWAP(int16_t, coeffs[i], coeffs[16 - i - 1]);
1481  }
1482 
1483  s->hevcdsp.dequant(coeffs, log2_trafo_size);
1484 
1485  if (explicit_rdpcm_flag || (s->ps.sps->implicit_rdpcm_enabled_flag &&
1486  lc->cu.pred_mode == MODE_INTRA &&
1487  (pred_mode_intra == 10 || pred_mode_intra == 26))) {
1488  int mode = explicit_rdpcm_flag ? explicit_rdpcm_dir_flag : (pred_mode_intra == 26);
1489 
1490  s->hevcdsp.transform_rdpcm(coeffs, log2_trafo_size, mode);
1491  }
1492  } else if (lc->cu.pred_mode == MODE_INTRA && c_idx == 0 && log2_trafo_size == 2) {
1493  s->hevcdsp.transform_4x4_luma(coeffs);
1494  } else {
1495  int max_xy = FFMAX(last_significant_coeff_x, last_significant_coeff_y);
1496  if (max_xy == 0)
1497  s->hevcdsp.idct_dc[log2_trafo_size - 2](coeffs);
1498  else {
1499  int col_limit = last_significant_coeff_x + last_significant_coeff_y + 4;
1500  if (max_xy < 4)
1501  col_limit = FFMIN(4, col_limit);
1502  else if (max_xy < 8)
1503  col_limit = FFMIN(8, col_limit);
1504  else if (max_xy < 12)
1505  col_limit = FFMIN(24, col_limit);
1506  s->hevcdsp.idct[log2_trafo_size - 2](coeffs, col_limit);
1507  }
1508  }
1509  }
1510  if (lc->tu.cross_pf) {
1511  int16_t *coeffs_y = (int16_t*)lc->edge_emu_buffer;
1512 
1513  for (i = 0; i < (trafo_size * trafo_size); i++) {
1514  coeffs[i] = coeffs[i] + ((lc->tu.res_scale_val * coeffs_y[i]) >> 3);
1515  }
1516  }
1517  s->hevcdsp.add_residual[log2_trafo_size-2](dst, coeffs, stride);
1518 }
1519 
1520 void ff_hevc_hls_mvd_coding(HEVCContext *s, int x0, int y0, int log2_cb_size)
1521 {
1522  HEVCLocalContext *lc = s->HEVClc;
1523  int x = abs_mvd_greater0_flag_decode(s);
1524  int y = abs_mvd_greater0_flag_decode(s);
1525 
1526  if (x)
1528  if (y)
1530 
1531  switch (x) {
1532  case 2: lc->pu.mvd.x = mvd_decode(s); break;
1533  case 1: lc->pu.mvd.x = mvd_sign_flag_decode(s); break;
1534  case 0: lc->pu.mvd.x = 0; break;
1535  }
1536 
1537  switch (y) {
1538  case 2: lc->pu.mvd.y = mvd_decode(s); break;
1539  case 1: lc->pu.mvd.y = mvd_sign_flag_decode(s); break;
1540  case 0: lc->pu.mvd.y = 0; break;
1541  }
1542 }
1543 
static av_always_inline int significant_coeff_group_flag_decode(HEVCContext *s, int c_idx, int ctx_cg)
Definition: hevc_cabac.c:936
void(* dequant)(int16_t *coeffs, int16_t log2_size)
Definition: hevcdsp.h:51
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:319
#define NULL
Definition: coverity.c:32
unsigned int log2_min_cb_size
Definition: hevc_ps.h:194
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
uint8_t edge_emu_buffer[(MAX_PB_SIZE+7)*EDGE_EMU_BUFFER_STRIDE *2]
Definition: hevcdec.h:448
int transform_skip_rotation_enabled_flag
Definition: hevc_ps.h:204
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:226
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:56
void(* transform_4x4_luma)(int16_t *coeffs)
Definition: hevcdsp.h:55
PredictionUnit pu
Definition: hevcdec.h:455
HEVCParamSets ps
Definition: hevcdec.h:492
int explicit_rdpcm_enabled_flag
Definition: hevc_ps.h:207
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
Macro definitions for various function/variable attributes.
int qp_bd_offset
Definition: hevc_ps.h:228
void(* idct[4])(int16_t *coeffs, int col_limit)
Definition: hevcdsp.h:57
int pixel_shift
Definition: hevc_ps.h:154
uint8_t entropy_coding_sync_enabled_flag
Definition: hevc_ps.h:261
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:217
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:276
uint8_t first_slice_in_pic_flag
Definition: hevcdec.h:259
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:199
void ff_hevc_hls_mvd_coding(HEVCContext *s, int x0, int y0, int log2_cb_size)
Definition: hevc_cabac.c:1520
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:587
#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:209
uint8_t amp_enabled_flag
Definition: hevc_ps.h:176
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:92
unsigned int log2_ctb_size
Definition: hevc_ps.h:198
int8_t cu_qp_offset_cb
Definition: hevcdec.h:378
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: hevcdec.h:305
#define FFMAX(a, b)
Definition: common.h:94
uint8_t edge_emu_buffer2[(MAX_PB_SIZE+7)*EDGE_EMU_BUFFER_STRIDE *2]
Definition: hevcdec.h:450
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:260
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:318
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
GLsizei GLboolean const GLfloat * value
Definition: opengl_enc.c:109
int hshift[3]
Definition: hevc_ps.h:225
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:214
uint8_t sl_dc[2][6]
Definition: hevc_ps.h:139
uint8_t sign_data_hiding_flag
Definition: hevc_ps.h:237
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
static av_always_inline int mvd_decode(HEVCContext *s)
Definition: hevc_cabac.c:832
int implicit_rdpcm_enabled_flag
Definition: hevc_ps.h:206
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:246
static const uint8_t diag_scan2x2_x[4]
Definition: hevc_cabac.c:419
int * ctb_addr_rs_to_ts
CtbAddrRSToTS.
Definition: hevc_ps.h:300
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:277
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
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:205
int ff_hevc_cu_qp_delta_sign_flag(HEVCContext *s)
Definition: hevc_cabac.c:649
uint8_t cabac_init_flag
Definition: hevcdec.h:282
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:306
uint8_t stat_coeff[4]
Definition: hevcdec.h:427
AVFrame * frame
Definition: hevcdec.h:487
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:170
int * tile_id
TileId.
Definition: hevc_ps.h:302
#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:252
static av_always_inline int abs_mvd_greater0_flag_decode(HEVCContext *s)
Definition: hevc_cabac.c:822
ScalingList scaling_list
Definition: hevc_ps.h:171
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
GLint GLenum GLboolean GLsizei stride
Definition: opengl_enc.c:105
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
if(ret< 0)
Definition: vf_mcdeint.c:282
static av_always_inline int coeff_sign_flag_decode(HEVCContext *s, uint8_t nb)
Definition: hevc_cabac.c:1000
#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 chroma_qp_offset_list_len_minus1
Definition: hevc_ps.h:287
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:1010
static const uint8_t * align_get_bits(GetBitContext *s)
Definition: get_bits.h:464
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:251
#define FFSWAP(type, a, b)
Definition: common.h:99
int bit_depth
Definition: hevc_ps.h:153
#define stride
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
ScanType
Definition: hevcdec.h:224
mode
Use these values in ebur128_init (or'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