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