4 * Copyright (C) 2012 - 2013 Guillaume Martres
5 * Copyright (C) 2012 - 2013 Gildas Cocherel
7 * This file is part of FFmpeg.
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.
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.
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
24 #include "libavutil/attributes.h"
25 #include "libavutil/common.h"
27 #include "cabac_functions.h"
28 #include "hevc_data.h"
31 #define CABAC_MAX_BIN 31
34 * number of bin by SyntaxElement.
36 av_unused static const int8_t num_bins_in_se[] = {
40 0, // sao_band_position
43 0, // end_of_slice_flag
44 3, // split_coding_unit_flag
45 1, // cu_transquant_bypass_flag
51 1, // prev_intra_luma_pred_mode
53 0, // rem_intra_luma_pred_mode
54 2, // intra_chroma_pred_mode
60 2, // abs_mvd_greater0_flag
61 2, // abs_mvd_greater1_flag
65 1, // no_residual_data_flag
66 3, // split_transform_flag
69 2, // transform_skip_flag[][]
70 2, // explicit_rdpcm_flag[][]
71 2, // explicit_rdpcm_dir_flag[][]
72 18, // last_significant_coeff_x_prefix
73 18, // last_significant_coeff_y_prefix
74 0, // last_significant_coeff_x_suffix
75 0, // last_significant_coeff_y_suffix
76 4, // significant_coeff_group_flag
77 44, // significant_coeff_flag
78 24, // coeff_abs_level_greater1_flag
79 6, // coeff_abs_level_greater2_flag
80 0, // coeff_abs_level_remaining
82 8, // log2_res_scale_abs
83 2, // res_scale_sign_flag
84 1, // cu_chroma_qp_offset_flag
85 1, // cu_chroma_qp_offset_idx
89 * Offset to ctxIdx 0 in init_values and states, indexed by SyntaxElement.
91 static const int elem_offset[sizeof(num_bins_in_se)] = {
95 2, // sao_band_position
98 2, // end_of_slice_flag
99 2, // split_coding_unit_flag
100 5, // cu_transquant_bypass_flag
106 17, // prev_intra_luma_pred_mode
108 18, // rem_intra_luma_pred_mode
109 18, // intra_chroma_pred_mode
112 22, // inter_pred_idc
115 31, // abs_mvd_greater0_flag
116 33, // abs_mvd_greater1_flag
117 35, // abs_mvd_minus2
120 36, // no_residual_data_flag
121 37, // split_transform_flag
123 42, // cbf_cb, cbf_cr
124 46, // transform_skip_flag[][]
125 48, // explicit_rdpcm_flag[][]
126 50, // explicit_rdpcm_dir_flag[][]
127 52, // last_significant_coeff_x_prefix
128 70, // last_significant_coeff_y_prefix
129 88, // last_significant_coeff_x_suffix
130 88, // last_significant_coeff_y_suffix
131 88, // significant_coeff_group_flag
132 92, // significant_coeff_flag
133 136, // coeff_abs_level_greater1_flag
134 160, // coeff_abs_level_greater2_flag
135 166, // coeff_abs_level_remaining
136 166, // coeff_sign_flag
137 166, // log2_res_scale_abs
138 174, // res_scale_sign_flag
139 176, // cu_chroma_qp_offset_flag
140 177, // cu_chroma_qp_offset_idx
145 * Indexed by init_type
147 static const uint8_t init_values[3][HEVC_CONTEXTS] = {
152 // split_coding_unit_flag
154 // cu_transquant_bypass_flag
164 // prev_intra_luma_pred_mode
166 // intra_chroma_pred_mode
173 CNU, CNU, CNU, CNU, CNU,
178 // abs_mvd_greater1_flag
180 // abs_mvd_greater1_flag
184 // no_residual_data_flag
186 // split_transform_flag
192 // transform_skip_flag
194 // explicit_rdpcm_flag
196 // explicit_rdpcm_dir_flag
198 // last_significant_coeff_x_prefix
199 110, 110, 124, 125, 140, 153, 125, 127, 140, 109, 111, 143, 127, 111,
201 // last_significant_coeff_y_prefix
202 110, 110, 124, 125, 140, 153, 125, 127, 140, 109, 111, 143, 127, 111,
204 // significant_coeff_group_flag
206 // significant_coeff_flag
207 111, 111, 125, 110, 110, 94, 124, 108, 124, 107, 125, 141, 179, 153,
208 125, 107, 125, 141, 179, 153, 125, 107, 125, 141, 179, 153, 125, 140,
209 139, 182, 182, 152, 136, 152, 136, 153, 136, 139, 111, 136, 139, 111,
211 // coeff_abs_level_greater1_flag
212 140, 92, 137, 138, 140, 152, 138, 139, 153, 74, 149, 92, 139, 107,
213 122, 152, 140, 179, 166, 182, 140, 227, 122, 197,
214 // coeff_abs_level_greater2_flag
215 138, 153, 136, 167, 152, 152,
216 // log2_res_scale_abs
217 154, 154, 154, 154, 154, 154, 154, 154,
218 // res_scale_sign_flag
220 // cu_chroma_qp_offset_flag
222 // cu_chroma_qp_offset_idx
229 // split_coding_unit_flag
231 // cu_transquant_bypass_flag
241 // prev_intra_luma_pred_mode
243 // intra_chroma_pred_mode
255 // abs_mvd_greater1_flag
257 // abs_mvd_greater1_flag
261 // no_residual_data_flag
263 // split_transform_flag
269 // transform_skip_flag
271 // explicit_rdpcm_flag
273 // explicit_rdpcm_dir_flag
275 // last_significant_coeff_x_prefix
276 125, 110, 94, 110, 95, 79, 125, 111, 110, 78, 110, 111, 111, 95,
278 // last_significant_coeff_y_prefix
279 125, 110, 94, 110, 95, 79, 125, 111, 110, 78, 110, 111, 111, 95,
281 // significant_coeff_group_flag
283 // significant_coeff_flag
284 155, 154, 139, 153, 139, 123, 123, 63, 153, 166, 183, 140, 136, 153,
285 154, 166, 183, 140, 136, 153, 154, 166, 183, 140, 136, 153, 154, 170,
286 153, 123, 123, 107, 121, 107, 121, 167, 151, 183, 140, 151, 183, 140,
288 // coeff_abs_level_greater1_flag
289 154, 196, 196, 167, 154, 152, 167, 182, 182, 134, 149, 136, 153, 121,
290 136, 137, 169, 194, 166, 167, 154, 167, 137, 182,
291 // coeff_abs_level_greater2_flag
292 107, 167, 91, 122, 107, 167,
293 // log2_res_scale_abs
294 154, 154, 154, 154, 154, 154, 154, 154,
295 // res_scale_sign_flag
297 // cu_chroma_qp_offset_flag
299 // cu_chroma_qp_offset_idx
306 // split_coding_unit_flag
308 // cu_transquant_bypass_flag
318 // prev_intra_luma_pred_mode
320 // intra_chroma_pred_mode
332 // abs_mvd_greater1_flag
334 // abs_mvd_greater1_flag
338 // no_residual_data_flag
340 // split_transform_flag
346 // transform_skip_flag
348 // explicit_rdpcm_flag
350 // explicit_rdpcm_dir_flag
352 // last_significant_coeff_x_prefix
353 125, 110, 124, 110, 95, 94, 125, 111, 111, 79, 125, 126, 111, 111,
355 // last_significant_coeff_y_prefix
356 125, 110, 124, 110, 95, 94, 125, 111, 111, 79, 125, 126, 111, 111,
358 // significant_coeff_group_flag
360 // significant_coeff_flag
361 170, 154, 139, 153, 139, 123, 123, 63, 124, 166, 183, 140, 136, 153,
362 154, 166, 183, 140, 136, 153, 154, 166, 183, 140, 136, 153, 154, 170,
363 153, 138, 138, 122, 121, 122, 121, 167, 151, 183, 140, 151, 183, 140,
365 // coeff_abs_level_greater1_flag
366 154, 196, 167, 167, 154, 152, 167, 182, 182, 134, 149, 136, 153, 121,
367 136, 122, 169, 208, 166, 167, 154, 152, 167, 182,
368 // coeff_abs_level_greater2_flag
369 107, 167, 91, 107, 107, 167,
370 // log2_res_scale_abs
371 154, 154, 154, 154, 154, 154, 154, 154,
372 // res_scale_sign_flag
374 // cu_chroma_qp_offset_flag
376 // cu_chroma_qp_offset_idx
381 static const uint8_t scan_1x1[1] = {
385 static const uint8_t horiz_scan2x2_x[4] = {
389 static const uint8_t horiz_scan2x2_y[4] = {
393 static const uint8_t horiz_scan4x4_x[16] = {
400 static const uint8_t horiz_scan4x4_y[16] = {
407 static const uint8_t horiz_scan8x8_inv[8][8] = {
408 { 0, 1, 2, 3, 16, 17, 18, 19, },
409 { 4, 5, 6, 7, 20, 21, 22, 23, },
410 { 8, 9, 10, 11, 24, 25, 26, 27, },
411 { 12, 13, 14, 15, 28, 29, 30, 31, },
412 { 32, 33, 34, 35, 48, 49, 50, 51, },
413 { 36, 37, 38, 39, 52, 53, 54, 55, },
414 { 40, 41, 42, 43, 56, 57, 58, 59, },
415 { 44, 45, 46, 47, 60, 61, 62, 63, },
418 static const uint8_t diag_scan2x2_x[4] = {
422 static const uint8_t diag_scan2x2_y[4] = {
426 static const uint8_t diag_scan2x2_inv[2][2] = {
431 static const uint8_t diag_scan4x4_inv[4][4] = {
438 static const uint8_t diag_scan8x8_inv[8][8] = {
439 { 0, 2, 5, 9, 14, 20, 27, 35, },
440 { 1, 4, 8, 13, 19, 26, 34, 42, },
441 { 3, 7, 12, 18, 25, 33, 41, 48, },
442 { 6, 11, 17, 24, 32, 40, 47, 53, },
443 { 10, 16, 23, 31, 39, 46, 52, 57, },
444 { 15, 22, 30, 38, 45, 51, 56, 60, },
445 { 21, 29, 37, 44, 50, 55, 59, 62, },
446 { 28, 36, 43, 49, 54, 58, 61, 63, },
449 void ff_hevc_save_states(HEVCContext *s, int ctb_addr_ts)
451 if (s->ps.pps->entropy_coding_sync_enabled_flag &&
452 (ctb_addr_ts % s->ps.sps->ctb_width == 2 ||
453 (s->ps.sps->ctb_width == 2 &&
454 ctb_addr_ts % s->ps.sps->ctb_width == 0))) {
455 memcpy(s->cabac_state, s->HEVClc->cabac_state, HEVC_CONTEXTS);
459 static void load_states(HEVCContext *s)
461 memcpy(s->HEVClc->cabac_state, s->cabac_state, HEVC_CONTEXTS);
464 static void cabac_reinit(HEVCLocalContext *lc)
466 skip_bytes(&lc->cc, 0);
469 static void cabac_init_decoder(HEVCContext *s)
471 GetBitContext *gb = &s->HEVClc->gb;
474 ff_init_cabac_decoder(&s->HEVClc->cc,
475 gb->buffer + get_bits_count(gb) / 8,
476 (get_bits_left(gb) + 7) / 8);
479 static void cabac_init_state(HEVCContext *s)
481 int init_type = 2 - s->sh.slice_type;
484 if (s->sh.cabac_init_flag && s->sh.slice_type != I_SLICE)
487 for (i = 0; i < HEVC_CONTEXTS; i++) {
488 int init_value = init_values[init_type][i];
489 int m = (init_value >> 4) * 5 - 45;
490 int n = ((init_value & 15) << 3) - 16;
491 int pre = 2 * (((m * av_clip(s->sh.slice_qp, 0, 51)) >> 4) + n) - 127;
495 pre = 124 + (pre & 1);
496 s->HEVClc->cabac_state[i] = pre;
499 for (i = 0; i < 4; i++)
500 s->HEVClc->stat_coeff[i] = 0;
503 void ff_hevc_cabac_init(HEVCContext *s, int ctb_addr_ts)
505 if (ctb_addr_ts == s->ps.pps->ctb_addr_rs_to_ts[s->sh.slice_ctb_addr_rs]) {
506 cabac_init_decoder(s);
507 if (s->sh.dependent_slice_segment_flag == 0 ||
508 (s->ps.pps->tiles_enabled_flag &&
509 s->ps.pps->tile_id[ctb_addr_ts] != s->ps.pps->tile_id[ctb_addr_ts - 1]))
512 if (!s->sh.first_slice_in_pic_flag &&
513 s->ps.pps->entropy_coding_sync_enabled_flag) {
514 if (ctb_addr_ts % s->ps.sps->ctb_width == 0) {
515 if (s->ps.sps->ctb_width == 1)
517 else if (s->sh.dependent_slice_segment_flag == 1)
522 if (s->ps.pps->tiles_enabled_flag &&
523 s->ps.pps->tile_id[ctb_addr_ts] != s->ps.pps->tile_id[ctb_addr_ts - 1]) {
524 if (s->threads_number == 1)
525 cabac_reinit(s->HEVClc);
527 cabac_init_decoder(s);
530 if (s->ps.pps->entropy_coding_sync_enabled_flag) {
531 if (ctb_addr_ts % s->ps.sps->ctb_width == 0) {
532 get_cabac_terminate(&s->HEVClc->cc);
533 if (s->threads_number == 1)
534 cabac_reinit(s->HEVClc);
536 cabac_init_decoder(s);
538 if (s->ps.sps->ctb_width == 1)
547 #define GET_CABAC(ctx) get_cabac(&s->HEVClc->cc, &s->HEVClc->cabac_state[ctx])
549 int ff_hevc_sao_merge_flag_decode(HEVCContext *s)
551 return GET_CABAC(elem_offset[SAO_MERGE_FLAG]);
554 int ff_hevc_sao_type_idx_decode(HEVCContext *s)
556 if (!GET_CABAC(elem_offset[SAO_TYPE_IDX]))
559 if (!get_cabac_bypass(&s->HEVClc->cc))
564 int ff_hevc_sao_band_position_decode(HEVCContext *s)
567 int value = get_cabac_bypass(&s->HEVClc->cc);
569 for (i = 0; i < 4; i++)
570 value = (value << 1) | get_cabac_bypass(&s->HEVClc->cc);
574 int ff_hevc_sao_offset_abs_decode(HEVCContext *s)
577 int length = (1 << (FFMIN(s->ps.sps->bit_depth, 10) - 5)) - 1;
579 while (i < length && get_cabac_bypass(&s->HEVClc->cc))
584 int ff_hevc_sao_offset_sign_decode(HEVCContext *s)
586 return get_cabac_bypass(&s->HEVClc->cc);
589 int ff_hevc_sao_eo_class_decode(HEVCContext *s)
591 int ret = get_cabac_bypass(&s->HEVClc->cc) << 1;
592 ret |= get_cabac_bypass(&s->HEVClc->cc);
596 int ff_hevc_end_of_slice_flag_decode(HEVCContext *s)
598 return get_cabac_terminate(&s->HEVClc->cc);
601 int ff_hevc_cu_transquant_bypass_flag_decode(HEVCContext *s)
603 return GET_CABAC(elem_offset[CU_TRANSQUANT_BYPASS_FLAG]);
606 int ff_hevc_skip_flag_decode(HEVCContext *s, int x0, int y0, int x_cb, int y_cb)
608 int min_cb_width = s->ps.sps->min_cb_width;
610 int x0b = av_mod_uintp2(x0, s->ps.sps->log2_ctb_size);
611 int y0b = av_mod_uintp2(y0, s->ps.sps->log2_ctb_size);
613 if (s->HEVClc->ctb_left_flag || x0b)
614 inc = !!SAMPLE_CTB(s->skip_flag, x_cb - 1, y_cb);
615 if (s->HEVClc->ctb_up_flag || y0b)
616 inc += !!SAMPLE_CTB(s->skip_flag, x_cb, y_cb - 1);
618 return GET_CABAC(elem_offset[SKIP_FLAG] + inc);
621 int ff_hevc_cu_qp_delta_abs(HEVCContext *s)
627 while (prefix_val < 5 && GET_CABAC(elem_offset[CU_QP_DELTA] + inc)) {
631 if (prefix_val >= 5) {
633 while (k < CABAC_MAX_BIN && get_cabac_bypass(&s->HEVClc->cc)) {
634 suffix_val += 1 << k;
637 if (k == CABAC_MAX_BIN)
638 av_log(s->avctx, AV_LOG_ERROR, "CABAC_MAX_BIN : %d\n", k);
641 suffix_val += get_cabac_bypass(&s->HEVClc->cc) << k;
643 return prefix_val + suffix_val;
646 int ff_hevc_cu_qp_delta_sign_flag(HEVCContext *s)
648 return get_cabac_bypass(&s->HEVClc->cc);
651 int ff_hevc_cu_chroma_qp_offset_flag(HEVCContext *s)
653 return GET_CABAC(elem_offset[CU_CHROMA_QP_OFFSET_FLAG]);
656 int ff_hevc_cu_chroma_qp_offset_idx(HEVCContext *s)
658 int c_max= FFMAX(5, s->ps.pps->chroma_qp_offset_list_len_minus1);
661 while (i < c_max && GET_CABAC(elem_offset[CU_CHROMA_QP_OFFSET_IDX]))
667 int ff_hevc_pred_mode_decode(HEVCContext *s)
669 return GET_CABAC(elem_offset[PRED_MODE_FLAG]);
672 int ff_hevc_split_coding_unit_flag_decode(HEVCContext *s, int ct_depth, int x0, int y0)
674 int inc = 0, depth_left = 0, depth_top = 0;
675 int x0b = av_mod_uintp2(x0, s->ps.sps->log2_ctb_size);
676 int y0b = av_mod_uintp2(y0, s->ps.sps->log2_ctb_size);
677 int x_cb = x0 >> s->ps.sps->log2_min_cb_size;
678 int y_cb = y0 >> s->ps.sps->log2_min_cb_size;
680 if (s->HEVClc->ctb_left_flag || x0b)
681 depth_left = s->tab_ct_depth[(y_cb) * s->ps.sps->min_cb_width + x_cb - 1];
682 if (s->HEVClc->ctb_up_flag || y0b)
683 depth_top = s->tab_ct_depth[(y_cb - 1) * s->ps.sps->min_cb_width + x_cb];
685 inc += (depth_left > ct_depth);
686 inc += (depth_top > ct_depth);
688 return GET_CABAC(elem_offset[SPLIT_CODING_UNIT_FLAG] + inc);
691 int ff_hevc_part_mode_decode(HEVCContext *s, int log2_cb_size)
693 if (GET_CABAC(elem_offset[PART_MODE])) // 1
695 if (log2_cb_size == s->ps.sps->log2_min_cb_size) {
696 if (s->HEVClc->cu.pred_mode == MODE_INTRA) // 0
698 if (GET_CABAC(elem_offset[PART_MODE] + 1)) // 01
700 if (log2_cb_size == 3) // 00
702 if (GET_CABAC(elem_offset[PART_MODE] + 2)) // 001
704 return PART_NxN; // 000
707 if (!s->ps.sps->amp_enabled_flag) {
708 if (GET_CABAC(elem_offset[PART_MODE] + 1)) // 01
713 if (GET_CABAC(elem_offset[PART_MODE] + 1)) { // 01X, 01XX
714 if (GET_CABAC(elem_offset[PART_MODE] + 3)) // 011
716 if (get_cabac_bypass(&s->HEVClc->cc)) // 0101
718 return PART_2NxnU; // 0100
721 if (GET_CABAC(elem_offset[PART_MODE] + 3)) // 001
723 if (get_cabac_bypass(&s->HEVClc->cc)) // 0001
725 return PART_nLx2N; // 0000
728 int ff_hevc_pcm_flag_decode(HEVCContext *s)
730 return get_cabac_terminate(&s->HEVClc->cc);
733 int ff_hevc_prev_intra_luma_pred_flag_decode(HEVCContext *s)
735 return GET_CABAC(elem_offset[PREV_INTRA_LUMA_PRED_FLAG]);
738 int ff_hevc_mpm_idx_decode(HEVCContext *s)
741 while (i < 2 && get_cabac_bypass(&s->HEVClc->cc))
746 int ff_hevc_rem_intra_luma_pred_mode_decode(HEVCContext *s)
749 int value = get_cabac_bypass(&s->HEVClc->cc);
751 for (i = 0; i < 4; i++)
752 value = (value << 1) | get_cabac_bypass(&s->HEVClc->cc);
756 int ff_hevc_intra_chroma_pred_mode_decode(HEVCContext *s)
759 if (!GET_CABAC(elem_offset[INTRA_CHROMA_PRED_MODE]))
762 ret = get_cabac_bypass(&s->HEVClc->cc) << 1;
763 ret |= get_cabac_bypass(&s->HEVClc->cc);
767 int ff_hevc_merge_idx_decode(HEVCContext *s)
769 int i = GET_CABAC(elem_offset[MERGE_IDX]);
772 while (i < s->sh.max_num_merge_cand-1 && get_cabac_bypass(&s->HEVClc->cc))
778 int ff_hevc_merge_flag_decode(HEVCContext *s)
780 return GET_CABAC(elem_offset[MERGE_FLAG]);
783 int ff_hevc_inter_pred_idc_decode(HEVCContext *s, int nPbW, int nPbH)
785 if (nPbW + nPbH == 12)
786 return GET_CABAC(elem_offset[INTER_PRED_IDC] + 4);
787 if (GET_CABAC(elem_offset[INTER_PRED_IDC] + s->HEVClc->ct_depth))
790 return GET_CABAC(elem_offset[INTER_PRED_IDC] + 4);
793 int ff_hevc_ref_idx_lx_decode(HEVCContext *s, int num_ref_idx_lx)
796 int max = num_ref_idx_lx - 1;
797 int max_ctx = FFMIN(max, 2);
799 while (i < max_ctx && GET_CABAC(elem_offset[REF_IDX_L0] + i))
802 while (i < max && get_cabac_bypass(&s->HEVClc->cc))
809 int ff_hevc_mvp_lx_flag_decode(HEVCContext *s)
811 return GET_CABAC(elem_offset[MVP_LX_FLAG]);
814 int ff_hevc_no_residual_syntax_flag_decode(HEVCContext *s)
816 return GET_CABAC(elem_offset[NO_RESIDUAL_DATA_FLAG]);
819 static av_always_inline int abs_mvd_greater0_flag_decode(HEVCContext *s)
821 return GET_CABAC(elem_offset[ABS_MVD_GREATER0_FLAG]);
824 static av_always_inline int abs_mvd_greater1_flag_decode(HEVCContext *s)
826 return GET_CABAC(elem_offset[ABS_MVD_GREATER1_FLAG] + 1);
829 static av_always_inline int mvd_decode(HEVCContext *s)
834 while (k < CABAC_MAX_BIN && get_cabac_bypass(&s->HEVClc->cc)) {
838 if (k == CABAC_MAX_BIN) {
839 av_log(s->avctx, AV_LOG_ERROR, "CABAC_MAX_BIN : %d\n", k);
843 ret += get_cabac_bypass(&s->HEVClc->cc) << k;
844 return get_cabac_bypass_sign(&s->HEVClc->cc, -ret);
847 static av_always_inline int mvd_sign_flag_decode(HEVCContext *s)
849 return get_cabac_bypass_sign(&s->HEVClc->cc, -1);
852 int ff_hevc_split_transform_flag_decode(HEVCContext *s, int log2_trafo_size)
854 return GET_CABAC(elem_offset[SPLIT_TRANSFORM_FLAG] + 5 - log2_trafo_size);
857 int ff_hevc_cbf_cb_cr_decode(HEVCContext *s, int trafo_depth)
859 return GET_CABAC(elem_offset[CBF_CB_CR] + trafo_depth);
862 int ff_hevc_cbf_luma_decode(HEVCContext *s, int trafo_depth)
864 return GET_CABAC(elem_offset[CBF_LUMA] + !trafo_depth);
867 static int hevc_transform_skip_flag_decode(HEVCContext *s, int c_idx)
869 return GET_CABAC(elem_offset[TRANSFORM_SKIP_FLAG] + !!c_idx);
872 static int explicit_rdpcm_flag_decode(HEVCContext *s, int c_idx)
874 return GET_CABAC(elem_offset[EXPLICIT_RDPCM_FLAG] + !!c_idx);
877 static int explicit_rdpcm_dir_flag_decode(HEVCContext *s, int c_idx)
879 return GET_CABAC(elem_offset[EXPLICIT_RDPCM_DIR_FLAG] + !!c_idx);
882 int ff_hevc_log2_res_scale_abs(HEVCContext *s, int idx) {
885 while (i < 4 && GET_CABAC(elem_offset[LOG2_RES_SCALE_ABS] + 4 * idx + i))
891 int ff_hevc_res_scale_sign_flag(HEVCContext *s, int idx) {
892 return GET_CABAC(elem_offset[RES_SCALE_SIGN_FLAG] + idx);
895 static av_always_inline void last_significant_coeff_xy_prefix_decode(HEVCContext *s, int c_idx,
896 int log2_size, int *last_scx_prefix, int *last_scy_prefix)
899 int max = (log2_size << 1) - 1;
900 int ctx_offset, ctx_shift;
903 ctx_offset = 3 * (log2_size - 2) + ((log2_size - 1) >> 2);
904 ctx_shift = (log2_size + 1) >> 2;
907 ctx_shift = log2_size - 2;
910 GET_CABAC(elem_offset[LAST_SIGNIFICANT_COEFF_X_PREFIX] + (i >> ctx_shift) + ctx_offset))
912 *last_scx_prefix = i;
916 GET_CABAC(elem_offset[LAST_SIGNIFICANT_COEFF_Y_PREFIX] + (i >> ctx_shift) + ctx_offset))
918 *last_scy_prefix = i;
921 static av_always_inline int last_significant_coeff_suffix_decode(HEVCContext *s,
922 int last_significant_coeff_prefix)
925 int length = (last_significant_coeff_prefix >> 1) - 1;
926 int value = get_cabac_bypass(&s->HEVClc->cc);
928 for (i = 1; i < length; i++)
929 value = (value << 1) | get_cabac_bypass(&s->HEVClc->cc);
933 static av_always_inline int significant_coeff_group_flag_decode(HEVCContext *s, int c_idx, int ctx_cg)
937 inc = FFMIN(ctx_cg, 1) + (c_idx>0 ? 2 : 0);
939 return GET_CABAC(elem_offset[SIGNIFICANT_COEFF_GROUP_FLAG] + inc);
941 static av_always_inline int significant_coeff_flag_decode(HEVCContext *s, int x_c, int y_c,
942 int offset, const uint8_t *ctx_idx_map)
944 int inc = ctx_idx_map[(y_c << 2) + x_c] + offset;
945 return GET_CABAC(elem_offset[SIGNIFICANT_COEFF_FLAG] + inc);
948 static av_always_inline int significant_coeff_flag_decode_0(HEVCContext *s, int c_idx, int offset)
950 return GET_CABAC(elem_offset[SIGNIFICANT_COEFF_FLAG] + offset);
953 static av_always_inline int coeff_abs_level_greater1_flag_decode(HEVCContext *s, int c_idx, int inc)
959 return GET_CABAC(elem_offset[COEFF_ABS_LEVEL_GREATER1_FLAG] + inc);
962 static av_always_inline int coeff_abs_level_greater2_flag_decode(HEVCContext *s, int c_idx, int inc)
967 return GET_CABAC(elem_offset[COEFF_ABS_LEVEL_GREATER2_FLAG] + inc);
970 static av_always_inline int coeff_abs_level_remaining_decode(HEVCContext *s, int rc_rice_param)
974 int last_coeff_abs_level_remaining;
977 while (prefix < CABAC_MAX_BIN && get_cabac_bypass(&s->HEVClc->cc))
979 if (prefix == CABAC_MAX_BIN) {
980 av_log(s->avctx, AV_LOG_ERROR, "CABAC_MAX_BIN : %d\n", prefix);
984 for (i = 0; i < rc_rice_param; i++)
985 suffix = (suffix << 1) | get_cabac_bypass(&s->HEVClc->cc);
986 last_coeff_abs_level_remaining = (prefix << rc_rice_param) + suffix;
988 int prefix_minus3 = prefix - 3;
989 for (i = 0; i < prefix_minus3 + rc_rice_param; i++)
990 suffix = (suffix << 1) | get_cabac_bypass(&s->HEVClc->cc);
991 last_coeff_abs_level_remaining = (((1 << prefix_minus3) + 3 - 1)
992 << rc_rice_param) + suffix;
994 return last_coeff_abs_level_remaining;
997 static av_always_inline int coeff_sign_flag_decode(HEVCContext *s, uint8_t nb)
1002 for (i = 0; i < nb; i++)
1003 ret = (ret << 1) | get_cabac_bypass(&s->HEVClc->cc);
1007 void ff_hevc_hls_residual_coding(HEVCContext *s, int x0, int y0,
1008 int log2_trafo_size, enum ScanType scan_idx,
1011 #define GET_COORD(offset, n) \
1013 x_c = (x_cg << 2) + scan_x_off[n]; \
1014 y_c = (y_cg << 2) + scan_y_off[n]; \
1016 HEVCLocalContext *lc = s->HEVClc;
1017 int transform_skip_flag = 0;
1019 int last_significant_coeff_x, last_significant_coeff_y;
1023 int greater1_ctx = 1;
1025 int num_last_subset;
1026 int x_cg_last_sig, y_cg_last_sig;
1028 const uint8_t *scan_x_cg, *scan_y_cg, *scan_x_off, *scan_y_off;
1030 ptrdiff_t stride = s->frame->linesize[c_idx];
1031 int hshift = s->ps.sps->hshift[c_idx];
1032 int vshift = s->ps.sps->vshift[c_idx];
1033 uint8_t *dst = &s->frame->data[c_idx][(y0 >> vshift) * stride +
1034 ((x0 >> hshift) << s->ps.sps->pixel_shift)];
1035 int16_t *coeffs = (int16_t*)(c_idx ? lc->edge_emu_buffer2 : lc->edge_emu_buffer);
1036 uint8_t significant_coeff_group_flag[8][8] = {{0}};
1037 int explicit_rdpcm_flag = 0;
1038 int explicit_rdpcm_dir_flag;
1040 int trafo_size = 1 << log2_trafo_size;
1042 int qp,shift,add,scale,scale_m;
1043 static const uint8_t level_scale[] = { 40, 45, 51, 57, 64, 72 };
1044 const uint8_t *scale_matrix = NULL;
1046 int pred_mode_intra = (c_idx == 0) ? lc->tu.intra_pred_mode :
1047 lc->tu.intra_pred_mode_c;
1049 memset(coeffs, 0, trafo_size * trafo_size * sizeof(int16_t));
1051 // Derive QP for dequant
1052 if (!lc->cu.cu_transquant_bypass_flag) {
1053 static const int qp_c[] = { 29, 30, 31, 32, 33, 33, 34, 34, 35, 35, 36, 36, 37, 37 };
1054 static const uint8_t rem6[51 + 4 * 6 + 1] = {
1055 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2,
1056 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5,
1057 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3,
1058 4, 5, 0, 1, 2, 3, 4, 5, 0, 1
1061 static const uint8_t div6[51 + 4 * 6 + 1] = {
1062 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 3, 3, 3,
1063 3, 3, 3, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6,
1064 7, 7, 7, 7, 7, 7, 8, 8, 8, 8, 8, 8, 9, 9, 9, 9, 9, 9, 10, 10, 10, 10,
1065 10, 10, 11, 11, 11, 11, 11, 11, 12, 12
1067 int qp_y = lc->qp_y;
1069 if (s->ps.pps->transform_skip_enabled_flag &&
1070 log2_trafo_size <= s->ps.pps->log2_max_transform_skip_block_size) {
1071 transform_skip_flag = hevc_transform_skip_flag_decode(s, c_idx);
1075 qp = qp_y + s->ps.sps->qp_bd_offset;
1080 offset = s->ps.pps->cb_qp_offset + s->sh.slice_cb_qp_offset +
1081 lc->tu.cu_qp_offset_cb;
1083 offset = s->ps.pps->cr_qp_offset + s->sh.slice_cr_qp_offset +
1084 lc->tu.cu_qp_offset_cr;
1086 qp_i = av_clip(qp_y + offset, - s->ps.sps->qp_bd_offset, 57);
1087 if (s->ps.sps->chroma_format_idc == 1) {
1093 qp = qp_c[qp_i - 30];
1101 qp += s->ps.sps->qp_bd_offset;
1104 shift = s->ps.sps->bit_depth + log2_trafo_size - 5;
1105 add = 1 << (shift-1);
1106 scale = level_scale[rem6[qp]] << (div6[qp]);
1107 scale_m = 16; // default when no custom scaling lists.
1110 if (s->ps.sps->scaling_list_enable_flag && !(transform_skip_flag && log2_trafo_size > 2)) {
1111 const ScalingList *sl = s->ps.pps->scaling_list_data_present_flag ?
1112 &s->ps.pps->scaling_list : &s->ps.sps->scaling_list;
1113 int matrix_id = lc->cu.pred_mode != MODE_INTRA;
1115 matrix_id = 3 * matrix_id + c_idx;
1117 scale_matrix = sl->sl[log2_trafo_size - 2][matrix_id];
1118 if (log2_trafo_size >= 4)
1119 dc_scale = sl->sl_dc[log2_trafo_size - 4][matrix_id];
1128 if (lc->cu.pred_mode == MODE_INTER && s->ps.sps->explicit_rdpcm_enabled_flag &&
1129 (transform_skip_flag || lc->cu.cu_transquant_bypass_flag)) {
1130 explicit_rdpcm_flag = explicit_rdpcm_flag_decode(s, c_idx);
1131 if (explicit_rdpcm_flag) {
1132 explicit_rdpcm_dir_flag = explicit_rdpcm_dir_flag_decode(s, c_idx);
1136 last_significant_coeff_xy_prefix_decode(s, c_idx, log2_trafo_size,
1137 &last_significant_coeff_x, &last_significant_coeff_y);
1139 if (last_significant_coeff_x > 3) {
1140 int suffix = last_significant_coeff_suffix_decode(s, last_significant_coeff_x);
1141 last_significant_coeff_x = (1 << ((last_significant_coeff_x >> 1) - 1)) *
1142 (2 + (last_significant_coeff_x & 1)) +
1146 if (last_significant_coeff_y > 3) {
1147 int suffix = last_significant_coeff_suffix_decode(s, last_significant_coeff_y);
1148 last_significant_coeff_y = (1 << ((last_significant_coeff_y >> 1) - 1)) *
1149 (2 + (last_significant_coeff_y & 1)) +
1153 if (scan_idx == SCAN_VERT)
1154 FFSWAP(int, last_significant_coeff_x, last_significant_coeff_y);
1156 x_cg_last_sig = last_significant_coeff_x >> 2;
1157 y_cg_last_sig = last_significant_coeff_y >> 2;
1161 int last_x_c = last_significant_coeff_x & 3;
1162 int last_y_c = last_significant_coeff_y & 3;
1164 scan_x_off = ff_hevc_diag_scan4x4_x;
1165 scan_y_off = ff_hevc_diag_scan4x4_y;
1166 num_coeff = diag_scan4x4_inv[last_y_c][last_x_c];
1167 if (trafo_size == 4) {
1168 scan_x_cg = scan_1x1;
1169 scan_y_cg = scan_1x1;
1170 } else if (trafo_size == 8) {
1171 num_coeff += diag_scan2x2_inv[y_cg_last_sig][x_cg_last_sig] << 4;
1172 scan_x_cg = diag_scan2x2_x;
1173 scan_y_cg = diag_scan2x2_y;
1174 } else if (trafo_size == 16) {
1175 num_coeff += diag_scan4x4_inv[y_cg_last_sig][x_cg_last_sig] << 4;
1176 scan_x_cg = ff_hevc_diag_scan4x4_x;
1177 scan_y_cg = ff_hevc_diag_scan4x4_y;
1178 } else { // trafo_size == 32
1179 num_coeff += diag_scan8x8_inv[y_cg_last_sig][x_cg_last_sig] << 4;
1180 scan_x_cg = ff_hevc_diag_scan8x8_x;
1181 scan_y_cg = ff_hevc_diag_scan8x8_y;
1186 scan_x_cg = horiz_scan2x2_x;
1187 scan_y_cg = horiz_scan2x2_y;
1188 scan_x_off = horiz_scan4x4_x;
1189 scan_y_off = horiz_scan4x4_y;
1190 num_coeff = horiz_scan8x8_inv[last_significant_coeff_y][last_significant_coeff_x];
1192 default: //SCAN_VERT
1193 scan_x_cg = horiz_scan2x2_y;
1194 scan_y_cg = horiz_scan2x2_x;
1195 scan_x_off = horiz_scan4x4_y;
1196 scan_y_off = horiz_scan4x4_x;
1197 num_coeff = horiz_scan8x8_inv[last_significant_coeff_x][last_significant_coeff_y];
1201 num_last_subset = (num_coeff - 1) >> 4;
1203 for (i = num_last_subset; i >= 0; i--) {
1205 int x_cg, y_cg, x_c, y_c, pos;
1206 int implicit_non_zero_coeff = 0;
1207 int64_t trans_coeff_level;
1209 int offset = i << 4;
1212 uint8_t significant_coeff_flag_idx[16];
1213 uint8_t nb_significant_coeff_flag = 0;
1215 x_cg = scan_x_cg[i];
1216 y_cg = scan_y_cg[i];
1218 if ((i < num_last_subset) && (i > 0)) {
1220 if (x_cg < (1 << (log2_trafo_size - 2)) - 1)
1221 ctx_cg += significant_coeff_group_flag[x_cg + 1][y_cg];
1222 if (y_cg < (1 << (log2_trafo_size - 2)) - 1)
1223 ctx_cg += significant_coeff_group_flag[x_cg][y_cg + 1];
1225 significant_coeff_group_flag[x_cg][y_cg] =
1226 significant_coeff_group_flag_decode(s, c_idx, ctx_cg);
1227 implicit_non_zero_coeff = 1;
1229 significant_coeff_group_flag[x_cg][y_cg] =
1230 ((x_cg == x_cg_last_sig && y_cg == y_cg_last_sig) ||
1231 (x_cg == 0 && y_cg == 0));
1234 last_scan_pos = num_coeff - offset - 1;
1236 if (i == num_last_subset) {
1237 n_end = last_scan_pos - 1;
1238 significant_coeff_flag_idx[0] = last_scan_pos;
1239 nb_significant_coeff_flag = 1;
1244 if (x_cg < ((1 << log2_trafo_size) - 1) >> 2)
1245 prev_sig = !!significant_coeff_group_flag[x_cg + 1][y_cg];
1246 if (y_cg < ((1 << log2_trafo_size) - 1) >> 2)
1247 prev_sig += (!!significant_coeff_group_flag[x_cg][y_cg + 1] << 1);
1249 if (significant_coeff_group_flag[x_cg][y_cg] && n_end >= 0) {
1250 static const uint8_t ctx_idx_map[] = {
1251 0, 1, 4, 5, 2, 3, 4, 5, 6, 6, 8, 8, 7, 7, 8, 8, // log2_trafo_size == 2
1252 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, // prev_sig == 0
1253 2, 2, 2, 2, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, // prev_sig == 1
1254 2, 1, 0, 0, 2, 1, 0, 0, 2, 1, 0, 0, 2, 1, 0, 0, // prev_sig == 2
1255 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2 // default
1257 const uint8_t *ctx_idx_map_p;
1259 if (s->ps.sps->transform_skip_context_enabled_flag &&
1260 (transform_skip_flag || lc->cu.cu_transquant_bypass_flag)) {
1261 ctx_idx_map_p = (uint8_t*) &ctx_idx_map[4 * 16];
1265 scf_offset = 14 + 27;
1270 if (log2_trafo_size == 2) {
1271 ctx_idx_map_p = (uint8_t*) &ctx_idx_map[0];
1273 ctx_idx_map_p = (uint8_t*) &ctx_idx_map[(prev_sig + 1) << 4];
1275 if ((x_cg > 0 || y_cg > 0))
1277 if (log2_trafo_size == 3) {
1278 scf_offset += (scan_idx == SCAN_DIAG) ? 9 : 15;
1283 if (log2_trafo_size == 3)
1290 for (n = n_end; n > 0; n--) {
1291 x_c = scan_x_off[n];
1292 y_c = scan_y_off[n];
1293 if (significant_coeff_flag_decode(s, x_c, y_c, scf_offset, ctx_idx_map_p)) {
1294 significant_coeff_flag_idx[nb_significant_coeff_flag] = n;
1295 nb_significant_coeff_flag++;
1296 implicit_non_zero_coeff = 0;
1299 if (implicit_non_zero_coeff == 0) {
1300 if (s->ps.sps->transform_skip_context_enabled_flag &&
1301 (transform_skip_flag || lc->cu.cu_transquant_bypass_flag)) {
1305 scf_offset = 16 + 27;
1314 scf_offset = 2 + scf_offset;
1317 if (significant_coeff_flag_decode_0(s, c_idx, scf_offset) == 1) {
1318 significant_coeff_flag_idx[nb_significant_coeff_flag] = 0;
1319 nb_significant_coeff_flag++;
1322 significant_coeff_flag_idx[nb_significant_coeff_flag] = 0;
1323 nb_significant_coeff_flag++;
1327 n_end = nb_significant_coeff_flag;
1331 int first_nz_pos_in_cg;
1332 int last_nz_pos_in_cg;
1333 int c_rice_param = 0;
1334 int first_greater1_coeff_idx = -1;
1335 uint8_t coeff_abs_level_greater1_flag[8];
1336 uint16_t coeff_sign_flag;
1342 // initialize first elem of coeff_bas_level_greater1_flag
1343 int ctx_set = (i > 0 && c_idx == 0) ? 2 : 0;
1345 if (s->ps.sps->persistent_rice_adaptation_enabled_flag) {
1346 if (!transform_skip_flag && !lc->cu.cu_transquant_bypass_flag)
1347 sb_type = 2 * (c_idx == 0 ? 1 : 0);
1349 sb_type = 2 * (c_idx == 0 ? 1 : 0) + 1;
1350 c_rice_param = lc->stat_coeff[sb_type] / 4;
1353 if (!(i == num_last_subset) && greater1_ctx == 0)
1356 last_nz_pos_in_cg = significant_coeff_flag_idx[0];
1358 for (m = 0; m < (n_end > 8 ? 8 : n_end); m++) {
1359 int inc = (ctx_set << 2) + greater1_ctx;
1360 coeff_abs_level_greater1_flag[m] =
1361 coeff_abs_level_greater1_flag_decode(s, c_idx, inc);
1362 if (coeff_abs_level_greater1_flag[m]) {
1364 if (first_greater1_coeff_idx == -1)
1365 first_greater1_coeff_idx = m;
1366 } else if (greater1_ctx > 0 && greater1_ctx < 3) {
1370 first_nz_pos_in_cg = significant_coeff_flag_idx[n_end - 1];
1372 if (lc->cu.cu_transquant_bypass_flag ||
1373 (lc->cu.pred_mode == MODE_INTRA &&
1374 s->ps.sps->implicit_rdpcm_enabled_flag && transform_skip_flag &&
1375 (pred_mode_intra == 10 || pred_mode_intra == 26 )) ||
1376 explicit_rdpcm_flag)
1379 sign_hidden = (last_nz_pos_in_cg - first_nz_pos_in_cg >= 4);
1381 if (first_greater1_coeff_idx != -1) {
1382 coeff_abs_level_greater1_flag[first_greater1_coeff_idx] += coeff_abs_level_greater2_flag_decode(s, c_idx, ctx_set);
1384 if (!s->ps.pps->sign_data_hiding_flag || !sign_hidden ) {
1385 coeff_sign_flag = coeff_sign_flag_decode(s, nb_significant_coeff_flag) << (16 - nb_significant_coeff_flag);
1387 coeff_sign_flag = coeff_sign_flag_decode(s, nb_significant_coeff_flag - 1) << (16 - (nb_significant_coeff_flag - 1));
1390 for (m = 0; m < n_end; m++) {
1391 n = significant_coeff_flag_idx[m];
1392 GET_COORD(offset, n);
1394 trans_coeff_level = 1 + coeff_abs_level_greater1_flag[m];
1395 if (trans_coeff_level == ((m == first_greater1_coeff_idx) ? 3 : 2)) {
1396 int last_coeff_abs_level_remaining = coeff_abs_level_remaining_decode(s, c_rice_param);
1398 trans_coeff_level += last_coeff_abs_level_remaining;
1399 if (trans_coeff_level > (3 << c_rice_param))
1400 c_rice_param = s->ps.sps->persistent_rice_adaptation_enabled_flag ? c_rice_param + 1 : FFMIN(c_rice_param + 1, 4);
1401 if (s->ps.sps->persistent_rice_adaptation_enabled_flag && !rice_init) {
1402 int c_rice_p_init = lc->stat_coeff[sb_type] / 4;
1403 if (last_coeff_abs_level_remaining >= (3 << c_rice_p_init))
1404 lc->stat_coeff[sb_type]++;
1405 else if (2 * last_coeff_abs_level_remaining < (1 << c_rice_p_init))
1406 if (lc->stat_coeff[sb_type] > 0)
1407 lc->stat_coeff[sb_type]--;
1412 int last_coeff_abs_level_remaining = coeff_abs_level_remaining_decode(s, c_rice_param);
1414 trans_coeff_level = 1 + last_coeff_abs_level_remaining;
1415 if (trans_coeff_level > (3 << c_rice_param))
1416 c_rice_param = s->ps.sps->persistent_rice_adaptation_enabled_flag ? c_rice_param + 1 : FFMIN(c_rice_param + 1, 4);
1417 if (s->ps.sps->persistent_rice_adaptation_enabled_flag && !rice_init) {
1418 int c_rice_p_init = lc->stat_coeff[sb_type] / 4;
1419 if (last_coeff_abs_level_remaining >= (3 << c_rice_p_init))
1420 lc->stat_coeff[sb_type]++;
1421 else if (2 * last_coeff_abs_level_remaining < (1 << c_rice_p_init))
1422 if (lc->stat_coeff[sb_type] > 0)
1423 lc->stat_coeff[sb_type]--;
1427 if (s->ps.pps->sign_data_hiding_flag && sign_hidden) {
1428 sum_abs += trans_coeff_level;
1429 if (n == first_nz_pos_in_cg && (sum_abs&1))
1430 trans_coeff_level = -trans_coeff_level;
1432 if (coeff_sign_flag >> 15)
1433 trans_coeff_level = -trans_coeff_level;
1434 coeff_sign_flag <<= 1;
1435 if(!lc->cu.cu_transquant_bypass_flag) {
1436 if (s->ps.sps->scaling_list_enable_flag && !(transform_skip_flag && log2_trafo_size > 2)) {
1437 if(y_c || x_c || log2_trafo_size < 4) {
1438 switch(log2_trafo_size) {
1439 case 3: pos = (y_c << 3) + x_c; break;
1440 case 4: pos = ((y_c >> 1) << 3) + (x_c >> 1); break;
1441 case 5: pos = ((y_c >> 2) << 3) + (x_c >> 2); break;
1442 default: pos = (y_c << 2) + x_c; break;
1444 scale_m = scale_matrix[pos];
1449 trans_coeff_level = (trans_coeff_level * (int64_t)scale * (int64_t)scale_m + add) >> shift;
1450 if(trans_coeff_level < 0) {
1451 if((~trans_coeff_level) & 0xFffffffffff8000)
1452 trans_coeff_level = -32768;
1454 if(trans_coeff_level & 0xffffffffffff8000)
1455 trans_coeff_level = 32767;
1458 coeffs[y_c * trafo_size + x_c] = trans_coeff_level;
1463 if (lc->cu.cu_transquant_bypass_flag) {
1464 if (explicit_rdpcm_flag || (s->ps.sps->implicit_rdpcm_enabled_flag &&
1465 (pred_mode_intra == 10 || pred_mode_intra == 26))) {
1466 int mode = s->ps.sps->implicit_rdpcm_enabled_flag ? (pred_mode_intra == 26) : explicit_rdpcm_dir_flag;
1468 s->hevcdsp.transform_rdpcm(coeffs, log2_trafo_size, mode);
1471 if (transform_skip_flag) {
1472 int rot = s->ps.sps->transform_skip_rotation_enabled_flag &&
1473 log2_trafo_size == 2 &&
1474 lc->cu.pred_mode == MODE_INTRA;
1476 for (i = 0; i < 8; i++)
1477 FFSWAP(int16_t, coeffs[i], coeffs[16 - i - 1]);
1480 s->hevcdsp.dequant(coeffs, log2_trafo_size);
1482 if (explicit_rdpcm_flag || (s->ps.sps->implicit_rdpcm_enabled_flag &&
1483 lc->cu.pred_mode == MODE_INTRA &&
1484 (pred_mode_intra == 10 || pred_mode_intra == 26))) {
1485 int mode = explicit_rdpcm_flag ? explicit_rdpcm_dir_flag : (pred_mode_intra == 26);
1487 s->hevcdsp.transform_rdpcm(coeffs, log2_trafo_size, mode);
1489 } else if (lc->cu.pred_mode == MODE_INTRA && c_idx == 0 && log2_trafo_size == 2) {
1490 s->hevcdsp.transform_4x4_luma(coeffs);
1492 int max_xy = FFMAX(last_significant_coeff_x, last_significant_coeff_y);
1494 s->hevcdsp.idct_dc[log2_trafo_size - 2](coeffs);
1496 int col_limit = last_significant_coeff_x + last_significant_coeff_y + 4;
1498 col_limit = FFMIN(4, col_limit);
1499 else if (max_xy < 8)
1500 col_limit = FFMIN(8, col_limit);
1501 else if (max_xy < 12)
1502 col_limit = FFMIN(24, col_limit);
1503 s->hevcdsp.idct[log2_trafo_size - 2](coeffs, col_limit);
1507 if (lc->tu.cross_pf) {
1508 int16_t *coeffs_y = (int16_t*)lc->edge_emu_buffer;
1510 for (i = 0; i < (trafo_size * trafo_size); i++) {
1511 coeffs[i] = coeffs[i] + ((lc->tu.res_scale_val * coeffs_y[i]) >> 3);
1514 s->hevcdsp.add_residual[log2_trafo_size-2](dst, coeffs, stride);
1517 void ff_hevc_hls_mvd_coding(HEVCContext *s, int x0, int y0, int log2_cb_size)
1519 HEVCLocalContext *lc = s->HEVClc;
1520 int x = abs_mvd_greater0_flag_decode(s);
1521 int y = abs_mvd_greater0_flag_decode(s);
1524 x += abs_mvd_greater1_flag_decode(s);
1526 y += abs_mvd_greater1_flag_decode(s);
1529 case 2: lc->pu.mvd.x = mvd_decode(s); break;
1530 case 1: lc->pu.mvd.x = mvd_sign_flag_decode(s); break;
1531 case 0: lc->pu.mvd.x = 0; break;
1535 case 2: lc->pu.mvd.y = mvd_decode(s); break;
1536 case 1: lc->pu.mvd.y = mvd_sign_flag_decode(s); break;
1537 case 0: lc->pu.mvd.y = 0; break;