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 += 1U << 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  return 0;
840  }
841  while (k--)
842  ret += get_cabac_bypass(&s->HEVClc->cc) << k;
843  return get_cabac_bypass_sign(&s->HEVClc->cc, -ret);
844 }
845 
847 {
848  return get_cabac_bypass_sign(&s->HEVClc->cc, -1);
849 }
850 
852 {
853  return GET_CABAC(elem_offset[SPLIT_TRANSFORM_FLAG] + 5 - log2_trafo_size);
854 }
855 
856 int ff_hevc_cbf_cb_cr_decode(HEVCContext *s, int trafo_depth)
857 {
858  return GET_CABAC(elem_offset[CBF_CB_CR] + trafo_depth);
859 }
860 
861 int ff_hevc_cbf_luma_decode(HEVCContext *s, int trafo_depth)
862 {
863  return GET_CABAC(elem_offset[CBF_LUMA] + !trafo_depth);
864 }
865 
867 {
868  return GET_CABAC(elem_offset[TRANSFORM_SKIP_FLAG] + !!c_idx);
869 }
870 
871 static int explicit_rdpcm_flag_decode(HEVCContext *s, int c_idx)
872 {
873  return GET_CABAC(elem_offset[EXPLICIT_RDPCM_FLAG] + !!c_idx);
874 }
875 
877 {
878  return GET_CABAC(elem_offset[EXPLICIT_RDPCM_DIR_FLAG] + !!c_idx);
879 }
880 
882  int i =0;
883 
884  while (i < 4 && GET_CABAC(elem_offset[LOG2_RES_SCALE_ABS] + 4 * idx + i))
885  i++;
886 
887  return i;
888 }
889 
892 }
893 
895  int log2_size, int *last_scx_prefix, int *last_scy_prefix)
896 {
897  int i = 0;
898  int max = (log2_size << 1) - 1;
899  int ctx_offset, ctx_shift;
900 
901  if (!c_idx) {
902  ctx_offset = 3 * (log2_size - 2) + ((log2_size - 1) >> 2);
903  ctx_shift = (log2_size + 1) >> 2;
904  } else {
905  ctx_offset = 15;
906  ctx_shift = log2_size - 2;
907  }
908  while (i < max &&
909  GET_CABAC(elem_offset[LAST_SIGNIFICANT_COEFF_X_PREFIX] + (i >> ctx_shift) + ctx_offset))
910  i++;
911  *last_scx_prefix = i;
912 
913  i = 0;
914  while (i < max &&
915  GET_CABAC(elem_offset[LAST_SIGNIFICANT_COEFF_Y_PREFIX] + (i >> ctx_shift) + ctx_offset))
916  i++;
917  *last_scy_prefix = i;
918 }
919 
921  int last_significant_coeff_prefix)
922 {
923  int i;
924  int length = (last_significant_coeff_prefix >> 1) - 1;
925  int value = get_cabac_bypass(&s->HEVClc->cc);
926 
927  for (i = 1; i < length; i++)
928  value = (value << 1) | get_cabac_bypass(&s->HEVClc->cc);
929  return value;
930 }
931 
933 {
934  int inc;
935 
936  inc = FFMIN(ctx_cg, 1) + (c_idx>0 ? 2 : 0);
937 
939 }
941  int offset, const uint8_t *ctx_idx_map)
942 {
943  int inc = ctx_idx_map[(y_c << 2) + x_c] + offset;
945 }
946 
948 {
949  return GET_CABAC(elem_offset[SIGNIFICANT_COEFF_FLAG] + offset);
950 }
951 
953 {
954 
955  if (c_idx > 0)
956  inc += 16;
957 
959 }
960 
962 {
963  if (c_idx > 0)
964  inc += 4;
965 
967 }
968 
970 {
971  int prefix = 0;
972  int suffix = 0;
973  int last_coeff_abs_level_remaining;
974  int i;
975 
976  while (prefix < CABAC_MAX_BIN && get_cabac_bypass(&s->HEVClc->cc))
977  prefix++;
978  if (prefix == CABAC_MAX_BIN) {
979  av_log(s->avctx, AV_LOG_ERROR, "CABAC_MAX_BIN : %d\n", prefix);
980  return 0;
981  }
982  if (prefix < 3) {
983  for (i = 0; i < rc_rice_param; i++)
984  suffix = (suffix << 1) | get_cabac_bypass(&s->HEVClc->cc);
985  last_coeff_abs_level_remaining = (prefix << rc_rice_param) + suffix;
986  } else {
987  int prefix_minus3 = prefix - 3;
988  for (i = 0; i < prefix_minus3 + rc_rice_param; i++)
989  suffix = (suffix << 1) | get_cabac_bypass(&s->HEVClc->cc);
990  last_coeff_abs_level_remaining = (((1 << prefix_minus3) + 3 - 1)
991  << rc_rice_param) + suffix;
992  }
993  return last_coeff_abs_level_remaining;
994 }
995 
997 {
998  int i;
999  int ret = 0;
1000 
1001  for (i = 0; i < nb; i++)
1002  ret = (ret << 1) | get_cabac_bypass(&s->HEVClc->cc);
1003  return ret;
1004 }
1005 
1007  int log2_trafo_size, enum ScanType scan_idx,
1008  int c_idx)
1009 {
1010 #define GET_COORD(offset, n) \
1011  do { \
1012  x_c = (x_cg << 2) + scan_x_off[n]; \
1013  y_c = (y_cg << 2) + scan_y_off[n]; \
1014  } while (0)
1015  HEVCLocalContext *lc = s->HEVClc;
1016  int transform_skip_flag = 0;
1017 
1018  int last_significant_coeff_x, last_significant_coeff_y;
1019  int last_scan_pos;
1020  int n_end;
1021  int num_coeff = 0;
1022  int greater1_ctx = 1;
1023 
1024  int num_last_subset;
1025  int x_cg_last_sig, y_cg_last_sig;
1026 
1027  const uint8_t *scan_x_cg, *scan_y_cg, *scan_x_off, *scan_y_off;
1028 
1029  ptrdiff_t stride = s->frame->linesize[c_idx];
1030  int hshift = s->ps.sps->hshift[c_idx];
1031  int vshift = s->ps.sps->vshift[c_idx];
1032  uint8_t *dst = &s->frame->data[c_idx][(y0 >> vshift) * stride +
1033  ((x0 >> hshift) << s->ps.sps->pixel_shift)];
1034  int16_t *coeffs = (int16_t*)(c_idx ? lc->edge_emu_buffer2 : lc->edge_emu_buffer);
1035  uint8_t significant_coeff_group_flag[8][8] = {{0}};
1036  int explicit_rdpcm_flag = 0;
1037  int explicit_rdpcm_dir_flag;
1038 
1039  int trafo_size = 1 << log2_trafo_size;
1040  int i;
1041  int qp,shift,add,scale,scale_m;
1042  const uint8_t level_scale[] = { 40, 45, 51, 57, 64, 72 };
1043  const uint8_t *scale_matrix = NULL;
1044  uint8_t dc_scale;
1045  int pred_mode_intra = (c_idx == 0) ? lc->tu.intra_pred_mode :
1046  lc->tu.intra_pred_mode_c;
1047 
1048  memset(coeffs, 0, trafo_size * trafo_size * sizeof(int16_t));
1049 
1050  // Derive QP for dequant
1051  if (!lc->cu.cu_transquant_bypass_flag) {
1052  static const int qp_c[] = { 29, 30, 31, 32, 33, 33, 34, 34, 35, 35, 36, 36, 37, 37 };
1053  static const uint8_t rem6[51 + 4 * 6 + 1] = {
1054  0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2,
1055  3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5,
1056  0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3,
1057  4, 5, 0, 1, 2, 3, 4, 5, 0, 1
1058  };
1059 
1060  static const uint8_t div6[51 + 4 * 6 + 1] = {
1061  0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 3, 3, 3,
1062  3, 3, 3, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6,
1063  7, 7, 7, 7, 7, 7, 8, 8, 8, 8, 8, 8, 9, 9, 9, 9, 9, 9, 10, 10, 10, 10,
1064  10, 10, 11, 11, 11, 11, 11, 11, 12, 12
1065  };
1066  int qp_y = lc->qp_y;
1067 
1069  log2_trafo_size <= s->ps.pps->log2_max_transform_skip_block_size) {
1070  transform_skip_flag = hevc_transform_skip_flag_decode(s, c_idx);
1071  }
1072 
1073  if (c_idx == 0) {
1074  qp = qp_y + s->ps.sps->qp_bd_offset;
1075  } else {
1076  int qp_i, offset;
1077 
1078  if (c_idx == 1)
1079  offset = s->ps.pps->cb_qp_offset + s->sh.slice_cb_qp_offset +
1080  lc->tu.cu_qp_offset_cb;
1081  else
1082  offset = s->ps.pps->cr_qp_offset + s->sh.slice_cr_qp_offset +
1083  lc->tu.cu_qp_offset_cr;
1084 
1085  qp_i = av_clip(qp_y + offset, - s->ps.sps->qp_bd_offset, 57);
1086  if (s->ps.sps->chroma_format_idc == 1) {
1087  if (qp_i < 30)
1088  qp = qp_i;
1089  else if (qp_i > 43)
1090  qp = qp_i - 6;
1091  else
1092  qp = qp_c[qp_i - 30];
1093  } else {
1094  if (qp_i > 51)
1095  qp = 51;
1096  else
1097  qp = qp_i;
1098  }
1099 
1100  qp += s->ps.sps->qp_bd_offset;
1101  }
1102 
1103  shift = s->ps.sps->bit_depth + log2_trafo_size - 5;
1104  add = 1 << (shift-1);
1105  scale = level_scale[rem6[qp]] << (div6[qp]);
1106  scale_m = 16; // default when no custom scaling lists.
1107  dc_scale = 16;
1108 
1109  if (s->ps.sps->scaling_list_enable_flag && !(transform_skip_flag && log2_trafo_size > 2)) {
1111  &s->ps.pps->scaling_list : &s->ps.sps->scaling_list;
1112  int matrix_id = lc->cu.pred_mode != MODE_INTRA;
1113 
1114  matrix_id = 3 * matrix_id + c_idx;
1115 
1116  scale_matrix = sl->sl[log2_trafo_size - 2][matrix_id];
1117  if (log2_trafo_size >= 4)
1118  dc_scale = sl->sl_dc[log2_trafo_size - 4][matrix_id];
1119  }
1120  } else {
1121  shift = 0;
1122  add = 0;
1123  scale = 0;
1124  dc_scale = 0;
1125  }
1126 
1128  (transform_skip_flag || lc->cu.cu_transquant_bypass_flag)) {
1129  explicit_rdpcm_flag = explicit_rdpcm_flag_decode(s, c_idx);
1130  if (explicit_rdpcm_flag) {
1131  explicit_rdpcm_dir_flag = explicit_rdpcm_dir_flag_decode(s, c_idx);
1132  }
1133  }
1134 
1135  last_significant_coeff_xy_prefix_decode(s, c_idx, log2_trafo_size,
1136  &last_significant_coeff_x, &last_significant_coeff_y);
1137 
1138  if (last_significant_coeff_x > 3) {
1139  int suffix = last_significant_coeff_suffix_decode(s, last_significant_coeff_x);
1140  last_significant_coeff_x = (1 << ((last_significant_coeff_x >> 1) - 1)) *
1141  (2 + (last_significant_coeff_x & 1)) +
1142  suffix;
1143  }
1144 
1145  if (last_significant_coeff_y > 3) {
1146  int suffix = last_significant_coeff_suffix_decode(s, last_significant_coeff_y);
1147  last_significant_coeff_y = (1 << ((last_significant_coeff_y >> 1) - 1)) *
1148  (2 + (last_significant_coeff_y & 1)) +
1149  suffix;
1150  }
1151 
1152  if (scan_idx == SCAN_VERT)
1153  FFSWAP(int, last_significant_coeff_x, last_significant_coeff_y);
1154 
1155  x_cg_last_sig = last_significant_coeff_x >> 2;
1156  y_cg_last_sig = last_significant_coeff_y >> 2;
1157 
1158  switch (scan_idx) {
1159  case SCAN_DIAG: {
1160  int last_x_c = last_significant_coeff_x & 3;
1161  int last_y_c = last_significant_coeff_y & 3;
1162 
1163  scan_x_off = ff_hevc_diag_scan4x4_x;
1164  scan_y_off = ff_hevc_diag_scan4x4_y;
1165  num_coeff = diag_scan4x4_inv[last_y_c][last_x_c];
1166  if (trafo_size == 4) {
1167  scan_x_cg = scan_1x1;
1168  scan_y_cg = scan_1x1;
1169  } else if (trafo_size == 8) {
1170  num_coeff += diag_scan2x2_inv[y_cg_last_sig][x_cg_last_sig] << 4;
1171  scan_x_cg = diag_scan2x2_x;
1172  scan_y_cg = diag_scan2x2_y;
1173  } else if (trafo_size == 16) {
1174  num_coeff += diag_scan4x4_inv[y_cg_last_sig][x_cg_last_sig] << 4;
1175  scan_x_cg = ff_hevc_diag_scan4x4_x;
1176  scan_y_cg = ff_hevc_diag_scan4x4_y;
1177  } else { // trafo_size == 32
1178  num_coeff += diag_scan8x8_inv[y_cg_last_sig][x_cg_last_sig] << 4;
1179  scan_x_cg = ff_hevc_diag_scan8x8_x;
1180  scan_y_cg = ff_hevc_diag_scan8x8_y;
1181  }
1182  break;
1183  }
1184  case SCAN_HORIZ:
1185  scan_x_cg = horiz_scan2x2_x;
1186  scan_y_cg = horiz_scan2x2_y;
1187  scan_x_off = horiz_scan4x4_x;
1188  scan_y_off = horiz_scan4x4_y;
1189  num_coeff = horiz_scan8x8_inv[last_significant_coeff_y][last_significant_coeff_x];
1190  break;
1191  default: //SCAN_VERT
1192  scan_x_cg = horiz_scan2x2_y;
1193  scan_y_cg = horiz_scan2x2_x;
1194  scan_x_off = horiz_scan4x4_y;
1195  scan_y_off = horiz_scan4x4_x;
1196  num_coeff = horiz_scan8x8_inv[last_significant_coeff_x][last_significant_coeff_y];
1197  break;
1198  }
1199  num_coeff++;
1200  num_last_subset = (num_coeff - 1) >> 4;
1201 
1202  for (i = num_last_subset; i >= 0; i--) {
1203  int n, m;
1204  int x_cg, y_cg, x_c, y_c, pos;
1205  int implicit_non_zero_coeff = 0;
1206  int64_t trans_coeff_level;
1207  int prev_sig = 0;
1208  int offset = i << 4;
1209  int rice_init = 0;
1210 
1211  uint8_t significant_coeff_flag_idx[16];
1212  uint8_t nb_significant_coeff_flag = 0;
1213 
1214  x_cg = scan_x_cg[i];
1215  y_cg = scan_y_cg[i];
1216 
1217  if ((i < num_last_subset) && (i > 0)) {
1218  int ctx_cg = 0;
1219  if (x_cg < (1 << (log2_trafo_size - 2)) - 1)
1220  ctx_cg += significant_coeff_group_flag[x_cg + 1][y_cg];
1221  if (y_cg < (1 << (log2_trafo_size - 2)) - 1)
1222  ctx_cg += significant_coeff_group_flag[x_cg][y_cg + 1];
1223 
1224  significant_coeff_group_flag[x_cg][y_cg] =
1225  significant_coeff_group_flag_decode(s, c_idx, ctx_cg);
1226  implicit_non_zero_coeff = 1;
1227  } else {
1228  significant_coeff_group_flag[x_cg][y_cg] =
1229  ((x_cg == x_cg_last_sig && y_cg == y_cg_last_sig) ||
1230  (x_cg == 0 && y_cg == 0));
1231  }
1232 
1233  last_scan_pos = num_coeff - offset - 1;
1234 
1235  if (i == num_last_subset) {
1236  n_end = last_scan_pos - 1;
1237  significant_coeff_flag_idx[0] = last_scan_pos;
1238  nb_significant_coeff_flag = 1;
1239  } else {
1240  n_end = 15;
1241  }
1242 
1243  if (x_cg < ((1 << log2_trafo_size) - 1) >> 2)
1244  prev_sig = !!significant_coeff_group_flag[x_cg + 1][y_cg];
1245  if (y_cg < ((1 << log2_trafo_size) - 1) >> 2)
1246  prev_sig += (!!significant_coeff_group_flag[x_cg][y_cg + 1] << 1);
1247 
1248  if (significant_coeff_group_flag[x_cg][y_cg] && n_end >= 0) {
1249  static const uint8_t ctx_idx_map[] = {
1250  0, 1, 4, 5, 2, 3, 4, 5, 6, 6, 8, 8, 7, 7, 8, 8, // log2_trafo_size == 2
1251  1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, // prev_sig == 0
1252  2, 2, 2, 2, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, // prev_sig == 1
1253  2, 1, 0, 0, 2, 1, 0, 0, 2, 1, 0, 0, 2, 1, 0, 0, // prev_sig == 2
1254  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2 // default
1255  };
1256  const uint8_t *ctx_idx_map_p;
1257  int scf_offset = 0;
1259  (transform_skip_flag || lc->cu.cu_transquant_bypass_flag)) {
1260  ctx_idx_map_p = (uint8_t*) &ctx_idx_map[4 * 16];
1261  if (c_idx == 0) {
1262  scf_offset = 40;
1263  } else {
1264  scf_offset = 14 + 27;
1265  }
1266  } else {
1267  if (c_idx != 0)
1268  scf_offset = 27;
1269  if (log2_trafo_size == 2) {
1270  ctx_idx_map_p = (uint8_t*) &ctx_idx_map[0];
1271  } else {
1272  ctx_idx_map_p = (uint8_t*) &ctx_idx_map[(prev_sig + 1) << 4];
1273  if (c_idx == 0) {
1274  if ((x_cg > 0 || y_cg > 0))
1275  scf_offset += 3;
1276  if (log2_trafo_size == 3) {
1277  scf_offset += (scan_idx == SCAN_DIAG) ? 9 : 15;
1278  } else {
1279  scf_offset += 21;
1280  }
1281  } else {
1282  if (log2_trafo_size == 3)
1283  scf_offset += 9;
1284  else
1285  scf_offset += 12;
1286  }
1287  }
1288  }
1289  for (n = n_end; n > 0; n--) {
1290  x_c = scan_x_off[n];
1291  y_c = scan_y_off[n];
1292  if (significant_coeff_flag_decode(s, x_c, y_c, scf_offset, ctx_idx_map_p)) {
1293  significant_coeff_flag_idx[nb_significant_coeff_flag] = n;
1294  nb_significant_coeff_flag++;
1295  implicit_non_zero_coeff = 0;
1296  }
1297  }
1298  if (implicit_non_zero_coeff == 0) {
1300  (transform_skip_flag || lc->cu.cu_transquant_bypass_flag)) {
1301  if (c_idx == 0) {
1302  scf_offset = 42;
1303  } else {
1304  scf_offset = 16 + 27;
1305  }
1306  } else {
1307  if (i == 0) {
1308  if (c_idx == 0)
1309  scf_offset = 0;
1310  else
1311  scf_offset = 27;
1312  } else {
1313  scf_offset = 2 + scf_offset;
1314  }
1315  }
1316  if (significant_coeff_flag_decode_0(s, c_idx, scf_offset) == 1) {
1317  significant_coeff_flag_idx[nb_significant_coeff_flag] = 0;
1318  nb_significant_coeff_flag++;
1319  }
1320  } else {
1321  significant_coeff_flag_idx[nb_significant_coeff_flag] = 0;
1322  nb_significant_coeff_flag++;
1323  }
1324  }
1325 
1326  n_end = nb_significant_coeff_flag;
1327 
1328 
1329  if (n_end) {
1330  int first_nz_pos_in_cg;
1331  int last_nz_pos_in_cg;
1332  int c_rice_param = 0;
1333  int first_greater1_coeff_idx = -1;
1334  uint8_t coeff_abs_level_greater1_flag[8];
1335  uint16_t coeff_sign_flag;
1336  int sum_abs = 0;
1337  int sign_hidden;
1338  int sb_type;
1339 
1340 
1341  // initialize first elem of coeff_bas_level_greater1_flag
1342  int ctx_set = (i > 0 && c_idx == 0) ? 2 : 0;
1343 
1345  if (!transform_skip_flag && !lc->cu.cu_transquant_bypass_flag)
1346  sb_type = 2 * (c_idx == 0 ? 1 : 0);
1347  else
1348  sb_type = 2 * (c_idx == 0 ? 1 : 0) + 1;
1349  c_rice_param = lc->stat_coeff[sb_type] / 4;
1350  }
1351 
1352  if (!(i == num_last_subset) && greater1_ctx == 0)
1353  ctx_set++;
1354  greater1_ctx = 1;
1355  last_nz_pos_in_cg = significant_coeff_flag_idx[0];
1356 
1357  for (m = 0; m < (n_end > 8 ? 8 : n_end); m++) {
1358  int inc = (ctx_set << 2) + greater1_ctx;
1359  coeff_abs_level_greater1_flag[m] =
1360  coeff_abs_level_greater1_flag_decode(s, c_idx, inc);
1361  if (coeff_abs_level_greater1_flag[m]) {
1362  greater1_ctx = 0;
1363  if (first_greater1_coeff_idx == -1)
1364  first_greater1_coeff_idx = m;
1365  } else if (greater1_ctx > 0 && greater1_ctx < 3) {
1366  greater1_ctx++;
1367  }
1368  }
1369  first_nz_pos_in_cg = significant_coeff_flag_idx[n_end - 1];
1370 
1371  if (lc->cu.cu_transquant_bypass_flag ||
1372  (lc->cu.pred_mode == MODE_INTRA &&
1373  s->ps.sps->implicit_rdpcm_enabled_flag && transform_skip_flag &&
1374  (pred_mode_intra == 10 || pred_mode_intra == 26 )) ||
1375  explicit_rdpcm_flag)
1376  sign_hidden = 0;
1377  else
1378  sign_hidden = (last_nz_pos_in_cg - first_nz_pos_in_cg >= 4);
1379 
1380  if (first_greater1_coeff_idx != -1) {
1381  coeff_abs_level_greater1_flag[first_greater1_coeff_idx] += coeff_abs_level_greater2_flag_decode(s, c_idx, ctx_set);
1382  }
1383  if (!s->ps.pps->sign_data_hiding_flag || !sign_hidden ) {
1384  coeff_sign_flag = coeff_sign_flag_decode(s, nb_significant_coeff_flag) << (16 - nb_significant_coeff_flag);
1385  } else {
1386  coeff_sign_flag = coeff_sign_flag_decode(s, nb_significant_coeff_flag - 1) << (16 - (nb_significant_coeff_flag - 1));
1387  }
1388 
1389  for (m = 0; m < n_end; m++) {
1390  n = significant_coeff_flag_idx[m];
1391  GET_COORD(offset, n);
1392  if (m < 8) {
1393  trans_coeff_level = 1 + coeff_abs_level_greater1_flag[m];
1394  if (trans_coeff_level == ((m == first_greater1_coeff_idx) ? 3 : 2)) {
1395  int last_coeff_abs_level_remaining = coeff_abs_level_remaining_decode(s, c_rice_param);
1396 
1397  trans_coeff_level += last_coeff_abs_level_remaining;
1398  if (trans_coeff_level > (3 << c_rice_param))
1399  c_rice_param = s->ps.sps->persistent_rice_adaptation_enabled_flag ? c_rice_param + 1 : FFMIN(c_rice_param + 1, 4);
1400  if (s->ps.sps->persistent_rice_adaptation_enabled_flag && !rice_init) {
1401  int c_rice_p_init = lc->stat_coeff[sb_type] / 4;
1402  if (last_coeff_abs_level_remaining >= (3 << c_rice_p_init))
1403  lc->stat_coeff[sb_type]++;
1404  else if (2 * last_coeff_abs_level_remaining < (1 << c_rice_p_init))
1405  if (lc->stat_coeff[sb_type] > 0)
1406  lc->stat_coeff[sb_type]--;
1407  rice_init = 1;
1408  }
1409  }
1410  } else {
1411  int last_coeff_abs_level_remaining = coeff_abs_level_remaining_decode(s, c_rice_param);
1412 
1413  trans_coeff_level = 1 + last_coeff_abs_level_remaining;
1414  if (trans_coeff_level > (3 << c_rice_param))
1415  c_rice_param = s->ps.sps->persistent_rice_adaptation_enabled_flag ? c_rice_param + 1 : FFMIN(c_rice_param + 1, 4);
1416  if (s->ps.sps->persistent_rice_adaptation_enabled_flag && !rice_init) {
1417  int c_rice_p_init = lc->stat_coeff[sb_type] / 4;
1418  if (last_coeff_abs_level_remaining >= (3 << c_rice_p_init))
1419  lc->stat_coeff[sb_type]++;
1420  else if (2 * last_coeff_abs_level_remaining < (1 << c_rice_p_init))
1421  if (lc->stat_coeff[sb_type] > 0)
1422  lc->stat_coeff[sb_type]--;
1423  rice_init = 1;
1424  }
1425  }
1426  if (s->ps.pps->sign_data_hiding_flag && sign_hidden) {
1427  sum_abs += trans_coeff_level;
1428  if (n == first_nz_pos_in_cg && (sum_abs&1))
1429  trans_coeff_level = -trans_coeff_level;
1430  }
1431  if (coeff_sign_flag >> 15)
1432  trans_coeff_level = -trans_coeff_level;
1433  coeff_sign_flag <<= 1;
1434  if(!lc->cu.cu_transquant_bypass_flag) {
1435  if (s->ps.sps->scaling_list_enable_flag && !(transform_skip_flag && log2_trafo_size > 2)) {
1436  if(y_c || x_c || log2_trafo_size < 4) {
1437  switch(log2_trafo_size) {
1438  case 3: pos = (y_c << 3) + x_c; break;
1439  case 4: pos = ((y_c >> 1) << 3) + (x_c >> 1); break;
1440  case 5: pos = ((y_c >> 2) << 3) + (x_c >> 2); break;
1441  default: pos = (y_c << 2) + x_c; break;
1442  }
1443  scale_m = scale_matrix[pos];
1444  } else {
1445  scale_m = dc_scale;
1446  }
1447  }
1448  trans_coeff_level = (trans_coeff_level * (int64_t)scale * (int64_t)scale_m + add) >> shift;
1449  if(trans_coeff_level < 0) {
1450  if((~trans_coeff_level) & 0xFffffffffff8000)
1451  trans_coeff_level = -32768;
1452  } else {
1453  if(trans_coeff_level & 0xffffffffffff8000)
1454  trans_coeff_level = 32767;
1455  }
1456  }
1457  coeffs[y_c * trafo_size + x_c] = trans_coeff_level;
1458  }
1459  }
1460  }
1461 
1462  if (lc->cu.cu_transquant_bypass_flag) {
1463  if (explicit_rdpcm_flag || (s->ps.sps->implicit_rdpcm_enabled_flag &&
1464  (pred_mode_intra == 10 || pred_mode_intra == 26))) {
1465  int mode = s->ps.sps->implicit_rdpcm_enabled_flag ? (pred_mode_intra == 26) : explicit_rdpcm_dir_flag;
1466 
1467  s->hevcdsp.transform_rdpcm(coeffs, log2_trafo_size, mode);
1468  }
1469  } else {
1470  if (transform_skip_flag) {
1472  log2_trafo_size == 2 &&
1473  lc->cu.pred_mode == MODE_INTRA;
1474  if (rot) {
1475  for (i = 0; i < 8; i++)
1476  FFSWAP(int16_t, coeffs[i], coeffs[16 - i - 1]);
1477  }
1478 
1479  s->hevcdsp.transform_skip(coeffs, log2_trafo_size);
1480 
1481  if (explicit_rdpcm_flag || (s->ps.sps->implicit_rdpcm_enabled_flag &&
1482  lc->cu.pred_mode == MODE_INTRA &&
1483  (pred_mode_intra == 10 || pred_mode_intra == 26))) {
1484  int mode = explicit_rdpcm_flag ? explicit_rdpcm_dir_flag : (pred_mode_intra == 26);
1485 
1486  s->hevcdsp.transform_rdpcm(coeffs, log2_trafo_size, mode);
1487  }
1488  } else if (lc->cu.pred_mode == MODE_INTRA && c_idx == 0 && log2_trafo_size == 2) {
1489  s->hevcdsp.idct_4x4_luma(coeffs);
1490  } else {
1491  int max_xy = FFMAX(last_significant_coeff_x, last_significant_coeff_y);
1492  if (max_xy == 0)
1493  s->hevcdsp.idct_dc[log2_trafo_size-2](coeffs);
1494  else {
1495  int col_limit = last_significant_coeff_x + last_significant_coeff_y + 4;
1496  if (max_xy < 4)
1497  col_limit = FFMIN(4, col_limit);
1498  else if (max_xy < 8)
1499  col_limit = FFMIN(8, col_limit);
1500  else if (max_xy < 12)
1501  col_limit = FFMIN(24, col_limit);
1502  s->hevcdsp.idct[log2_trafo_size-2](coeffs, col_limit);
1503  }
1504  }
1505  }
1506  if (lc->tu.cross_pf) {
1507  int16_t *coeffs_y = (int16_t*)lc->edge_emu_buffer;
1508 
1509  for (i = 0; i < (trafo_size * trafo_size); i++) {
1510  coeffs[i] = coeffs[i] + ((lc->tu.res_scale_val * coeffs_y[i]) >> 3);
1511  }
1512  }
1513  s->hevcdsp.transform_add[log2_trafo_size-2](dst, coeffs, stride);
1514 }
1515 
1516 void ff_hevc_hls_mvd_coding(HEVCContext *s, int x0, int y0, int log2_cb_size)
1517 {
1518  HEVCLocalContext *lc = s->HEVClc;
1519  int x = abs_mvd_greater0_flag_decode(s);
1520  int y = abs_mvd_greater0_flag_decode(s);
1521 
1522  if (x)
1524  if (y)
1526 
1527  switch (x) {
1528  case 2: lc->pu.mvd.x = mvd_decode(s); break;
1529  case 1: lc->pu.mvd.x = mvd_sign_flag_decode(s); break;
1530  case 0: lc->pu.mvd.x = 0; break;
1531  }
1532 
1533  switch (y) {
1534  case 2: lc->pu.mvd.y = mvd_decode(s); break;
1535  case 1: lc->pu.mvd.y = mvd_sign_flag_decode(s); break;
1536  case 0: lc->pu.mvd.y = 0; break;
1537  }
1538 }
1539 
static av_always_inline int significant_coeff_group_flag_decode(HEVCContext *s, int c_idx, int ctx_cg)
Definition: hevc_cabac.c:932
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:861
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:947
int ff_hevc_split_transform_flag_decode(HEVCContext *s, int log2_trafo_size)
Definition: hevc_cabac.c:851
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:871
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:1516
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:856
uint8_t * tab_ct_depth
Definition: hevc.h:883
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:881
#define av_log(a,...)
unsigned m
Definition: audioconvert.c:187
HEVCDSPContext hevcdsp
Definition: hevc.h:872
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
#define U(x)
Definition: vp56_arith.h:37
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:607
#define GET_CABAC(ctx)
Definition: hevc_cabac.c:546
const char * suffix
Definition: checkasm.c:114
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:94
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:876
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:890
uint8_t cabac_state[HEVC_CONTEXTS]
Definition: hevc.h:777
#define FFMIN(a, b)
Definition: common.h:96
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
int ff_init_cabac_decoder(CABACContext *c, const uint8_t *buf, int buf_size)
Definition: cabac.c:178
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:952
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:961
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:894
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:209
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:920
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:305
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:192
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:940
GLint GLenum GLboolean GLsizei stride
Definition: opengl_enc.c:105
uint8_t * skip_flag
Definition: hevc.h:882
#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:866
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:282
Definition: hevc.h:258
static av_always_inline int coeff_sign_flag_decode(HEVCContext *s, uint8_t nb)
Definition: hevc_cabac.c:996
#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
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:1006
static const uint8_t * align_get_bits(GetBitContext *s)
Definition: get_bits.h:457
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:39
int cb_qp_offset
Definition: hevc.h:504
#define FFSWAP(type, a, b)
Definition: common.h:99
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:969
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:846
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:126
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