FFmpeg  2.8.17
 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 
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 < 7 && get_cabac_bypass(&s->HEVClc->cc)) {
633  suffix_val += 1 << k;
634  k++;
635  }
636  if (k == 7) {
637  av_log(s->avctx, AV_LOG_ERROR, "CABAC_MAX_BIN : %d\n", k);
638  return AVERROR_INVALIDDATA;
639  }
640 
641  while (k--)
642  suffix_val += get_cabac_bypass(&s->HEVClc->cc) << k;
643  }
644  return prefix_val + suffix_val;
645 }
646 
648 {
649  return get_cabac_bypass(&s->HEVClc->cc);
650 }
651 
653 {
655 }
656 
658 {
659  int c_max= FFMAX(5, s->ps.pps->chroma_qp_offset_list_len_minus1);
660  int i = 0;
661 
662  while (i < c_max && GET_CABAC(elem_offset[CU_CHROMA_QP_OFFSET_IDX]))
663  i++;
664 
665  return i;
666 }
667 
669 {
671 }
672 
673 int ff_hevc_split_coding_unit_flag_decode(HEVCContext *s, int ct_depth, int x0, int y0)
674 {
675  int inc = 0, depth_left = 0, depth_top = 0;
676  int x0b = av_mod_uintp2(x0, s->ps.sps->log2_ctb_size);
677  int y0b = av_mod_uintp2(y0, s->ps.sps->log2_ctb_size);
678  int x_cb = x0 >> s->ps.sps->log2_min_cb_size;
679  int y_cb = y0 >> s->ps.sps->log2_min_cb_size;
680 
681  if (s->HEVClc->ctb_left_flag || x0b)
682  depth_left = s->tab_ct_depth[(y_cb) * s->ps.sps->min_cb_width + x_cb - 1];
683  if (s->HEVClc->ctb_up_flag || y0b)
684  depth_top = s->tab_ct_depth[(y_cb - 1) * s->ps.sps->min_cb_width + x_cb];
685 
686  inc += (depth_left > ct_depth);
687  inc += (depth_top > ct_depth);
688 
690 }
691 
692 int ff_hevc_part_mode_decode(HEVCContext *s, int log2_cb_size)
693 {
694  if (GET_CABAC(elem_offset[PART_MODE])) // 1
695  return PART_2Nx2N;
696  if (log2_cb_size == s->ps.sps->log2_min_cb_size) {
697  if (s->HEVClc->cu.pred_mode == MODE_INTRA) // 0
698  return PART_NxN;
699  if (GET_CABAC(elem_offset[PART_MODE] + 1)) // 01
700  return PART_2NxN;
701  if (log2_cb_size == 3) // 00
702  return PART_Nx2N;
703  if (GET_CABAC(elem_offset[PART_MODE] + 2)) // 001
704  return PART_Nx2N;
705  return PART_NxN; // 000
706  }
707 
708  if (!s->ps.sps->amp_enabled_flag) {
709  if (GET_CABAC(elem_offset[PART_MODE] + 1)) // 01
710  return PART_2NxN;
711  return PART_Nx2N;
712  }
713 
714  if (GET_CABAC(elem_offset[PART_MODE] + 1)) { // 01X, 01XX
715  if (GET_CABAC(elem_offset[PART_MODE] + 3)) // 011
716  return PART_2NxN;
717  if (get_cabac_bypass(&s->HEVClc->cc)) // 0101
718  return PART_2NxnD;
719  return PART_2NxnU; // 0100
720  }
721 
722  if (GET_CABAC(elem_offset[PART_MODE] + 3)) // 001
723  return PART_Nx2N;
724  if (get_cabac_bypass(&s->HEVClc->cc)) // 0001
725  return PART_nRx2N;
726  return PART_nLx2N; // 0000
727 }
728 
730 {
731  return get_cabac_terminate(&s->HEVClc->cc);
732 }
733 
735 {
737 }
738 
740 {
741  int i = 0;
742  while (i < 2 && get_cabac_bypass(&s->HEVClc->cc))
743  i++;
744  return i;
745 }
746 
748 {
749  int i;
750  int value = get_cabac_bypass(&s->HEVClc->cc);
751 
752  for (i = 0; i < 4; i++)
753  value = (value << 1) | get_cabac_bypass(&s->HEVClc->cc);
754  return value;
755 }
756 
758 {
759  int ret;
761  return 4;
762 
763  ret = get_cabac_bypass(&s->HEVClc->cc) << 1;
764  ret |= get_cabac_bypass(&s->HEVClc->cc);
765  return ret;
766 }
767 
769 {
770  int i = GET_CABAC(elem_offset[MERGE_IDX]);
771 
772  if (i != 0) {
773  while (i < s->sh.max_num_merge_cand-1 && get_cabac_bypass(&s->HEVClc->cc))
774  i++;
775  }
776  return i;
777 }
778 
780 {
782 }
783 
784 int ff_hevc_inter_pred_idc_decode(HEVCContext *s, int nPbW, int nPbH)
785 {
786  if (nPbW + nPbH == 12)
787  return GET_CABAC(elem_offset[INTER_PRED_IDC] + 4);
789  return PRED_BI;
790 
791  return GET_CABAC(elem_offset[INTER_PRED_IDC] + 4);
792 }
793 
794 int ff_hevc_ref_idx_lx_decode(HEVCContext *s, int num_ref_idx_lx)
795 {
796  int i = 0;
797  int max = num_ref_idx_lx - 1;
798  int max_ctx = FFMIN(max, 2);
799 
800  while (i < max_ctx && GET_CABAC(elem_offset[REF_IDX_L0] + i))
801  i++;
802  if (i == 2) {
803  while (i < max && get_cabac_bypass(&s->HEVClc->cc))
804  i++;
805  }
806 
807  return i;
808 }
809 
811 {
813 }
814 
816 {
818 }
819 
821 {
823 }
824 
826 {
828 }
829 
831 {
832  int ret = 2;
833  int k = 1;
834 
835  while (k < CABAC_MAX_BIN && get_cabac_bypass(&s->HEVClc->cc)) {
836  ret += 1U << k;
837  k++;
838  }
839  if (k == CABAC_MAX_BIN) {
840  av_log(s->avctx, AV_LOG_ERROR, "CABAC_MAX_BIN : %d\n", k);
841  return 0;
842  }
843  while (k--)
844  ret += get_cabac_bypass(&s->HEVClc->cc) << k;
845  return get_cabac_bypass_sign(&s->HEVClc->cc, -ret);
846 }
847 
849 {
850  return get_cabac_bypass_sign(&s->HEVClc->cc, -1);
851 }
852 
854 {
855  return GET_CABAC(elem_offset[SPLIT_TRANSFORM_FLAG] + 5 - log2_trafo_size);
856 }
857 
858 int ff_hevc_cbf_cb_cr_decode(HEVCContext *s, int trafo_depth)
859 {
860  return GET_CABAC(elem_offset[CBF_CB_CR] + trafo_depth);
861 }
862 
863 int ff_hevc_cbf_luma_decode(HEVCContext *s, int trafo_depth)
864 {
865  return GET_CABAC(elem_offset[CBF_LUMA] + !trafo_depth);
866 }
867 
869 {
870  return GET_CABAC(elem_offset[TRANSFORM_SKIP_FLAG] + !!c_idx);
871 }
872 
873 static int explicit_rdpcm_flag_decode(HEVCContext *s, int c_idx)
874 {
875  return GET_CABAC(elem_offset[EXPLICIT_RDPCM_FLAG] + !!c_idx);
876 }
877 
879 {
880  return GET_CABAC(elem_offset[EXPLICIT_RDPCM_DIR_FLAG] + !!c_idx);
881 }
882 
884  int i =0;
885 
886  while (i < 4 && GET_CABAC(elem_offset[LOG2_RES_SCALE_ABS] + 4 * idx + i))
887  i++;
888 
889  return i;
890 }
891 
894 }
895 
897  int log2_size, int *last_scx_prefix, int *last_scy_prefix)
898 {
899  int i = 0;
900  int max = (log2_size << 1) - 1;
901  int ctx_offset, ctx_shift;
902 
903  if (!c_idx) {
904  ctx_offset = 3 * (log2_size - 2) + ((log2_size - 1) >> 2);
905  ctx_shift = (log2_size + 1) >> 2;
906  } else {
907  ctx_offset = 15;
908  ctx_shift = log2_size - 2;
909  }
910  while (i < max &&
911  GET_CABAC(elem_offset[LAST_SIGNIFICANT_COEFF_X_PREFIX] + (i >> ctx_shift) + ctx_offset))
912  i++;
913  *last_scx_prefix = i;
914 
915  i = 0;
916  while (i < max &&
917  GET_CABAC(elem_offset[LAST_SIGNIFICANT_COEFF_Y_PREFIX] + (i >> ctx_shift) + ctx_offset))
918  i++;
919  *last_scy_prefix = i;
920 }
921 
923  int last_significant_coeff_prefix)
924 {
925  int i;
926  int length = (last_significant_coeff_prefix >> 1) - 1;
927  int value = get_cabac_bypass(&s->HEVClc->cc);
928 
929  for (i = 1; i < length; i++)
930  value = (value << 1) | get_cabac_bypass(&s->HEVClc->cc);
931  return value;
932 }
933 
935 {
936  int inc;
937 
938  inc = FFMIN(ctx_cg, 1) + (c_idx>0 ? 2 : 0);
939 
941 }
943  int offset, const uint8_t *ctx_idx_map)
944 {
945  int inc = ctx_idx_map[(y_c << 2) + x_c] + offset;
947 }
948 
950 {
951  return GET_CABAC(elem_offset[SIGNIFICANT_COEFF_FLAG] + offset);
952 }
953 
955 {
956 
957  if (c_idx > 0)
958  inc += 16;
959 
961 }
962 
964 {
965  if (c_idx > 0)
966  inc += 4;
967 
969 }
970 
972 {
973  int prefix = 0;
974  int suffix = 0;
975  int last_coeff_abs_level_remaining;
976  int i;
977 
978  while (prefix < CABAC_MAX_BIN && get_cabac_bypass(&s->HEVClc->cc))
979  prefix++;
980 
981  if (prefix < 3) {
982  for (i = 0; i < rc_rice_param; i++)
983  suffix = (suffix << 1) | get_cabac_bypass(&s->HEVClc->cc);
984  last_coeff_abs_level_remaining = (prefix << rc_rice_param) + suffix;
985  } else {
986  int prefix_minus3 = prefix - 3;
987 
988  if (prefix == CABAC_MAX_BIN || prefix_minus3 + rc_rice_param >= 31) {
989  av_log(s->avctx, AV_LOG_ERROR, "CABAC_MAX_BIN : %d\n", prefix);
990  return 0;
991  }
992 
993  for (i = 0; i < prefix_minus3 + rc_rice_param; i++)
994  suffix = (suffix << 1) | get_cabac_bypass(&s->HEVClc->cc);
995  last_coeff_abs_level_remaining = (((1 << prefix_minus3) + 3 - 1)
996  << rc_rice_param) + suffix;
997  }
998  return last_coeff_abs_level_remaining;
999 }
1000 
1002 {
1003  int i;
1004  int ret = 0;
1005 
1006  for (i = 0; i < nb; i++)
1007  ret = (ret << 1) | get_cabac_bypass(&s->HEVClc->cc);
1008  return ret;
1009 }
1010 
1012  int log2_trafo_size, enum ScanType scan_idx,
1013  int c_idx)
1014 {
1015 #define GET_COORD(offset, n) \
1016  do { \
1017  x_c = (x_cg << 2) + scan_x_off[n]; \
1018  y_c = (y_cg << 2) + scan_y_off[n]; \
1019  } while (0)
1020  HEVCLocalContext *lc = s->HEVClc;
1021  int transform_skip_flag = 0;
1022 
1023  int last_significant_coeff_x, last_significant_coeff_y;
1024  int last_scan_pos;
1025  int n_end;
1026  int num_coeff = 0;
1027  int greater1_ctx = 1;
1028 
1029  int num_last_subset;
1030  int x_cg_last_sig, y_cg_last_sig;
1031 
1032  const uint8_t *scan_x_cg, *scan_y_cg, *scan_x_off, *scan_y_off;
1033 
1034  ptrdiff_t stride = s->frame->linesize[c_idx];
1035  int hshift = s->ps.sps->hshift[c_idx];
1036  int vshift = s->ps.sps->vshift[c_idx];
1037  uint8_t *dst = &s->frame->data[c_idx][(y0 >> vshift) * stride +
1038  ((x0 >> hshift) << s->ps.sps->pixel_shift)];
1039  int16_t *coeffs = (int16_t*)(c_idx ? lc->edge_emu_buffer2 : lc->edge_emu_buffer);
1040  uint8_t significant_coeff_group_flag[8][8] = {{0}};
1041  int explicit_rdpcm_flag = 0;
1042  int explicit_rdpcm_dir_flag;
1043 
1044  int trafo_size = 1 << log2_trafo_size;
1045  int i;
1046  int qp,shift,add,scale,scale_m;
1047  const uint8_t level_scale[] = { 40, 45, 51, 57, 64, 72 };
1048  const uint8_t *scale_matrix = NULL;
1049  uint8_t dc_scale;
1050  int pred_mode_intra = (c_idx == 0) ? lc->tu.intra_pred_mode :
1051  lc->tu.intra_pred_mode_c;
1052 
1053  memset(coeffs, 0, trafo_size * trafo_size * sizeof(int16_t));
1054 
1055  // Derive QP for dequant
1056  if (!lc->cu.cu_transquant_bypass_flag) {
1057  static const int qp_c[] = { 29, 30, 31, 32, 33, 33, 34, 34, 35, 35, 36, 36, 37, 37 };
1058  static const uint8_t rem6[51 + 4 * 6 + 1] = {
1059  0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2,
1060  3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5,
1061  0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3,
1062  4, 5, 0, 1, 2, 3, 4, 5, 0, 1
1063  };
1064 
1065  static const uint8_t div6[51 + 4 * 6 + 1] = {
1066  0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 3, 3, 3,
1067  3, 3, 3, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6,
1068  7, 7, 7, 7, 7, 7, 8, 8, 8, 8, 8, 8, 9, 9, 9, 9, 9, 9, 10, 10, 10, 10,
1069  10, 10, 11, 11, 11, 11, 11, 11, 12, 12
1070  };
1071  int qp_y = lc->qp_y;
1072 
1074  log2_trafo_size <= s->ps.pps->log2_max_transform_skip_block_size) {
1075  transform_skip_flag = hevc_transform_skip_flag_decode(s, c_idx);
1076  }
1077 
1078  if (c_idx == 0) {
1079  qp = qp_y + s->ps.sps->qp_bd_offset;
1080  } else {
1081  int qp_i, offset;
1082 
1083  if (c_idx == 1)
1084  offset = s->ps.pps->cb_qp_offset + s->sh.slice_cb_qp_offset +
1085  lc->tu.cu_qp_offset_cb;
1086  else
1087  offset = s->ps.pps->cr_qp_offset + s->sh.slice_cr_qp_offset +
1088  lc->tu.cu_qp_offset_cr;
1089 
1090  qp_i = av_clip(qp_y + offset, - s->ps.sps->qp_bd_offset, 57);
1091  if (s->ps.sps->chroma_format_idc == 1) {
1092  if (qp_i < 30)
1093  qp = qp_i;
1094  else if (qp_i > 43)
1095  qp = qp_i - 6;
1096  else
1097  qp = qp_c[qp_i - 30];
1098  } else {
1099  if (qp_i > 51)
1100  qp = 51;
1101  else
1102  qp = qp_i;
1103  }
1104 
1105  qp += s->ps.sps->qp_bd_offset;
1106  }
1107 
1108  shift = s->ps.sps->bit_depth + log2_trafo_size - 5;
1109  add = 1 << (shift-1);
1110  scale = level_scale[rem6[qp]] << (div6[qp]);
1111  scale_m = 16; // default when no custom scaling lists.
1112  dc_scale = 16;
1113 
1114  if (s->ps.sps->scaling_list_enable_flag && !(transform_skip_flag && log2_trafo_size > 2)) {
1116  &s->ps.pps->scaling_list : &s->ps.sps->scaling_list;
1117  int matrix_id = lc->cu.pred_mode != MODE_INTRA;
1118 
1119  matrix_id = 3 * matrix_id + c_idx;
1120 
1121  scale_matrix = sl->sl[log2_trafo_size - 2][matrix_id];
1122  if (log2_trafo_size >= 4)
1123  dc_scale = sl->sl_dc[log2_trafo_size - 4][matrix_id];
1124  }
1125  } else {
1126  shift = 0;
1127  add = 0;
1128  scale = 0;
1129  dc_scale = 0;
1130  }
1131 
1133  (transform_skip_flag || lc->cu.cu_transquant_bypass_flag)) {
1134  explicit_rdpcm_flag = explicit_rdpcm_flag_decode(s, c_idx);
1135  if (explicit_rdpcm_flag) {
1136  explicit_rdpcm_dir_flag = explicit_rdpcm_dir_flag_decode(s, c_idx);
1137  }
1138  }
1139 
1140  last_significant_coeff_xy_prefix_decode(s, c_idx, log2_trafo_size,
1141  &last_significant_coeff_x, &last_significant_coeff_y);
1142 
1143  if (last_significant_coeff_x > 3) {
1144  int suffix = last_significant_coeff_suffix_decode(s, last_significant_coeff_x);
1145  last_significant_coeff_x = (1 << ((last_significant_coeff_x >> 1) - 1)) *
1146  (2 + (last_significant_coeff_x & 1)) +
1147  suffix;
1148  }
1149 
1150  if (last_significant_coeff_y > 3) {
1151  int suffix = last_significant_coeff_suffix_decode(s, last_significant_coeff_y);
1152  last_significant_coeff_y = (1 << ((last_significant_coeff_y >> 1) - 1)) *
1153  (2 + (last_significant_coeff_y & 1)) +
1154  suffix;
1155  }
1156 
1157  if (scan_idx == SCAN_VERT)
1158  FFSWAP(int, last_significant_coeff_x, last_significant_coeff_y);
1159 
1160  x_cg_last_sig = last_significant_coeff_x >> 2;
1161  y_cg_last_sig = last_significant_coeff_y >> 2;
1162 
1163  switch (scan_idx) {
1164  case SCAN_DIAG: {
1165  int last_x_c = last_significant_coeff_x & 3;
1166  int last_y_c = last_significant_coeff_y & 3;
1167 
1168  scan_x_off = ff_hevc_diag_scan4x4_x;
1169  scan_y_off = ff_hevc_diag_scan4x4_y;
1170  num_coeff = diag_scan4x4_inv[last_y_c][last_x_c];
1171  if (trafo_size == 4) {
1172  scan_x_cg = scan_1x1;
1173  scan_y_cg = scan_1x1;
1174  } else if (trafo_size == 8) {
1175  num_coeff += diag_scan2x2_inv[y_cg_last_sig][x_cg_last_sig] << 4;
1176  scan_x_cg = diag_scan2x2_x;
1177  scan_y_cg = diag_scan2x2_y;
1178  } else if (trafo_size == 16) {
1179  num_coeff += diag_scan4x4_inv[y_cg_last_sig][x_cg_last_sig] << 4;
1180  scan_x_cg = ff_hevc_diag_scan4x4_x;
1181  scan_y_cg = ff_hevc_diag_scan4x4_y;
1182  } else { // trafo_size == 32
1183  num_coeff += diag_scan8x8_inv[y_cg_last_sig][x_cg_last_sig] << 4;
1184  scan_x_cg = ff_hevc_diag_scan8x8_x;
1185  scan_y_cg = ff_hevc_diag_scan8x8_y;
1186  }
1187  break;
1188  }
1189  case SCAN_HORIZ:
1190  scan_x_cg = horiz_scan2x2_x;
1191  scan_y_cg = horiz_scan2x2_y;
1192  scan_x_off = horiz_scan4x4_x;
1193  scan_y_off = horiz_scan4x4_y;
1194  num_coeff = horiz_scan8x8_inv[last_significant_coeff_y][last_significant_coeff_x];
1195  break;
1196  default: //SCAN_VERT
1197  scan_x_cg = horiz_scan2x2_y;
1198  scan_y_cg = horiz_scan2x2_x;
1199  scan_x_off = horiz_scan4x4_y;
1200  scan_y_off = horiz_scan4x4_x;
1201  num_coeff = horiz_scan8x8_inv[last_significant_coeff_x][last_significant_coeff_y];
1202  break;
1203  }
1204  num_coeff++;
1205  num_last_subset = (num_coeff - 1) >> 4;
1206 
1207  for (i = num_last_subset; i >= 0; i--) {
1208  int n, m;
1209  int x_cg, y_cg, x_c, y_c, pos;
1210  int implicit_non_zero_coeff = 0;
1211  int64_t trans_coeff_level;
1212  int prev_sig = 0;
1213  int offset = i << 4;
1214  int rice_init = 0;
1215 
1216  uint8_t significant_coeff_flag_idx[16];
1217  uint8_t nb_significant_coeff_flag = 0;
1218 
1219  x_cg = scan_x_cg[i];
1220  y_cg = scan_y_cg[i];
1221 
1222  if ((i < num_last_subset) && (i > 0)) {
1223  int ctx_cg = 0;
1224  if (x_cg < (1 << (log2_trafo_size - 2)) - 1)
1225  ctx_cg += significant_coeff_group_flag[x_cg + 1][y_cg];
1226  if (y_cg < (1 << (log2_trafo_size - 2)) - 1)
1227  ctx_cg += significant_coeff_group_flag[x_cg][y_cg + 1];
1228 
1229  significant_coeff_group_flag[x_cg][y_cg] =
1230  significant_coeff_group_flag_decode(s, c_idx, ctx_cg);
1231  implicit_non_zero_coeff = 1;
1232  } else {
1233  significant_coeff_group_flag[x_cg][y_cg] =
1234  ((x_cg == x_cg_last_sig && y_cg == y_cg_last_sig) ||
1235  (x_cg == 0 && y_cg == 0));
1236  }
1237 
1238  last_scan_pos = num_coeff - offset - 1;
1239 
1240  if (i == num_last_subset) {
1241  n_end = last_scan_pos - 1;
1242  significant_coeff_flag_idx[0] = last_scan_pos;
1243  nb_significant_coeff_flag = 1;
1244  } else {
1245  n_end = 15;
1246  }
1247 
1248  if (x_cg < ((1 << log2_trafo_size) - 1) >> 2)
1249  prev_sig = !!significant_coeff_group_flag[x_cg + 1][y_cg];
1250  if (y_cg < ((1 << log2_trafo_size) - 1) >> 2)
1251  prev_sig += (!!significant_coeff_group_flag[x_cg][y_cg + 1] << 1);
1252 
1253  if (significant_coeff_group_flag[x_cg][y_cg] && n_end >= 0) {
1254  static const uint8_t ctx_idx_map[] = {
1255  0, 1, 4, 5, 2, 3, 4, 5, 6, 6, 8, 8, 7, 7, 8, 8, // log2_trafo_size == 2
1256  1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, // prev_sig == 0
1257  2, 2, 2, 2, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, // prev_sig == 1
1258  2, 1, 0, 0, 2, 1, 0, 0, 2, 1, 0, 0, 2, 1, 0, 0, // prev_sig == 2
1259  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2 // default
1260  };
1261  const uint8_t *ctx_idx_map_p;
1262  int scf_offset = 0;
1264  (transform_skip_flag || lc->cu.cu_transquant_bypass_flag)) {
1265  ctx_idx_map_p = (uint8_t*) &ctx_idx_map[4 * 16];
1266  if (c_idx == 0) {
1267  scf_offset = 40;
1268  } else {
1269  scf_offset = 14 + 27;
1270  }
1271  } else {
1272  if (c_idx != 0)
1273  scf_offset = 27;
1274  if (log2_trafo_size == 2) {
1275  ctx_idx_map_p = (uint8_t*) &ctx_idx_map[0];
1276  } else {
1277  ctx_idx_map_p = (uint8_t*) &ctx_idx_map[(prev_sig + 1) << 4];
1278  if (c_idx == 0) {
1279  if ((x_cg > 0 || y_cg > 0))
1280  scf_offset += 3;
1281  if (log2_trafo_size == 3) {
1282  scf_offset += (scan_idx == SCAN_DIAG) ? 9 : 15;
1283  } else {
1284  scf_offset += 21;
1285  }
1286  } else {
1287  if (log2_trafo_size == 3)
1288  scf_offset += 9;
1289  else
1290  scf_offset += 12;
1291  }
1292  }
1293  }
1294  for (n = n_end; n > 0; n--) {
1295  x_c = scan_x_off[n];
1296  y_c = scan_y_off[n];
1297  if (significant_coeff_flag_decode(s, x_c, y_c, scf_offset, ctx_idx_map_p)) {
1298  significant_coeff_flag_idx[nb_significant_coeff_flag] = n;
1299  nb_significant_coeff_flag++;
1300  implicit_non_zero_coeff = 0;
1301  }
1302  }
1303  if (implicit_non_zero_coeff == 0) {
1305  (transform_skip_flag || lc->cu.cu_transquant_bypass_flag)) {
1306  if (c_idx == 0) {
1307  scf_offset = 42;
1308  } else {
1309  scf_offset = 16 + 27;
1310  }
1311  } else {
1312  if (i == 0) {
1313  if (c_idx == 0)
1314  scf_offset = 0;
1315  else
1316  scf_offset = 27;
1317  } else {
1318  scf_offset = 2 + scf_offset;
1319  }
1320  }
1321  if (significant_coeff_flag_decode_0(s, c_idx, scf_offset) == 1) {
1322  significant_coeff_flag_idx[nb_significant_coeff_flag] = 0;
1323  nb_significant_coeff_flag++;
1324  }
1325  } else {
1326  significant_coeff_flag_idx[nb_significant_coeff_flag] = 0;
1327  nb_significant_coeff_flag++;
1328  }
1329  }
1330 
1331  n_end = nb_significant_coeff_flag;
1332 
1333 
1334  if (n_end) {
1335  int first_nz_pos_in_cg;
1336  int last_nz_pos_in_cg;
1337  int c_rice_param = 0;
1338  int first_greater1_coeff_idx = -1;
1339  uint8_t coeff_abs_level_greater1_flag[8];
1340  uint16_t coeff_sign_flag;
1341  int sum_abs = 0;
1342  int sign_hidden;
1343  int sb_type;
1344 
1345 
1346  // initialize first elem of coeff_bas_level_greater1_flag
1347  int ctx_set = (i > 0 && c_idx == 0) ? 2 : 0;
1348 
1350  if (!transform_skip_flag && !lc->cu.cu_transquant_bypass_flag)
1351  sb_type = 2 * (c_idx == 0 ? 1 : 0);
1352  else
1353  sb_type = 2 * (c_idx == 0 ? 1 : 0) + 1;
1354  c_rice_param = lc->stat_coeff[sb_type] / 4;
1355  }
1356 
1357  if (!(i == num_last_subset) && greater1_ctx == 0)
1358  ctx_set++;
1359  greater1_ctx = 1;
1360  last_nz_pos_in_cg = significant_coeff_flag_idx[0];
1361 
1362  for (m = 0; m < (n_end > 8 ? 8 : n_end); m++) {
1363  int inc = (ctx_set << 2) + greater1_ctx;
1364  coeff_abs_level_greater1_flag[m] =
1365  coeff_abs_level_greater1_flag_decode(s, c_idx, inc);
1366  if (coeff_abs_level_greater1_flag[m]) {
1367  greater1_ctx = 0;
1368  if (first_greater1_coeff_idx == -1)
1369  first_greater1_coeff_idx = m;
1370  } else if (greater1_ctx > 0 && greater1_ctx < 3) {
1371  greater1_ctx++;
1372  }
1373  }
1374  first_nz_pos_in_cg = significant_coeff_flag_idx[n_end - 1];
1375 
1376  if (lc->cu.cu_transquant_bypass_flag ||
1377  (lc->cu.pred_mode == MODE_INTRA &&
1378  s->ps.sps->implicit_rdpcm_enabled_flag && transform_skip_flag &&
1379  (pred_mode_intra == 10 || pred_mode_intra == 26 )) ||
1380  explicit_rdpcm_flag)
1381  sign_hidden = 0;
1382  else
1383  sign_hidden = (last_nz_pos_in_cg - first_nz_pos_in_cg >= 4);
1384 
1385  if (first_greater1_coeff_idx != -1) {
1386  coeff_abs_level_greater1_flag[first_greater1_coeff_idx] += coeff_abs_level_greater2_flag_decode(s, c_idx, ctx_set);
1387  }
1388  if (!s->ps.pps->sign_data_hiding_flag || !sign_hidden ) {
1389  coeff_sign_flag = coeff_sign_flag_decode(s, nb_significant_coeff_flag) << (16 - nb_significant_coeff_flag);
1390  } else {
1391  coeff_sign_flag = coeff_sign_flag_decode(s, nb_significant_coeff_flag - 1) << (16 - (nb_significant_coeff_flag - 1));
1392  }
1393 
1394  for (m = 0; m < n_end; m++) {
1395  n = significant_coeff_flag_idx[m];
1396  GET_COORD(offset, n);
1397  if (m < 8) {
1398  trans_coeff_level = 1 + coeff_abs_level_greater1_flag[m];
1399  if (trans_coeff_level == ((m == first_greater1_coeff_idx) ? 3 : 2)) {
1400  int last_coeff_abs_level_remaining = coeff_abs_level_remaining_decode(s, c_rice_param);
1401 
1402  trans_coeff_level += last_coeff_abs_level_remaining;
1403  if (trans_coeff_level > (3 << c_rice_param))
1404  c_rice_param = s->ps.sps->persistent_rice_adaptation_enabled_flag ? c_rice_param + 1 : FFMIN(c_rice_param + 1, 4);
1405  if (s->ps.sps->persistent_rice_adaptation_enabled_flag && !rice_init) {
1406  int c_rice_p_init = lc->stat_coeff[sb_type] / 4;
1407  if (last_coeff_abs_level_remaining >= (3 << c_rice_p_init))
1408  lc->stat_coeff[sb_type]++;
1409  else if (2 * last_coeff_abs_level_remaining < (1 << c_rice_p_init))
1410  if (lc->stat_coeff[sb_type] > 0)
1411  lc->stat_coeff[sb_type]--;
1412  rice_init = 1;
1413  }
1414  }
1415  } else {
1416  int last_coeff_abs_level_remaining = coeff_abs_level_remaining_decode(s, c_rice_param);
1417 
1418  trans_coeff_level = 1 + last_coeff_abs_level_remaining;
1419  if (trans_coeff_level > (3 << c_rice_param))
1420  c_rice_param = s->ps.sps->persistent_rice_adaptation_enabled_flag ? c_rice_param + 1 : FFMIN(c_rice_param + 1, 4);
1421  if (s->ps.sps->persistent_rice_adaptation_enabled_flag && !rice_init) {
1422  int c_rice_p_init = lc->stat_coeff[sb_type] / 4;
1423  if (last_coeff_abs_level_remaining >= (3 << c_rice_p_init))
1424  lc->stat_coeff[sb_type]++;
1425  else if (2 * last_coeff_abs_level_remaining < (1 << c_rice_p_init))
1426  if (lc->stat_coeff[sb_type] > 0)
1427  lc->stat_coeff[sb_type]--;
1428  rice_init = 1;
1429  }
1430  }
1431  if (s->ps.pps->sign_data_hiding_flag && sign_hidden) {
1432  sum_abs += trans_coeff_level;
1433  if (n == first_nz_pos_in_cg && (sum_abs&1))
1434  trans_coeff_level = -trans_coeff_level;
1435  }
1436  if (coeff_sign_flag >> 15)
1437  trans_coeff_level = -trans_coeff_level;
1438  coeff_sign_flag <<= 1;
1439  if(!lc->cu.cu_transquant_bypass_flag) {
1440  if (s->ps.sps->scaling_list_enable_flag && !(transform_skip_flag && log2_trafo_size > 2)) {
1441  if(y_c || x_c || log2_trafo_size < 4) {
1442  switch(log2_trafo_size) {
1443  case 3: pos = (y_c << 3) + x_c; break;
1444  case 4: pos = ((y_c >> 1) << 3) + (x_c >> 1); break;
1445  case 5: pos = ((y_c >> 2) << 3) + (x_c >> 2); break;
1446  default: pos = (y_c << 2) + x_c; break;
1447  }
1448  scale_m = scale_matrix[pos];
1449  } else {
1450  scale_m = dc_scale;
1451  }
1452  }
1453  trans_coeff_level = (trans_coeff_level * (int64_t)scale * (int64_t)scale_m + add) >> shift;
1454  if(trans_coeff_level < 0) {
1455  if((~trans_coeff_level) & 0xFffffffffff8000)
1456  trans_coeff_level = -32768;
1457  } else {
1458  if(trans_coeff_level & 0xffffffffffff8000)
1459  trans_coeff_level = 32767;
1460  }
1461  }
1462  coeffs[y_c * trafo_size + x_c] = trans_coeff_level;
1463  }
1464  }
1465  }
1466 
1467  if (lc->cu.cu_transquant_bypass_flag) {
1468  if (explicit_rdpcm_flag || (s->ps.sps->implicit_rdpcm_enabled_flag &&
1469  (pred_mode_intra == 10 || pred_mode_intra == 26))) {
1470  int mode = s->ps.sps->implicit_rdpcm_enabled_flag ? (pred_mode_intra == 26) : explicit_rdpcm_dir_flag;
1471 
1472  s->hevcdsp.transform_rdpcm(coeffs, log2_trafo_size, mode);
1473  }
1474  } else {
1475  if (transform_skip_flag) {
1477  log2_trafo_size == 2 &&
1478  lc->cu.pred_mode == MODE_INTRA;
1479  if (rot) {
1480  for (i = 0; i < 8; i++)
1481  FFSWAP(int16_t, coeffs[i], coeffs[16 - i - 1]);
1482  }
1483 
1484  s->hevcdsp.transform_skip(coeffs, log2_trafo_size);
1485 
1486  if (explicit_rdpcm_flag || (s->ps.sps->implicit_rdpcm_enabled_flag &&
1487  lc->cu.pred_mode == MODE_INTRA &&
1488  (pred_mode_intra == 10 || pred_mode_intra == 26))) {
1489  int mode = explicit_rdpcm_flag ? explicit_rdpcm_dir_flag : (pred_mode_intra == 26);
1490 
1491  s->hevcdsp.transform_rdpcm(coeffs, log2_trafo_size, mode);
1492  }
1493  } else if (lc->cu.pred_mode == MODE_INTRA && c_idx == 0 && log2_trafo_size == 2) {
1494  s->hevcdsp.idct_4x4_luma(coeffs);
1495  } else {
1496  int max_xy = FFMAX(last_significant_coeff_x, last_significant_coeff_y);
1497  if (max_xy == 0)
1498  s->hevcdsp.idct_dc[log2_trafo_size-2](coeffs);
1499  else {
1500  int col_limit = last_significant_coeff_x + last_significant_coeff_y + 4;
1501  if (max_xy < 4)
1502  col_limit = FFMIN(4, col_limit);
1503  else if (max_xy < 8)
1504  col_limit = FFMIN(8, col_limit);
1505  else if (max_xy < 12)
1506  col_limit = FFMIN(24, col_limit);
1507  s->hevcdsp.idct[log2_trafo_size-2](coeffs, col_limit);
1508  }
1509  }
1510  }
1511  if (lc->tu.cross_pf) {
1512  int16_t *coeffs_y = (int16_t*)lc->edge_emu_buffer;
1513 
1514  for (i = 0; i < (trafo_size * trafo_size); i++) {
1515  coeffs[i] = coeffs[i] + ((lc->tu.res_scale_val * coeffs_y[i]) >> 3);
1516  }
1517  }
1518  s->hevcdsp.transform_add[log2_trafo_size-2](dst, coeffs, stride);
1519 }
1520 
1521 void ff_hevc_hls_mvd_coding(HEVCContext *s, int x0, int y0, int log2_cb_size)
1522 {
1523  HEVCLocalContext *lc = s->HEVClc;
1524  int x = abs_mvd_greater0_flag_decode(s);
1526 
1527  if (x)
1529  if (y)
1531 
1532  switch (x) {
1533  case 2: lc->pu.mvd.x = mvd_decode(s); break;
1534  case 1: lc->pu.mvd.x = mvd_sign_flag_decode(s); break;
1535  case 0: lc->pu.mvd.x = 0; break;
1536  }
1537 
1538  switch (y) {
1539  case 2: lc->pu.mvd.y = mvd_decode(s); break;
1540  case 1: lc->pu.mvd.y = mvd_sign_flag_decode(s); break;
1541  case 0: lc->pu.mvd.y = 0; break;
1542  }
1543 }
1544 
static av_always_inline int significant_coeff_group_flag_decode(HEVCContext *s, int c_idx, int ctx_cg)
Definition: hevc_cabac.c:934
int8_t cu_qp_offset_cr
Definition: hevc.h:705
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:795
const HEVCPPS * pps
Definition: hevc.h:570
#define NULL
Definition: coverity.c:32
unsigned int log2_min_cb_size
Definition: hevc.h:451
const char * s
Definition: avisynth_c.h:631
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
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:673
uint8_t edge_emu_buffer[(MAX_PB_SIZE+7)*EDGE_EMU_BUFFER_STRIDE *2]
Definition: hevc.h:801
int transform_skip_rotation_enabled_flag
Definition: hevc.h:461
int16_t x
horizontal component of motion vector
Definition: hevc.h:664
uint8_t * cabac_state
Definition: hevc.h:835
int vshift[3]
Definition: hevc.h:483
int ff_hevc_cbf_luma_decode(HEVCContext *s, int trafo_depth)
Definition: hevc_cabac.c:863
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:56
PredictionUnit pu
Definition: hevc.h:808
Definition: hevc.h:259
HEVCParamSets ps
Definition: hevc.h:845
int explicit_rdpcm_enabled_flag
Definition: hevc.h:464
int ff_hevc_merge_flag_decode(HEVCContext *s)
Definition: hevc_cabac.c:779
uint8_t dependent_slice_segment_flag
Definition: hevc.h:586
CABACContext cc
Definition: hevc.h:785
Macro definitions for various function/variable attributes.
int qp_bd_offset
Definition: hevc.h:485
#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:411
uint8_t entropy_coding_sync_enabled_flag
Definition: hevc.h:515
int ff_hevc_no_residual_syntax_flag_decode(HEVCContext *s)
Definition: hevc_cabac.c:815
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:949
int ff_hevc_split_transform_flag_decode(HEVCContext *s, int log2_trafo_size)
Definition: hevc_cabac.c:853
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:747
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:784
int ff_hevc_part_mode_decode(HEVCContext *s, int log2_cb_size)
Definition: hevc_cabac.c:692
static int explicit_rdpcm_flag_decode(HEVCContext *s, int c_idx)
Definition: hevc_cabac.c:873
AVCodecContext * avctx
Definition: hevc.h:822
static void cabac_init_state(HEVCContext *s)
Definition: hevc_cabac.c:478
int min_cb_width
Definition: hevc.h:474
int ff_hevc_prev_intra_luma_pred_flag_decode(HEVCContext *s)
Definition: hevc_cabac.c:734
static const uint8_t horiz_scan4x4_y[16]
Definition: hevc_cabac.c:399
uint8_t scaling_list_data_present_flag
Definition: hevc.h:530
uint8_t first_slice_in_pic_flag
Definition: hevc.h:585
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:213
void ff_hevc_hls_mvd_coding(HEVCContext *s, int x0, int y0, int log2_cb_size)
Definition: hevc_cabac.c:1521
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:830
int ff_hevc_cbf_cb_cr_decode(HEVCContext *s, int trafo_depth)
Definition: hevc_cabac.c:858
uint8_t * tab_ct_depth
Definition: hevc.h:884
uint8_t cu_transquant_bypass_flag
Definition: hevc.h:660
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:883
#define av_log(a,...)
unsigned m
Definition: audioconvert.c:187
HEVCDSPContext hevcdsp
Definition: hevc.h:873
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:657
#define U(x)
Definition: vp56_arith.h:37
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:594
#define GET_CABAC(ctx)
Definition: hevc_cabac.c:546
const char * suffix
Definition: checkasm.c:75
int ff_hevc_cu_transquant_bypass_flag_decode(HEVCContext *s)
Definition: hevc_cabac.c:600
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
static const uint8_t diag_scan4x4_inv[4][4]
Definition: hevc_cabac.c:430
int persistent_rice_adaptation_enabled_flag
coded frame dimension in various units
Definition: hevc.h:466
void(* transform_skip)(int16_t *coeffs, int16_t log2_size)
Definition: hevcdsp.h:51
uint8_t amp_enabled_flag
Definition: hevc.h:433
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:455
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:704
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:631
#define FFMAX(a, b)
Definition: common.h:90
uint8_t edge_emu_buffer2[(MAX_PB_SIZE+7)*EDGE_EMU_BUFFER_STRIDE *2]
Definition: hevc.h:803
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:878
uint8_t tiles_enabled_flag
Definition: hevc.h:514
int ct_depth
Definition: hevc.h:806
static const uint8_t diag_scan8x8_inv[8][8]
Definition: hevc_cabac.c:437
int intra_pred_mode
Definition: hevc.h:699
const HEVCSPS * sps
Definition: hevc.h:569
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:825
int res_scale_val
Definition: hevc.h:696
int ff_hevc_res_scale_sign_flag(HEVCContext *s, int idx)
Definition: hevc_cabac.c:892
uint8_t cabac_state[HEVC_CONTEXTS]
Definition: hevc.h:778
#define FFMIN(a, b)
Definition: common.h:92
float y
int slice_cr_qp_offset
Definition: hevc.h:617
GLsizei GLboolean const GLfloat * value
Definition: opengl_enc.c:109
int hshift[3]
Definition: hevc.h:482
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:787
Definition: hevc.h:133
Context Adaptive Binary Arithmetic Coder inline functions.
int intra_pred_mode_c
Definition: hevc.h:700
Definition: hevc.h:208
int ctb_width
Definition: hevc.h:471
uint8_t sl_dc[2][6]
Definition: hevc.h:395
uint8_t sign_data_hiding_flag
Definition: hevc.h:491
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:954
static int av_unused get_cabac_terminate(CABACContext *c)
static av_always_inline int mvd_decode(HEVCContext *s)
Definition: hevc_cabac.c:830
int implicit_rdpcm_enabled_flag
Definition: hevc.h:463
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:963
int ff_hevc_merge_idx_decode(HEVCContext *s)
Definition: hevc_cabac.c:768
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:896
int slice_cb_qp_offset
Definition: hevc.h:616
uint8_t transform_skip_enabled_flag
Definition: hevc.h:500
static const uint8_t diag_scan2x2_x[4]
Definition: hevc_cabac.c:417
int * ctb_addr_rs_to_ts
CtbAddrRSToTS.
Definition: hevc.h:554
Definition: hevc.h:167
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:199
int ff_hevc_end_of_slice_flag_decode(HEVCContext *s)
Definition: hevc_cabac.c:595
ScalingList scaling_list
Definition: hevc.h:531
static av_always_inline int last_significant_coeff_suffix_decode(HEVCContext *s, int last_significant_coeff_prefix)
Definition: hevc_cabac.c:922
enum PredMode pred_mode
PredMode.
Definition: hevc.h:654
int16_t y
vertical component of motion vector
Definition: hevc.h:665
uint8_t cross_pf
Definition: hevc.h:706
TransformUnit tu
Definition: hevc.h:792
uint8_t ctb_left_flag
Definition: hevc.h:794
static const uint8_t horiz_scan2x2_x[4]
Definition: hevc_cabac.c:384
int transform_skip_context_enabled_flag
Definition: hevc.h:462
int ff_hevc_cu_qp_delta_sign_flag(HEVCContext *s)
Definition: hevc_cabac.c:647
uint8_t cabac_init_flag
Definition: hevc.h:608
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:298
uint8_t stat_coeff[4]
Definition: hevc.h:780
const uint8_t ff_hevc_diag_scan8x8_y[64]
Definition: hevc_data.c:58
AVFrame * frame
Definition: hevc.h:840
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:784
uint8_t scaling_list_enable_flag
Definition: hevc.h:427
int * tile_id
TileId.
Definition: hevc.h:556
#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:794
HEVCLocalContext * HEVClc
Definition: hevc.h:827
int cr_qp_offset
Definition: hevc.h:506
static av_always_inline int abs_mvd_greater0_flag_decode(HEVCContext *s)
Definition: hevc_cabac.c:820
ScalingList scaling_list
Definition: hevc.h:428
static const uint8_t diag_scan2x2_inv[2][2]
Definition: hevc_cabac.c:425
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:182
int ff_hevc_cu_chroma_qp_offset_flag(HEVCContext *s)
Definition: hevc_cabac.c:652
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:942
GLint GLenum GLboolean GLsizei stride
Definition: opengl_enc.c:105
uint8_t * skip_flag
Definition: hevc.h:883
#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:868
int ff_hevc_intra_chroma_pred_mode_decode(HEVCContext *s)
Definition: hevc_cabac.c:757
common internal and external API header
if(ret< 0)
Definition: vf_mcdeint.c:280
Definition: hevc.h:258
static av_always_inline int coeff_sign_flag_decode(HEVCContext *s, uint8_t nb)
Definition: hevc_cabac.c:1001
#define GET_COORD(offset, n)
int slice_ctb_addr_rs
Definition: hevc.h:647
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:541
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:668
CodingUnit cu
Definition: hevc.h:807
static const int16_t coeffs[]
int ff_hevc_mpm_idx_decode(HEVCContext *s)
Definition: hevc_cabac.c:739
int ff_hevc_pcm_flag_decode(HEVCContext *s)
Definition: hevc_cabac.c:729
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:1011
static const uint8_t * align_get_bits(GetBitContext *s)
Definition: get_bits.h:454
static void cabac_init_decoder(HEVCContext *s)
Definition: hevc_cabac.c:468
const uint8_t ff_hevc_diag_scan8x8_x[64]
Definition: hevc_data.c:39
#define av_always_inline
Definition: attributes.h:37
int cb_qp_offset
Definition: hevc.h:505
#define FFSWAP(type, a, b)
Definition: common.h:95
int bit_depth
Definition: hevc.h:409
enum SliceType slice_type
Definition: hevc.h:581
#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:853
static av_always_inline int coeff_abs_level_remaining_decode(HEVCContext *s, int rc_rice_param)
Definition: hevc_cabac.c:971
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:848
for(j=16;j >0;--j)
int ff_hevc_cu_qp_delta_abs(HEVCContext *s)
Definition: hevc_cabac.c:620
const uint8_t ff_hevc_diag_scan4x4_y[16]
Definition: hevc_data.c:32
#define av_unused
Definition: attributes.h:118
static const uint8_t diag_scan2x2_y[4]
Definition: hevc_cabac.c:421
void(* idct_4x4_luma)(int16_t *coeffs)
Definition: hevcdsp.h:55
int ff_hevc_mvp_lx_flag_decode(HEVCContext *s)
Definition: hevc_cabac.c:810
#define SAMPLE_CTB(tab, x, y)
Definition: hevc.h:83