summaryrefslogtreecommitdiff
path: root/libavcodec/hevc_cabac.c (plain)
blob: e27c54ed4bd915cd268e674e61c805ead7efc8ed
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 */
37av_unused 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 */
92static 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 */
148static 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
382static const uint8_t scan_1x1[1] = {
383 0,
384};
385
386static const uint8_t horiz_scan2x2_x[4] = {
387 0, 1, 0, 1,
388};
389
390static const uint8_t horiz_scan2x2_y[4] = {
391 0, 0, 1, 1
392};
393
394static 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
401static 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
408static 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
419static const uint8_t diag_scan2x2_x[4] = {
420 0, 0, 1, 1,
421};
422
423static const uint8_t diag_scan2x2_y[4] = {
424 0, 1, 0, 1,
425};
426
427static const uint8_t diag_scan2x2_inv[2][2] = {
428 { 0, 2, },
429 { 1, 3, },
430};
431
432static 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
439static 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
450void ff_hevc_save_states(HEVCContext *s, int ctb_addr_ts)
451{
452 if (s->ps.pps->entropy_coding_sync_enabled_flag &&
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
460static void load_states(HEVCContext *s)
461{
462 memcpy(s->HEVClc->cabac_state, s->cabac_state, HEVC_CONTEXTS);
463}
464
465static void cabac_reinit(HEVCLocalContext *lc)
466{
467 skip_bytes(&lc->cc, 0);
468}
469
470static void cabac_init_decoder(HEVCContext *s)
471{
472 GetBitContext *gb = &s->HEVClc->gb;
473 skip_bits(gb, 1);
474 align_get_bits(gb);
475 ff_init_cabac_decoder(&s->HEVClc->cc,
476 gb->buffer + get_bits_count(gb) / 8,
477 (get_bits_left(gb) + 7) / 8);
478}
479
480static void cabac_init_state(HEVCContext *s)
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
504void 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 cabac_init_decoder(s);
508 if (s->sh.dependent_slice_segment_flag == 0 ||
509 (s->ps.pps->tiles_enabled_flag &&
510 s->ps.pps->tile_id[ctb_addr_ts] != s->ps.pps->tile_id[ctb_addr_ts - 1]))
511 cabac_init_state(s);
512
513 if (!s->sh.first_slice_in_pic_flag &&
514 s->ps.pps->entropy_coding_sync_enabled_flag) {
515 if (ctb_addr_ts % s->ps.sps->ctb_width == 0) {
516 if (s->ps.sps->ctb_width == 1)
517 cabac_init_state(s);
518 else if (s->sh.dependent_slice_segment_flag == 1)
519 load_states(s);
520 }
521 }
522 } else {
523 if (s->ps.pps->tiles_enabled_flag &&
524 s->ps.pps->tile_id[ctb_addr_ts] != s->ps.pps->tile_id[ctb_addr_ts - 1]) {
525 if (s->threads_number == 1)
526 cabac_reinit(s->HEVClc);
527 else
528 cabac_init_decoder(s);
529 cabac_init_state(s);
530 }
531 if (s->ps.pps->entropy_coding_sync_enabled_flag) {
532 if (ctb_addr_ts % s->ps.sps->ctb_width == 0) {
533 get_cabac_terminate(&s->HEVClc->cc);
534 if (s->threads_number == 1)
535 cabac_reinit(s->HEVClc);
536 else
537 cabac_init_decoder(s);
538
539 if (s->ps.sps->ctb_width == 1)
540 cabac_init_state(s);
541 else
542 load_states(s);
543 }
544 }
545 }
546}
547
548#define GET_CABAC(ctx) get_cabac(&s->HEVClc->cc, &s->HEVClc->cabac_state[ctx])
549
550int ff_hevc_sao_merge_flag_decode(HEVCContext *s)
551{
552 return GET_CABAC(elem_offset[SAO_MERGE_FLAG]);
553}
554
555int ff_hevc_sao_type_idx_decode(HEVCContext *s)
556{
557 if (!GET_CABAC(elem_offset[SAO_TYPE_IDX]))
558 return 0;
559
560 if (!get_cabac_bypass(&s->HEVClc->cc))
561 return SAO_BAND;
562 return SAO_EDGE;
563}
564
565int ff_hevc_sao_band_position_decode(HEVCContext *s)
566{
567 int i;
568 int value = get_cabac_bypass(&s->HEVClc->cc);
569
570 for (i = 0; i < 4; i++)
571 value = (value << 1) | get_cabac_bypass(&s->HEVClc->cc);
572 return value;
573}
574
575int ff_hevc_sao_offset_abs_decode(HEVCContext *s)
576{
577 int i = 0;
578 int length = (1 << (FFMIN(s->ps.sps->bit_depth, 10) - 5)) - 1;
579
580 while (i < length && get_cabac_bypass(&s->HEVClc->cc))
581 i++;
582 return i;
583}
584
585int ff_hevc_sao_offset_sign_decode(HEVCContext *s)
586{
587 return get_cabac_bypass(&s->HEVClc->cc);
588}
589
590int ff_hevc_sao_eo_class_decode(HEVCContext *s)
591{
592 int ret = get_cabac_bypass(&s->HEVClc->cc) << 1;
593 ret |= get_cabac_bypass(&s->HEVClc->cc);
594 return ret;
595}
596
597int ff_hevc_end_of_slice_flag_decode(HEVCContext *s)
598{
599 return get_cabac_terminate(&s->HEVClc->cc);
600}
601
602int ff_hevc_cu_transquant_bypass_flag_decode(HEVCContext *s)
603{
604 return GET_CABAC(elem_offset[CU_TRANSQUANT_BYPASS_FLAG]);
605}
606
607int ff_hevc_skip_flag_decode(HEVCContext *s, int x0, int y0, int x_cb, int y_cb)
608{
609 int min_cb_width = s->ps.sps->min_cb_width;
610 int inc = 0;
611 int x0b = av_mod_uintp2(x0, s->ps.sps->log2_ctb_size);
612 int y0b = av_mod_uintp2(y0, s->ps.sps->log2_ctb_size);
613
614 if (s->HEVClc->ctb_left_flag || x0b)
615 inc = !!SAMPLE_CTB(s->skip_flag, x_cb - 1, y_cb);
616 if (s->HEVClc->ctb_up_flag || y0b)
617 inc += !!SAMPLE_CTB(s->skip_flag, x_cb, y_cb - 1);
618
619 return GET_CABAC(elem_offset[SKIP_FLAG] + inc);
620}
621
622int ff_hevc_cu_qp_delta_abs(HEVCContext *s)
623{
624 int prefix_val = 0;
625 int suffix_val = 0;
626 int inc = 0;
627
628 while (prefix_val < 5 && GET_CABAC(elem_offset[CU_QP_DELTA] + inc)) {
629 prefix_val++;
630 inc = 1;
631 }
632 if (prefix_val >= 5) {
633 int k = 0;
634 while (k < CABAC_MAX_BIN && get_cabac_bypass(&s->HEVClc->cc)) {
635 suffix_val += 1 << k;
636 k++;
637 }
638 if (k == CABAC_MAX_BIN)
639 av_log(s->avctx, AV_LOG_ERROR, "CABAC_MAX_BIN : %d\n", k);
640
641 while (k--)
642 suffix_val += get_cabac_bypass(&s->HEVClc->cc) << k;
643 }
644 return prefix_val + suffix_val;
645}
646
647int ff_hevc_cu_qp_delta_sign_flag(HEVCContext *s)
648{
649 return get_cabac_bypass(&s->HEVClc->cc);
650}
651
652int ff_hevc_cu_chroma_qp_offset_flag(HEVCContext *s)
653{
654 return GET_CABAC(elem_offset[CU_CHROMA_QP_OFFSET_FLAG]);
655}
656
657int ff_hevc_cu_chroma_qp_offset_idx(HEVCContext *s)
658{
659 int c_max= FFMAX(5, s->ps.pps->chroma_qp_offset_list_len_minus1);
660 int i = 0;
661
662 while (i < c_max && GET_CABAC(elem_offset[CU_CHROMA_QP_OFFSET_IDX]))
663 i++;
664
665 return i;
666}
667
668int ff_hevc_pred_mode_decode(HEVCContext *s)
669{
670 return GET_CABAC(elem_offset[PRED_MODE_FLAG]);
671}
672
673int ff_hevc_split_coding_unit_flag_decode(HEVCContext *s, int ct_depth, int x0, int y0)
674{
675 int inc = 0, depth_left = 0, depth_top = 0;
676 int x0b = av_mod_uintp2(x0, s->ps.sps->log2_ctb_size);
677 int y0b = av_mod_uintp2(y0, s->ps.sps->log2_ctb_size);
678 int x_cb = x0 >> s->ps.sps->log2_min_cb_size;
679 int y_cb = y0 >> s->ps.sps->log2_min_cb_size;
680
681 if (s->HEVClc->ctb_left_flag || x0b)
682 depth_left = s->tab_ct_depth[(y_cb) * s->ps.sps->min_cb_width + x_cb - 1];
683 if (s->HEVClc->ctb_up_flag || y0b)
684 depth_top = s->tab_ct_depth[(y_cb - 1) * s->ps.sps->min_cb_width + x_cb];
685
686 inc += (depth_left > ct_depth);
687 inc += (depth_top > ct_depth);
688
689 return GET_CABAC(elem_offset[SPLIT_CODING_UNIT_FLAG] + inc);
690}
691
692int ff_hevc_part_mode_decode(HEVCContext *s, int log2_cb_size)
693{
694 if (GET_CABAC(elem_offset[PART_MODE])) // 1
695 return PART_2Nx2N;
696 if (log2_cb_size == s->ps.sps->log2_min_cb_size) {
697 if (s->HEVClc->cu.pred_mode == MODE_INTRA) // 0
698 return PART_NxN;
699 if (GET_CABAC(elem_offset[PART_MODE] + 1)) // 01
700 return PART_2NxN;
701 if (log2_cb_size == 3) // 00
702 return PART_Nx2N;
703 if (GET_CABAC(elem_offset[PART_MODE] + 2)) // 001
704 return PART_Nx2N;
705 return PART_NxN; // 000
706 }
707
708 if (!s->ps.sps->amp_enabled_flag) {
709 if (GET_CABAC(elem_offset[PART_MODE] + 1)) // 01
710 return PART_2NxN;
711 return PART_Nx2N;
712 }
713
714 if (GET_CABAC(elem_offset[PART_MODE] + 1)) { // 01X, 01XX
715 if (GET_CABAC(elem_offset[PART_MODE] + 3)) // 011
716 return PART_2NxN;
717 if (get_cabac_bypass(&s->HEVClc->cc)) // 0101
718 return PART_2NxnD;
719 return PART_2NxnU; // 0100
720 }
721
722 if (GET_CABAC(elem_offset[PART_MODE] + 3)) // 001
723 return PART_Nx2N;
724 if (get_cabac_bypass(&s->HEVClc->cc)) // 0001
725 return PART_nRx2N;
726 return PART_nLx2N; // 0000
727}
728
729int ff_hevc_pcm_flag_decode(HEVCContext *s)
730{
731 return get_cabac_terminate(&s->HEVClc->cc);
732}
733
734int ff_hevc_prev_intra_luma_pred_flag_decode(HEVCContext *s)
735{
736 return GET_CABAC(elem_offset[PREV_INTRA_LUMA_PRED_FLAG]);
737}
738
739int ff_hevc_mpm_idx_decode(HEVCContext *s)
740{
741 int i = 0;
742 while (i < 2 && get_cabac_bypass(&s->HEVClc->cc))
743 i++;
744 return i;
745}
746
747int ff_hevc_rem_intra_luma_pred_mode_decode(HEVCContext *s)
748{
749 int i;
750 int value = get_cabac_bypass(&s->HEVClc->cc);
751
752 for (i = 0; i < 4; i++)
753 value = (value << 1) | get_cabac_bypass(&s->HEVClc->cc);
754 return value;
755}
756
757int ff_hevc_intra_chroma_pred_mode_decode(HEVCContext *s)
758{
759 int ret;
760 if (!GET_CABAC(elem_offset[INTRA_CHROMA_PRED_MODE]))
761 return 4;
762
763 ret = get_cabac_bypass(&s->HEVClc->cc) << 1;
764 ret |= get_cabac_bypass(&s->HEVClc->cc);
765 return ret;
766}
767
768int ff_hevc_merge_idx_decode(HEVCContext *s)
769{
770 int i = GET_CABAC(elem_offset[MERGE_IDX]);
771
772 if (i != 0) {
773 while (i < s->sh.max_num_merge_cand-1 && get_cabac_bypass(&s->HEVClc->cc))
774 i++;
775 }
776 return i;
777}
778
779int ff_hevc_merge_flag_decode(HEVCContext *s)
780{
781 return GET_CABAC(elem_offset[MERGE_FLAG]);
782}
783
784int ff_hevc_inter_pred_idc_decode(HEVCContext *s, int nPbW, int nPbH)
785{
786 if (nPbW + nPbH == 12)
787 return GET_CABAC(elem_offset[INTER_PRED_IDC] + 4);
788 if (GET_CABAC(elem_offset[INTER_PRED_IDC] + s->HEVClc->ct_depth))
789 return PRED_BI;
790
791 return GET_CABAC(elem_offset[INTER_PRED_IDC] + 4);
792}
793
794int ff_hevc_ref_idx_lx_decode(HEVCContext *s, int num_ref_idx_lx)
795{
796 int i = 0;
797 int max = num_ref_idx_lx - 1;
798 int max_ctx = FFMIN(max, 2);
799
800 while (i < max_ctx && GET_CABAC(elem_offset[REF_IDX_L0] + i))
801 i++;
802 if (i == 2) {
803 while (i < max && get_cabac_bypass(&s->HEVClc->cc))
804 i++;
805 }
806
807 return i;
808}
809
810int ff_hevc_mvp_lx_flag_decode(HEVCContext *s)
811{
812 return GET_CABAC(elem_offset[MVP_LX_FLAG]);
813}
814
815int ff_hevc_no_residual_syntax_flag_decode(HEVCContext *s)
816{
817 return GET_CABAC(elem_offset[NO_RESIDUAL_DATA_FLAG]);
818}
819
820static av_always_inline int abs_mvd_greater0_flag_decode(HEVCContext *s)
821{
822 return GET_CABAC(elem_offset[ABS_MVD_GREATER0_FLAG]);
823}
824
825static av_always_inline int abs_mvd_greater1_flag_decode(HEVCContext *s)
826{
827 return GET_CABAC(elem_offset[ABS_MVD_GREATER1_FLAG] + 1);
828}
829
830static av_always_inline int mvd_decode(HEVCContext *s)
831{
832 int ret = 2;
833 int k = 1;
834
835 while (k < CABAC_MAX_BIN && get_cabac_bypass(&s->HEVClc->cc)) {
836 ret += 1U << k;
837 k++;
838 }
839 if (k == CABAC_MAX_BIN) {
840 av_log(s->avctx, AV_LOG_ERROR, "CABAC_MAX_BIN : %d\n", k);
841 return 0;
842 }
843 while (k--)
844 ret += get_cabac_bypass(&s->HEVClc->cc) << k;
845 return get_cabac_bypass_sign(&s->HEVClc->cc, -ret);
846}
847
848static av_always_inline int mvd_sign_flag_decode(HEVCContext *s)
849{
850 return get_cabac_bypass_sign(&s->HEVClc->cc, -1);
851}
852
853int ff_hevc_split_transform_flag_decode(HEVCContext *s, int log2_trafo_size)
854{
855 return GET_CABAC(elem_offset[SPLIT_TRANSFORM_FLAG] + 5 - log2_trafo_size);
856}
857
858int ff_hevc_cbf_cb_cr_decode(HEVCContext *s, int trafo_depth)
859{
860 return GET_CABAC(elem_offset[CBF_CB_CR] + trafo_depth);
861}
862
863int ff_hevc_cbf_luma_decode(HEVCContext *s, int trafo_depth)
864{
865 return GET_CABAC(elem_offset[CBF_LUMA] + !trafo_depth);
866}
867
868static int hevc_transform_skip_flag_decode(HEVCContext *s, int c_idx)
869{
870 return GET_CABAC(elem_offset[TRANSFORM_SKIP_FLAG] + !!c_idx);
871}
872
873static int explicit_rdpcm_flag_decode(HEVCContext *s, int c_idx)
874{
875 return GET_CABAC(elem_offset[EXPLICIT_RDPCM_FLAG] + !!c_idx);
876}
877
878static int explicit_rdpcm_dir_flag_decode(HEVCContext *s, int c_idx)
879{
880 return GET_CABAC(elem_offset[EXPLICIT_RDPCM_DIR_FLAG] + !!c_idx);
881}
882
883int ff_hevc_log2_res_scale_abs(HEVCContext *s, int idx) {
884 int i =0;
885
886 while (i < 4 && GET_CABAC(elem_offset[LOG2_RES_SCALE_ABS] + 4 * idx + i))
887 i++;
888
889 return i;
890}
891
892int ff_hevc_res_scale_sign_flag(HEVCContext *s, int idx) {
893 return GET_CABAC(elem_offset[RES_SCALE_SIGN_FLAG] + idx);
894}
895
896static av_always_inline void last_significant_coeff_xy_prefix_decode(HEVCContext *s, int c_idx,
897 int log2_size, int *last_scx_prefix, int *last_scy_prefix)
898{
899 int i = 0;
900 int max = (log2_size << 1) - 1;
901 int ctx_offset, ctx_shift;
902
903 if (!c_idx) {
904 ctx_offset = 3 * (log2_size - 2) + ((log2_size - 1) >> 2);
905 ctx_shift = (log2_size + 1) >> 2;
906 } else {
907 ctx_offset = 15;
908 ctx_shift = log2_size - 2;
909 }
910 while (i < max &&
911 GET_CABAC(elem_offset[LAST_SIGNIFICANT_COEFF_X_PREFIX] + (i >> ctx_shift) + ctx_offset))
912 i++;
913 *last_scx_prefix = i;
914
915 i = 0;
916 while (i < max &&
917 GET_CABAC(elem_offset[LAST_SIGNIFICANT_COEFF_Y_PREFIX] + (i >> ctx_shift) + ctx_offset))
918 i++;
919 *last_scy_prefix = i;
920}
921
922static av_always_inline int last_significant_coeff_suffix_decode(HEVCContext *s,
923 int last_significant_coeff_prefix)
924{
925 int i;
926 int length = (last_significant_coeff_prefix >> 1) - 1;
927 int value = get_cabac_bypass(&s->HEVClc->cc);
928
929 for (i = 1; i < length; i++)
930 value = (value << 1) | get_cabac_bypass(&s->HEVClc->cc);
931 return value;
932}
933
934static av_always_inline int significant_coeff_group_flag_decode(HEVCContext *s, int c_idx, int ctx_cg)
935{
936 int inc;
937
938 inc = FFMIN(ctx_cg, 1) + (c_idx>0 ? 2 : 0);
939
940 return GET_CABAC(elem_offset[SIGNIFICANT_COEFF_GROUP_FLAG] + inc);
941}
942static av_always_inline int significant_coeff_flag_decode(HEVCContext *s, int x_c, int y_c,
943 int offset, const uint8_t *ctx_idx_map)
944{
945 int inc = ctx_idx_map[(y_c << 2) + x_c] + offset;
946 return GET_CABAC(elem_offset[SIGNIFICANT_COEFF_FLAG] + inc);
947}
948
949static av_always_inline int significant_coeff_flag_decode_0(HEVCContext *s, int c_idx, int offset)
950{
951 return GET_CABAC(elem_offset[SIGNIFICANT_COEFF_FLAG] + offset);
952}
953
954static av_always_inline int coeff_abs_level_greater1_flag_decode(HEVCContext *s, int c_idx, int inc)
955{
956
957 if (c_idx > 0)
958 inc += 16;
959
960 return GET_CABAC(elem_offset[COEFF_ABS_LEVEL_GREATER1_FLAG] + inc);
961}
962
963static av_always_inline int coeff_abs_level_greater2_flag_decode(HEVCContext *s, int c_idx, int inc)
964{
965 if (c_idx > 0)
966 inc += 4;
967
968 return GET_CABAC(elem_offset[COEFF_ABS_LEVEL_GREATER2_FLAG] + inc);
969}
970
971static av_always_inline int coeff_abs_level_remaining_decode(HEVCContext *s, int rc_rice_param)
972{
973 int prefix = 0;
974 int suffix = 0;
975 int last_coeff_abs_level_remaining;
976 int i;
977
978 while (prefix < CABAC_MAX_BIN && get_cabac_bypass(&s->HEVClc->cc))
979 prefix++;
980 if (prefix == CABAC_MAX_BIN) {
981 av_log(s->avctx, AV_LOG_ERROR, "CABAC_MAX_BIN : %d\n", prefix);
982 return 0;
983 }
984 if (prefix < 3) {
985 for (i = 0; i < rc_rice_param; i++)
986 suffix = (suffix << 1) | get_cabac_bypass(&s->HEVClc->cc);
987 last_coeff_abs_level_remaining = (prefix << rc_rice_param) + suffix;
988 } else {
989 int prefix_minus3 = prefix - 3;
990 for (i = 0; i < prefix_minus3 + rc_rice_param; i++)
991 suffix = (suffix << 1) | get_cabac_bypass(&s->HEVClc->cc);
992 last_coeff_abs_level_remaining = (((1 << prefix_minus3) + 3 - 1)
993 << rc_rice_param) + suffix;
994 }
995 return last_coeff_abs_level_remaining;
996}
997
998static av_always_inline int coeff_sign_flag_decode(HEVCContext *s, uint8_t nb)
999{
1000 int i;
1001 int ret = 0;
1002
1003 for (i = 0; i < nb; i++)
1004 ret = (ret << 1) | get_cabac_bypass(&s->HEVClc->cc);
1005 return ret;
1006}
1007
1008void ff_hevc_hls_residual_coding(HEVCContext *s, int x0, int y0,
1009 int log2_trafo_size, enum ScanType scan_idx,
1010 int c_idx)
1011{
1012#define GET_COORD(offset, n) \
1013 do { \
1014 x_c = (x_cg << 2) + scan_x_off[n]; \
1015 y_c = (y_cg << 2) + scan_y_off[n]; \
1016 } while (0)
1017 HEVCLocalContext *lc = s->HEVClc;
1018 int transform_skip_flag = 0;
1019
1020 int last_significant_coeff_x, last_significant_coeff_y;
1021 int last_scan_pos;
1022 int n_end;
1023 int num_coeff = 0;
1024 int greater1_ctx = 1;
1025
1026 int num_last_subset;
1027 int x_cg_last_sig, y_cg_last_sig;
1028
1029 const uint8_t *scan_x_cg, *scan_y_cg, *scan_x_off, *scan_y_off;
1030
1031 ptrdiff_t stride = s->frame->linesize[c_idx];
1032 int hshift = s->ps.sps->hshift[c_idx];
1033 int vshift = s->ps.sps->vshift[c_idx];
1034 uint8_t *dst = &s->frame->data[c_idx][(y0 >> vshift) * stride +
1035 ((x0 >> hshift) << s->ps.sps->pixel_shift)];
1036 int16_t *coeffs = (int16_t*)(c_idx ? lc->edge_emu_buffer2 : lc->edge_emu_buffer);
1037 uint8_t significant_coeff_group_flag[8][8] = {{0}};
1038 int explicit_rdpcm_flag = 0;
1039 int explicit_rdpcm_dir_flag;
1040
1041 int trafo_size = 1 << log2_trafo_size;
1042 int i;
1043 int qp,shift,add,scale,scale_m;
1044 static const uint8_t level_scale[] = { 40, 45, 51, 57, 64, 72 };
1045 const uint8_t *scale_matrix = NULL;
1046 uint8_t dc_scale;
1047 int pred_mode_intra = (c_idx == 0) ? lc->tu.intra_pred_mode :
1048 lc->tu.intra_pred_mode_c;
1049
1050 memset(coeffs, 0, trafo_size * trafo_size * sizeof(int16_t));
1051
1052 // Derive QP for dequant
1053 if (!lc->cu.cu_transquant_bypass_flag) {
1054 static const int qp_c[] = { 29, 30, 31, 32, 33, 33, 34, 34, 35, 35, 36, 36, 37, 37 };
1055 static const uint8_t rem6[51 + 4 * 6 + 1] = {
1056 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2,
1057 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5,
1058 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3,
1059 4, 5, 0, 1, 2, 3, 4, 5, 0, 1
1060 };
1061
1062 static const uint8_t div6[51 + 4 * 6 + 1] = {
1063 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 3, 3, 3,
1064 3, 3, 3, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6,
1065 7, 7, 7, 7, 7, 7, 8, 8, 8, 8, 8, 8, 9, 9, 9, 9, 9, 9, 10, 10, 10, 10,
1066 10, 10, 11, 11, 11, 11, 11, 11, 12, 12
1067 };
1068 int qp_y = lc->qp_y;
1069
1070 if (s->ps.pps->transform_skip_enabled_flag &&
1071 log2_trafo_size <= s->ps.pps->log2_max_transform_skip_block_size) {
1072 transform_skip_flag = hevc_transform_skip_flag_decode(s, c_idx);
1073 }
1074
1075 if (c_idx == 0) {
1076 qp = qp_y + s->ps.sps->qp_bd_offset;
1077 } else {
1078 int qp_i, offset;
1079
1080 if (c_idx == 1)
1081 offset = s->ps.pps->cb_qp_offset + s->sh.slice_cb_qp_offset +
1082 lc->tu.cu_qp_offset_cb;
1083 else
1084 offset = s->ps.pps->cr_qp_offset + s->sh.slice_cr_qp_offset +
1085 lc->tu.cu_qp_offset_cr;
1086
1087 qp_i = av_clip(qp_y + offset, - s->ps.sps->qp_bd_offset, 57);
1088 if (s->ps.sps->chroma_format_idc == 1) {
1089 if (qp_i < 30)
1090 qp = qp_i;
1091 else if (qp_i > 43)
1092 qp = qp_i - 6;
1093 else
1094 qp = qp_c[qp_i - 30];
1095 } else {
1096 if (qp_i > 51)
1097 qp = 51;
1098 else
1099 qp = qp_i;
1100 }
1101
1102 qp += s->ps.sps->qp_bd_offset;
1103 }
1104
1105 shift = s->ps.sps->bit_depth + log2_trafo_size - 5;
1106 add = 1 << (shift-1);
1107 scale = level_scale[rem6[qp]] << (div6[qp]);
1108 scale_m = 16; // default when no custom scaling lists.
1109 dc_scale = 16;
1110
1111 if (s->ps.sps->scaling_list_enable_flag && !(transform_skip_flag && log2_trafo_size > 2)) {
1112 const ScalingList *sl = s->ps.pps->scaling_list_data_present_flag ?
1113 &s->ps.pps->scaling_list : &s->ps.sps->scaling_list;
1114 int matrix_id = lc->cu.pred_mode != MODE_INTRA;
1115
1116 matrix_id = 3 * matrix_id + c_idx;
1117
1118 scale_matrix = sl->sl[log2_trafo_size - 2][matrix_id];
1119 if (log2_trafo_size >= 4)
1120 dc_scale = sl->sl_dc[log2_trafo_size - 4][matrix_id];
1121 }
1122 } else {
1123 shift = 0;
1124 add = 0;
1125 scale = 0;
1126 dc_scale = 0;
1127 }
1128
1129 if (lc->cu.pred_mode == MODE_INTER && s->ps.sps->explicit_rdpcm_enabled_flag &&
1130 (transform_skip_flag || lc->cu.cu_transquant_bypass_flag)) {
1131 explicit_rdpcm_flag = explicit_rdpcm_flag_decode(s, c_idx);
1132 if (explicit_rdpcm_flag) {
1133 explicit_rdpcm_dir_flag = explicit_rdpcm_dir_flag_decode(s, c_idx);
1134 }
1135 }
1136
1137 last_significant_coeff_xy_prefix_decode(s, c_idx, log2_trafo_size,
1138 &last_significant_coeff_x, &last_significant_coeff_y);
1139
1140 if (last_significant_coeff_x > 3) {
1141 int suffix = last_significant_coeff_suffix_decode(s, last_significant_coeff_x);
1142 last_significant_coeff_x = (1 << ((last_significant_coeff_x >> 1) - 1)) *
1143 (2 + (last_significant_coeff_x & 1)) +
1144 suffix;
1145 }
1146
1147 if (last_significant_coeff_y > 3) {
1148 int suffix = last_significant_coeff_suffix_decode(s, last_significant_coeff_y);
1149 last_significant_coeff_y = (1 << ((last_significant_coeff_y >> 1) - 1)) *
1150 (2 + (last_significant_coeff_y & 1)) +
1151 suffix;
1152 }
1153
1154 if (scan_idx == SCAN_VERT)
1155 FFSWAP(int, last_significant_coeff_x, last_significant_coeff_y);
1156
1157 x_cg_last_sig = last_significant_coeff_x >> 2;
1158 y_cg_last_sig = last_significant_coeff_y >> 2;
1159
1160 switch (scan_idx) {
1161 case SCAN_DIAG: {
1162 int last_x_c = last_significant_coeff_x & 3;
1163 int last_y_c = last_significant_coeff_y & 3;
1164
1165 scan_x_off = ff_hevc_diag_scan4x4_x;
1166 scan_y_off = ff_hevc_diag_scan4x4_y;
1167 num_coeff = diag_scan4x4_inv[last_y_c][last_x_c];
1168 if (trafo_size == 4) {
1169 scan_x_cg = scan_1x1;
1170 scan_y_cg = scan_1x1;
1171 } else if (trafo_size == 8) {
1172 num_coeff += diag_scan2x2_inv[y_cg_last_sig][x_cg_last_sig] << 4;
1173 scan_x_cg = diag_scan2x2_x;
1174 scan_y_cg = diag_scan2x2_y;
1175 } else if (trafo_size == 16) {
1176 num_coeff += diag_scan4x4_inv[y_cg_last_sig][x_cg_last_sig] << 4;
1177 scan_x_cg = ff_hevc_diag_scan4x4_x;
1178 scan_y_cg = ff_hevc_diag_scan4x4_y;
1179 } else { // trafo_size == 32
1180 num_coeff += diag_scan8x8_inv[y_cg_last_sig][x_cg_last_sig] << 4;
1181 scan_x_cg = ff_hevc_diag_scan8x8_x;
1182 scan_y_cg = ff_hevc_diag_scan8x8_y;
1183 }
1184 break;
1185 }
1186 case SCAN_HORIZ:
1187 scan_x_cg = horiz_scan2x2_x;
1188 scan_y_cg = horiz_scan2x2_y;
1189 scan_x_off = horiz_scan4x4_x;
1190 scan_y_off = horiz_scan4x4_y;
1191 num_coeff = horiz_scan8x8_inv[last_significant_coeff_y][last_significant_coeff_x];
1192 break;
1193 default: //SCAN_VERT
1194 scan_x_cg = horiz_scan2x2_y;
1195 scan_y_cg = horiz_scan2x2_x;
1196 scan_x_off = horiz_scan4x4_y;
1197 scan_y_off = horiz_scan4x4_x;
1198 num_coeff = horiz_scan8x8_inv[last_significant_coeff_x][last_significant_coeff_y];
1199 break;
1200 }
1201 num_coeff++;
1202 num_last_subset = (num_coeff - 1) >> 4;
1203
1204 for (i = num_last_subset; i >= 0; i--) {
1205 int n, m;
1206 int x_cg, y_cg, x_c, y_c, pos;
1207 int implicit_non_zero_coeff = 0;
1208 int64_t trans_coeff_level;
1209 int prev_sig = 0;
1210 int offset = i << 4;
1211 int rice_init = 0;
1212
1213 uint8_t significant_coeff_flag_idx[16];
1214 uint8_t nb_significant_coeff_flag = 0;
1215
1216 x_cg = scan_x_cg[i];
1217 y_cg = scan_y_cg[i];
1218
1219 if ((i < num_last_subset) && (i > 0)) {
1220 int ctx_cg = 0;
1221 if (x_cg < (1 << (log2_trafo_size - 2)) - 1)
1222 ctx_cg += significant_coeff_group_flag[x_cg + 1][y_cg];
1223 if (y_cg < (1 << (log2_trafo_size - 2)) - 1)
1224 ctx_cg += significant_coeff_group_flag[x_cg][y_cg + 1];
1225
1226 significant_coeff_group_flag[x_cg][y_cg] =
1227 significant_coeff_group_flag_decode(s, c_idx, ctx_cg);
1228 implicit_non_zero_coeff = 1;
1229 } else {
1230 significant_coeff_group_flag[x_cg][y_cg] =
1231 ((x_cg == x_cg_last_sig && y_cg == y_cg_last_sig) ||
1232 (x_cg == 0 && y_cg == 0));
1233 }
1234
1235 last_scan_pos = num_coeff - offset - 1;
1236
1237 if (i == num_last_subset) {
1238 n_end = last_scan_pos - 1;
1239 significant_coeff_flag_idx[0] = last_scan_pos;
1240 nb_significant_coeff_flag = 1;
1241 } else {
1242 n_end = 15;
1243 }
1244
1245 if (x_cg < ((1 << log2_trafo_size) - 1) >> 2)
1246 prev_sig = !!significant_coeff_group_flag[x_cg + 1][y_cg];
1247 if (y_cg < ((1 << log2_trafo_size) - 1) >> 2)
1248 prev_sig += (!!significant_coeff_group_flag[x_cg][y_cg + 1] << 1);
1249
1250 if (significant_coeff_group_flag[x_cg][y_cg] && n_end >= 0) {
1251 static const uint8_t ctx_idx_map[] = {
1252 0, 1, 4, 5, 2, 3, 4, 5, 6, 6, 8, 8, 7, 7, 8, 8, // log2_trafo_size == 2
1253 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, // prev_sig == 0
1254 2, 2, 2, 2, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, // prev_sig == 1
1255 2, 1, 0, 0, 2, 1, 0, 0, 2, 1, 0, 0, 2, 1, 0, 0, // prev_sig == 2
1256 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2 // default
1257 };
1258 const uint8_t *ctx_idx_map_p;
1259 int scf_offset = 0;
1260 if (s->ps.sps->transform_skip_context_enabled_flag &&
1261 (transform_skip_flag || lc->cu.cu_transquant_bypass_flag)) {
1262 ctx_idx_map_p = (uint8_t*) &ctx_idx_map[4 * 16];
1263 if (c_idx == 0) {
1264 scf_offset = 40;
1265 } else {
1266 scf_offset = 14 + 27;
1267 }
1268 } else {
1269 if (c_idx != 0)
1270 scf_offset = 27;
1271 if (log2_trafo_size == 2) {
1272 ctx_idx_map_p = (uint8_t*) &ctx_idx_map[0];
1273 } else {
1274 ctx_idx_map_p = (uint8_t*) &ctx_idx_map[(prev_sig + 1) << 4];
1275 if (c_idx == 0) {
1276 if ((x_cg > 0 || y_cg > 0))
1277 scf_offset += 3;
1278 if (log2_trafo_size == 3) {
1279 scf_offset += (scan_idx == SCAN_DIAG) ? 9 : 15;
1280 } else {
1281 scf_offset += 21;
1282 }
1283 } else {
1284 if (log2_trafo_size == 3)
1285 scf_offset += 9;
1286 else
1287 scf_offset += 12;
1288 }
1289 }
1290 }
1291 for (n = n_end; n > 0; n--) {
1292 x_c = scan_x_off[n];
1293 y_c = scan_y_off[n];
1294 if (significant_coeff_flag_decode(s, x_c, y_c, scf_offset, ctx_idx_map_p)) {
1295 significant_coeff_flag_idx[nb_significant_coeff_flag] = n;
1296 nb_significant_coeff_flag++;
1297 implicit_non_zero_coeff = 0;
1298 }
1299 }
1300 if (implicit_non_zero_coeff == 0) {
1301 if (s->ps.sps->transform_skip_context_enabled_flag &&
1302 (transform_skip_flag || lc->cu.cu_transquant_bypass_flag)) {
1303 if (c_idx == 0) {
1304 scf_offset = 42;
1305 } else {
1306 scf_offset = 16 + 27;
1307 }
1308 } else {
1309 if (i == 0) {
1310 if (c_idx == 0)
1311 scf_offset = 0;
1312 else
1313 scf_offset = 27;
1314 } else {
1315 scf_offset = 2 + scf_offset;
1316 }
1317 }
1318 if (significant_coeff_flag_decode_0(s, c_idx, scf_offset) == 1) {
1319 significant_coeff_flag_idx[nb_significant_coeff_flag] = 0;
1320 nb_significant_coeff_flag++;
1321 }
1322 } else {
1323 significant_coeff_flag_idx[nb_significant_coeff_flag] = 0;
1324 nb_significant_coeff_flag++;
1325 }
1326 }
1327
1328 n_end = nb_significant_coeff_flag;
1329
1330
1331 if (n_end) {
1332 int first_nz_pos_in_cg;
1333 int last_nz_pos_in_cg;
1334 int c_rice_param = 0;
1335 int first_greater1_coeff_idx = -1;
1336 uint8_t coeff_abs_level_greater1_flag[8];
1337 uint16_t coeff_sign_flag;
1338 int sum_abs = 0;
1339 int sign_hidden;
1340 int sb_type;
1341
1342
1343 // initialize first elem of coeff_bas_level_greater1_flag
1344 int ctx_set = (i > 0 && c_idx == 0) ? 2 : 0;
1345
1346 if (s->ps.sps->persistent_rice_adaptation_enabled_flag) {
1347 if (!transform_skip_flag && !lc->cu.cu_transquant_bypass_flag)
1348 sb_type = 2 * (c_idx == 0 ? 1 : 0);
1349 else
1350 sb_type = 2 * (c_idx == 0 ? 1 : 0) + 1;
1351 c_rice_param = lc->stat_coeff[sb_type] / 4;
1352 }
1353
1354 if (!(i == num_last_subset) && greater1_ctx == 0)
1355 ctx_set++;
1356 greater1_ctx = 1;
1357 last_nz_pos_in_cg = significant_coeff_flag_idx[0];
1358
1359 for (m = 0; m < (n_end > 8 ? 8 : n_end); m++) {
1360 int inc = (ctx_set << 2) + greater1_ctx;
1361 coeff_abs_level_greater1_flag[m] =
1362 coeff_abs_level_greater1_flag_decode(s, c_idx, inc);
1363 if (coeff_abs_level_greater1_flag[m]) {
1364 greater1_ctx = 0;
1365 if (first_greater1_coeff_idx == -1)
1366 first_greater1_coeff_idx = m;
1367 } else if (greater1_ctx > 0 && greater1_ctx < 3) {
1368 greater1_ctx++;
1369 }
1370 }
1371 first_nz_pos_in_cg = significant_coeff_flag_idx[n_end - 1];
1372
1373 if (lc->cu.cu_transquant_bypass_flag ||
1374 (lc->cu.pred_mode == MODE_INTRA &&
1375 s->ps.sps->implicit_rdpcm_enabled_flag && transform_skip_flag &&
1376 (pred_mode_intra == 10 || pred_mode_intra == 26 )) ||
1377 explicit_rdpcm_flag)
1378 sign_hidden = 0;
1379 else
1380 sign_hidden = (last_nz_pos_in_cg - first_nz_pos_in_cg >= 4);
1381
1382 if (first_greater1_coeff_idx != -1) {
1383 coeff_abs_level_greater1_flag[first_greater1_coeff_idx] += coeff_abs_level_greater2_flag_decode(s, c_idx, ctx_set);
1384 }
1385 if (!s->ps.pps->sign_data_hiding_flag || !sign_hidden ) {
1386 coeff_sign_flag = coeff_sign_flag_decode(s, nb_significant_coeff_flag) << (16 - nb_significant_coeff_flag);
1387 } else {
1388 coeff_sign_flag = coeff_sign_flag_decode(s, nb_significant_coeff_flag - 1) << (16 - (nb_significant_coeff_flag - 1));
1389 }
1390
1391 for (m = 0; m < n_end; m++) {
1392 n = significant_coeff_flag_idx[m];
1393 GET_COORD(offset, n);
1394 if (m < 8) {
1395 trans_coeff_level = 1 + coeff_abs_level_greater1_flag[m];
1396 if (trans_coeff_level == ((m == first_greater1_coeff_idx) ? 3 : 2)) {
1397 int last_coeff_abs_level_remaining = coeff_abs_level_remaining_decode(s, c_rice_param);
1398
1399 trans_coeff_level += last_coeff_abs_level_remaining;
1400 if (trans_coeff_level > (3 << c_rice_param))
1401 c_rice_param = s->ps.sps->persistent_rice_adaptation_enabled_flag ? c_rice_param + 1 : FFMIN(c_rice_param + 1, 4);
1402 if (s->ps.sps->persistent_rice_adaptation_enabled_flag && !rice_init) {
1403 int c_rice_p_init = lc->stat_coeff[sb_type] / 4;
1404 if (last_coeff_abs_level_remaining >= (3 << c_rice_p_init))
1405 lc->stat_coeff[sb_type]++;
1406 else if (2 * last_coeff_abs_level_remaining < (1 << c_rice_p_init))
1407 if (lc->stat_coeff[sb_type] > 0)
1408 lc->stat_coeff[sb_type]--;
1409 rice_init = 1;
1410 }
1411 }
1412 } else {
1413 int last_coeff_abs_level_remaining = coeff_abs_level_remaining_decode(s, c_rice_param);
1414
1415 trans_coeff_level = 1 + 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 if (s->ps.pps->sign_data_hiding_flag && sign_hidden) {
1429 sum_abs += trans_coeff_level;
1430 if (n == first_nz_pos_in_cg && (sum_abs&1))
1431 trans_coeff_level = -trans_coeff_level;
1432 }
1433 if (coeff_sign_flag >> 15)
1434 trans_coeff_level = -trans_coeff_level;
1435 coeff_sign_flag <<= 1;
1436 if(!lc->cu.cu_transquant_bypass_flag) {
1437 if (s->ps.sps->scaling_list_enable_flag && !(transform_skip_flag && log2_trafo_size > 2)) {
1438 if(y_c || x_c || log2_trafo_size < 4) {
1439 switch(log2_trafo_size) {
1440 case 3: pos = (y_c << 3) + x_c; break;
1441 case 4: pos = ((y_c >> 1) << 3) + (x_c >> 1); break;
1442 case 5: pos = ((y_c >> 2) << 3) + (x_c >> 2); break;
1443 default: pos = (y_c << 2) + x_c; break;
1444 }
1445 scale_m = scale_matrix[pos];
1446 } else {
1447 scale_m = dc_scale;
1448 }
1449 }
1450 trans_coeff_level = (trans_coeff_level * (int64_t)scale * (int64_t)scale_m + add) >> shift;
1451 if(trans_coeff_level < 0) {
1452 if((~trans_coeff_level) & 0xFffffffffff8000)
1453 trans_coeff_level = -32768;
1454 } else {
1455 if(trans_coeff_level & 0xffffffffffff8000)
1456 trans_coeff_level = 32767;
1457 }
1458 }
1459 coeffs[y_c * trafo_size + x_c] = trans_coeff_level;
1460 }
1461 }
1462 }
1463
1464 if (lc->cu.cu_transquant_bypass_flag) {
1465 if (explicit_rdpcm_flag || (s->ps.sps->implicit_rdpcm_enabled_flag &&
1466 (pred_mode_intra == 10 || pred_mode_intra == 26))) {
1467 int mode = s->ps.sps->implicit_rdpcm_enabled_flag ? (pred_mode_intra == 26) : explicit_rdpcm_dir_flag;
1468
1469 s->hevcdsp.transform_rdpcm(coeffs, log2_trafo_size, mode);
1470 }
1471 } else {
1472 if (transform_skip_flag) {
1473 int rot = s->ps.sps->transform_skip_rotation_enabled_flag &&
1474 log2_trafo_size == 2 &&
1475 lc->cu.pred_mode == MODE_INTRA;
1476 if (rot) {
1477 for (i = 0; i < 8; i++)
1478 FFSWAP(int16_t, coeffs[i], coeffs[16 - i - 1]);
1479 }
1480
1481 s->hevcdsp.dequant(coeffs, log2_trafo_size);
1482
1483 if (explicit_rdpcm_flag || (s->ps.sps->implicit_rdpcm_enabled_flag &&
1484 lc->cu.pred_mode == MODE_INTRA &&
1485 (pred_mode_intra == 10 || pred_mode_intra == 26))) {
1486 int mode = explicit_rdpcm_flag ? explicit_rdpcm_dir_flag : (pred_mode_intra == 26);
1487
1488 s->hevcdsp.transform_rdpcm(coeffs, log2_trafo_size, mode);
1489 }
1490 } else if (lc->cu.pred_mode == MODE_INTRA && c_idx == 0 && log2_trafo_size == 2) {
1491 s->hevcdsp.transform_4x4_luma(coeffs);
1492 } else {
1493 int max_xy = FFMAX(last_significant_coeff_x, last_significant_coeff_y);
1494 if (max_xy == 0)
1495 s->hevcdsp.idct_dc[log2_trafo_size - 2](coeffs);
1496 else {
1497 int col_limit = last_significant_coeff_x + last_significant_coeff_y + 4;
1498 if (max_xy < 4)
1499 col_limit = FFMIN(4, col_limit);
1500 else if (max_xy < 8)
1501 col_limit = FFMIN(8, col_limit);
1502 else if (max_xy < 12)
1503 col_limit = FFMIN(24, col_limit);
1504 s->hevcdsp.idct[log2_trafo_size - 2](coeffs, col_limit);
1505 }
1506 }
1507 }
1508 if (lc->tu.cross_pf) {
1509 int16_t *coeffs_y = (int16_t*)lc->edge_emu_buffer;
1510
1511 for (i = 0; i < (trafo_size * trafo_size); i++) {
1512 coeffs[i] = coeffs[i] + ((lc->tu.res_scale_val * coeffs_y[i]) >> 3);
1513 }
1514 }
1515 s->hevcdsp.add_residual[log2_trafo_size-2](dst, coeffs, stride);
1516}
1517
1518void ff_hevc_hls_mvd_coding(HEVCContext *s, int x0, int y0, int log2_cb_size)
1519{
1520 HEVCLocalContext *lc = s->HEVClc;
1521 int x = abs_mvd_greater0_flag_decode(s);
1522 int y = abs_mvd_greater0_flag_decode(s);
1523
1524 if (x)
1525 x += abs_mvd_greater1_flag_decode(s);
1526 if (y)
1527 y += abs_mvd_greater1_flag_decode(s);
1528
1529 switch (x) {
1530 case 2: lc->pu.mvd.x = mvd_decode(s); break;
1531 case 1: lc->pu.mvd.x = mvd_sign_flag_decode(s); break;
1532 case 0: lc->pu.mvd.x = 0; break;
1533 }
1534
1535 switch (y) {
1536 case 2: lc->pu.mvd.y = mvd_decode(s); break;
1537 case 1: lc->pu.mvd.y = mvd_sign_flag_decode(s); break;
1538 case 0: lc->pu.mvd.y = 0; break;
1539 }
1540}
1541
1542
generated by cgit at 2024-05-17 07:00:01 (GMT)