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