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