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