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"
30 #define CABAC_MAX_BIN 31
33 * number of bin by SyntaxElement.
35 av_unused static const int8_t num_bins_in_se[] = {
39 0, // sao_band_position
42 0, // end_of_slice_flag
43 3, // split_coding_unit_flag
44 1, // cu_transquant_bypass_flag
50 1, // prev_intra_luma_pred_mode
52 0, // rem_intra_luma_pred_mode
53 2, // intra_chroma_pred_mode
59 2, // abs_mvd_greater0_flag
60 2, // abs_mvd_greater1_flag
64 1, // no_residual_data_flag
65 3, // split_transform_flag
68 2, // transform_skip_flag[][]
69 2, // explicit_rdpcm_flag[][]
70 2, // explicit_rdpcm_dir_flag[][]
71 18, // last_significant_coeff_x_prefix
72 18, // last_significant_coeff_y_prefix
73 0, // last_significant_coeff_x_suffix
74 0, // last_significant_coeff_y_suffix
75 4, // significant_coeff_group_flag
76 44, // significant_coeff_flag
77 24, // coeff_abs_level_greater1_flag
78 6, // coeff_abs_level_greater2_flag
79 0, // coeff_abs_level_remaining
81 8, // log2_res_scale_abs
82 2, // res_scale_sign_flag
83 1, // cu_chroma_qp_offset_flag
84 1, // cu_chroma_qp_offset_idx
88 * Offset to ctxIdx 0 in init_values and states, indexed by SyntaxElement.
90 static const int elem_offset[sizeof(num_bins_in_se)] = {
94 2, // sao_band_position
97 2, // end_of_slice_flag
98 2, // split_coding_unit_flag
99 5, // cu_transquant_bypass_flag
105 17, // prev_intra_luma_pred_mode
107 18, // rem_intra_luma_pred_mode
108 18, // intra_chroma_pred_mode
111 22, // inter_pred_idc
114 31, // abs_mvd_greater0_flag
115 33, // abs_mvd_greater1_flag
116 35, // abs_mvd_minus2
119 36, // no_residual_data_flag
120 37, // split_transform_flag
122 42, // cbf_cb, cbf_cr
123 46, // transform_skip_flag[][]
124 48, // explicit_rdpcm_flag[][]
125 50, // explicit_rdpcm_dir_flag[][]
126 52, // last_significant_coeff_x_prefix
127 70, // last_significant_coeff_y_prefix
128 88, // last_significant_coeff_x_suffix
129 88, // last_significant_coeff_y_suffix
130 88, // significant_coeff_group_flag
131 92, // significant_coeff_flag
132 136, // coeff_abs_level_greater1_flag
133 160, // coeff_abs_level_greater2_flag
134 166, // coeff_abs_level_remaining
135 166, // coeff_sign_flag
136 166, // log2_res_scale_abs
137 174, // res_scale_sign_flag
138 176, // cu_chroma_qp_offset_flag
139 177, // cu_chroma_qp_offset_idx
144 * Indexed by init_type
146 static const uint8_t init_values[3][HEVC_CONTEXTS] = {
151 // split_coding_unit_flag
153 // cu_transquant_bypass_flag
163 // prev_intra_luma_pred_mode
165 // intra_chroma_pred_mode
172 CNU, CNU, CNU, CNU, CNU,
177 // abs_mvd_greater1_flag
179 // abs_mvd_greater1_flag
183 // no_residual_data_flag
185 // split_transform_flag
191 // transform_skip_flag
193 // explicit_rdpcm_flag
195 // explicit_rdpcm_dir_flag
197 // last_significant_coeff_x_prefix
198 110, 110, 124, 125, 140, 153, 125, 127, 140, 109, 111, 143, 127, 111,
200 // last_significant_coeff_y_prefix
201 110, 110, 124, 125, 140, 153, 125, 127, 140, 109, 111, 143, 127, 111,
203 // significant_coeff_group_flag
205 // significant_coeff_flag
206 111, 111, 125, 110, 110, 94, 124, 108, 124, 107, 125, 141, 179, 153,
207 125, 107, 125, 141, 179, 153, 125, 107, 125, 141, 179, 153, 125, 140,
208 139, 182, 182, 152, 136, 152, 136, 153, 136, 139, 111, 136, 139, 111,
210 // coeff_abs_level_greater1_flag
211 140, 92, 137, 138, 140, 152, 138, 139, 153, 74, 149, 92, 139, 107,
212 122, 152, 140, 179, 166, 182, 140, 227, 122, 197,
213 // coeff_abs_level_greater2_flag
214 138, 153, 136, 167, 152, 152,
215 // log2_res_scale_abs
216 154, 154, 154, 154, 154, 154, 154, 154,
217 // res_scale_sign_flag
219 // cu_chroma_qp_offset_flag
221 // cu_chroma_qp_offset_idx
228 // split_coding_unit_flag
230 // cu_transquant_bypass_flag
240 // prev_intra_luma_pred_mode
242 // intra_chroma_pred_mode
254 // abs_mvd_greater1_flag
256 // abs_mvd_greater1_flag
260 // no_residual_data_flag
262 // split_transform_flag
268 // transform_skip_flag
270 // explicit_rdpcm_flag
272 // explicit_rdpcm_dir_flag
274 // last_significant_coeff_x_prefix
275 125, 110, 94, 110, 95, 79, 125, 111, 110, 78, 110, 111, 111, 95,
277 // last_significant_coeff_y_prefix
278 125, 110, 94, 110, 95, 79, 125, 111, 110, 78, 110, 111, 111, 95,
280 // significant_coeff_group_flag
282 // significant_coeff_flag
283 155, 154, 139, 153, 139, 123, 123, 63, 153, 166, 183, 140, 136, 153,
284 154, 166, 183, 140, 136, 153, 154, 166, 183, 140, 136, 153, 154, 170,
285 153, 123, 123, 107, 121, 107, 121, 167, 151, 183, 140, 151, 183, 140,
287 // coeff_abs_level_greater1_flag
288 154, 196, 196, 167, 154, 152, 167, 182, 182, 134, 149, 136, 153, 121,
289 136, 137, 169, 194, 166, 167, 154, 167, 137, 182,
290 // coeff_abs_level_greater2_flag
291 107, 167, 91, 122, 107, 167,
292 // log2_res_scale_abs
293 154, 154, 154, 154, 154, 154, 154, 154,
294 // res_scale_sign_flag
296 // cu_chroma_qp_offset_flag
298 // cu_chroma_qp_offset_idx
305 // split_coding_unit_flag
307 // cu_transquant_bypass_flag
317 // prev_intra_luma_pred_mode
319 // intra_chroma_pred_mode
331 // abs_mvd_greater1_flag
333 // abs_mvd_greater1_flag
337 // no_residual_data_flag
339 // split_transform_flag
345 // transform_skip_flag
347 // explicit_rdpcm_flag
349 // explicit_rdpcm_dir_flag
351 // last_significant_coeff_x_prefix
352 125, 110, 124, 110, 95, 94, 125, 111, 111, 79, 125, 126, 111, 111,
354 // last_significant_coeff_y_prefix
355 125, 110, 124, 110, 95, 94, 125, 111, 111, 79, 125, 126, 111, 111,
357 // significant_coeff_group_flag
359 // significant_coeff_flag
360 170, 154, 139, 153, 139, 123, 123, 63, 124, 166, 183, 140, 136, 153,
361 154, 166, 183, 140, 136, 153, 154, 166, 183, 140, 136, 153, 154, 170,
362 153, 138, 138, 122, 121, 122, 121, 167, 151, 183, 140, 151, 183, 140,
364 // coeff_abs_level_greater1_flag
365 154, 196, 167, 167, 154, 152, 167, 182, 182, 134, 149, 136, 153, 121,
366 136, 122, 169, 208, 166, 167, 154, 152, 167, 182,
367 // coeff_abs_level_greater2_flag
368 107, 167, 91, 107, 107, 167,
369 // log2_res_scale_abs
370 154, 154, 154, 154, 154, 154, 154, 154,
371 // res_scale_sign_flag
373 // cu_chroma_qp_offset_flag
375 // cu_chroma_qp_offset_idx
380 static const uint8_t scan_1x1[1] = {
384 static const uint8_t horiz_scan2x2_x[4] = {
388 static const uint8_t horiz_scan2x2_y[4] = {
392 static const uint8_t horiz_scan4x4_x[16] = {
399 static const uint8_t horiz_scan4x4_y[16] = {
406 static const uint8_t horiz_scan8x8_inv[8][8] = {
407 { 0, 1, 2, 3, 16, 17, 18, 19, },
408 { 4, 5, 6, 7, 20, 21, 22, 23, },
409 { 8, 9, 10, 11, 24, 25, 26, 27, },
410 { 12, 13, 14, 15, 28, 29, 30, 31, },
411 { 32, 33, 34, 35, 48, 49, 50, 51, },
412 { 36, 37, 38, 39, 52, 53, 54, 55, },
413 { 40, 41, 42, 43, 56, 57, 58, 59, },
414 { 44, 45, 46, 47, 60, 61, 62, 63, },
417 static const uint8_t diag_scan2x2_x[4] = {
421 static const uint8_t diag_scan2x2_y[4] = {
425 static const uint8_t diag_scan2x2_inv[2][2] = {
430 static const uint8_t diag_scan4x4_inv[4][4] = {
437 static const uint8_t diag_scan8x8_inv[8][8] = {
438 { 0, 2, 5, 9, 14, 20, 27, 35, },
439 { 1, 4, 8, 13, 19, 26, 34, 42, },
440 { 3, 7, 12, 18, 25, 33, 41, 48, },
441 { 6, 11, 17, 24, 32, 40, 47, 53, },
442 { 10, 16, 23, 31, 39, 46, 52, 57, },
443 { 15, 22, 30, 38, 45, 51, 56, 60, },
444 { 21, 29, 37, 44, 50, 55, 59, 62, },
445 { 28, 36, 43, 49, 54, 58, 61, 63, },
448 void ff_hevc_save_states(HEVCContext *s, int ctb_addr_ts)
450 if (s->ps.pps->entropy_coding_sync_enabled_flag &&
451 (ctb_addr_ts % s->ps.sps->ctb_width == 2 ||
452 (s->ps.sps->ctb_width == 2 &&
453 ctb_addr_ts % s->ps.sps->ctb_width == 0))) {
454 memcpy(s->cabac_state, s->HEVClc->cabac_state, HEVC_CONTEXTS);
458 static void load_states(HEVCContext *s)
460 memcpy(s->HEVClc->cabac_state, s->cabac_state, HEVC_CONTEXTS);
463 static void cabac_reinit(HEVCLocalContext *lc)
465 skip_bytes(&lc->cc, 0);
468 static void cabac_init_decoder(HEVCContext *s)
470 GetBitContext *gb = &s->HEVClc->gb;
473 ff_init_cabac_decoder(&s->HEVClc->cc,
474 gb->buffer + get_bits_count(gb) / 8,
475 (get_bits_left(gb) + 7) / 8);
478 static void cabac_init_state(HEVCContext *s)
480 int init_type = 2 - s->sh.slice_type;
483 if (s->sh.cabac_init_flag && s->sh.slice_type != I_SLICE)
486 for (i = 0; i < HEVC_CONTEXTS; i++) {
487 int init_value = init_values[init_type][i];
488 int m = (init_value >> 4) * 5 - 45;
489 int n = ((init_value & 15) << 3) - 16;
490 int pre = 2 * (((m * av_clip(s->sh.slice_qp, 0, 51)) >> 4) + n) - 127;
494 pre = 124 + (pre & 1);
495 s->HEVClc->cabac_state[i] = pre;
498 for (i = 0; i < 4; i++)
499 s->HEVClc->stat_coeff[i] = 0;
502 void ff_hevc_cabac_init(HEVCContext *s, int ctb_addr_ts)
504 if (ctb_addr_ts == s->ps.pps->ctb_addr_rs_to_ts[s->sh.slice_ctb_addr_rs]) {
505 cabac_init_decoder(s);
506 if (s->sh.dependent_slice_segment_flag == 0 ||
507 (s->ps.pps->tiles_enabled_flag &&
508 s->ps.pps->tile_id[ctb_addr_ts] != s->ps.pps->tile_id[ctb_addr_ts - 1]))
511 if (!s->sh.first_slice_in_pic_flag &&
512 s->ps.pps->entropy_coding_sync_enabled_flag) {
513 if (ctb_addr_ts % s->ps.sps->ctb_width == 0) {
514 if (s->ps.sps->ctb_width == 1)
516 else if (s->sh.dependent_slice_segment_flag == 1)
521 if (s->ps.pps->tiles_enabled_flag &&
522 s->ps.pps->tile_id[ctb_addr_ts] != s->ps.pps->tile_id[ctb_addr_ts - 1]) {
523 if (s->threads_number == 1)
524 cabac_reinit(s->HEVClc);
526 cabac_init_decoder(s);
529 if (s->ps.pps->entropy_coding_sync_enabled_flag) {
530 if (ctb_addr_ts % s->ps.sps->ctb_width == 0) {
531 get_cabac_terminate(&s->HEVClc->cc);
532 if (s->threads_number == 1)
533 cabac_reinit(s->HEVClc);
535 cabac_init_decoder(s);
537 if (s->ps.sps->ctb_width == 1)
546 #define GET_CABAC(ctx) get_cabac(&s->HEVClc->cc, &s->HEVClc->cabac_state[ctx])
548 int ff_hevc_sao_merge_flag_decode(HEVCContext *s)
550 return GET_CABAC(elem_offset[SAO_MERGE_FLAG]);
553 int ff_hevc_sao_type_idx_decode(HEVCContext *s)
555 if (!GET_CABAC(elem_offset[SAO_TYPE_IDX]))
558 if (!get_cabac_bypass(&s->HEVClc->cc))
563 int ff_hevc_sao_band_position_decode(HEVCContext *s)
566 int value = get_cabac_bypass(&s->HEVClc->cc);
568 for (i = 0; i < 4; i++)
569 value = (value << 1) | get_cabac_bypass(&s->HEVClc->cc);
573 int ff_hevc_sao_offset_abs_decode(HEVCContext *s)
576 int length = (1 << (FFMIN(s->ps.sps->bit_depth, 10) - 5)) - 1;
578 while (i < length && get_cabac_bypass(&s->HEVClc->cc))
583 int ff_hevc_sao_offset_sign_decode(HEVCContext *s)
585 return get_cabac_bypass(&s->HEVClc->cc);
588 int ff_hevc_sao_eo_class_decode(HEVCContext *s)
590 int ret = get_cabac_bypass(&s->HEVClc->cc) << 1;
591 ret |= get_cabac_bypass(&s->HEVClc->cc);
595 int ff_hevc_end_of_slice_flag_decode(HEVCContext *s)
597 return get_cabac_terminate(&s->HEVClc->cc);
600 int ff_hevc_cu_transquant_bypass_flag_decode(HEVCContext *s)
602 return GET_CABAC(elem_offset[CU_TRANSQUANT_BYPASS_FLAG]);
605 int ff_hevc_skip_flag_decode(HEVCContext *s, int x0, int y0, int x_cb, int y_cb)
607 int min_cb_width = s->ps.sps->min_cb_width;
609 int x0b = av_mod_uintp2(x0, s->ps.sps->log2_ctb_size);
610 int y0b = av_mod_uintp2(y0, s->ps.sps->log2_ctb_size);
612 if (s->HEVClc->ctb_left_flag || x0b)
613 inc = !!SAMPLE_CTB(s->skip_flag, x_cb - 1, y_cb);
614 if (s->HEVClc->ctb_up_flag || y0b)
615 inc += !!SAMPLE_CTB(s->skip_flag, x_cb, y_cb - 1);
617 return GET_CABAC(elem_offset[SKIP_FLAG] + inc);
620 int ff_hevc_cu_qp_delta_abs(HEVCContext *s)
626 while (prefix_val < 5 && GET_CABAC(elem_offset[CU_QP_DELTA] + inc)) {
630 if (prefix_val >= 5) {
632 while (k < CABAC_MAX_BIN && get_cabac_bypass(&s->HEVClc->cc)) {
633 suffix_val += 1 << k;
636 if (k == CABAC_MAX_BIN)
637 av_log(s->avctx, AV_LOG_ERROR, "CABAC_MAX_BIN : %d\n", k);
640 suffix_val += get_cabac_bypass(&s->HEVClc->cc) << k;
642 return prefix_val + suffix_val;
645 int ff_hevc_cu_qp_delta_sign_flag(HEVCContext *s)
647 return get_cabac_bypass(&s->HEVClc->cc);
650 int ff_hevc_cu_chroma_qp_offset_flag(HEVCContext *s)
652 return GET_CABAC(elem_offset[CU_CHROMA_QP_OFFSET_FLAG]);
655 int ff_hevc_cu_chroma_qp_offset_idx(HEVCContext *s)
657 int c_max= FFMAX(5, s->ps.pps->chroma_qp_offset_list_len_minus1);
660 while (i < c_max && GET_CABAC(elem_offset[CU_CHROMA_QP_OFFSET_IDX]))
666 int ff_hevc_pred_mode_decode(HEVCContext *s)
668 return GET_CABAC(elem_offset[PRED_MODE_FLAG]);
671 int ff_hevc_split_coding_unit_flag_decode(HEVCContext *s, int ct_depth, int x0, int y0)
673 int inc = 0, depth_left = 0, depth_top = 0;
674 int x0b = av_mod_uintp2(x0, s->ps.sps->log2_ctb_size);
675 int y0b = av_mod_uintp2(y0, s->ps.sps->log2_ctb_size);
676 int x_cb = x0 >> s->ps.sps->log2_min_cb_size;
677 int y_cb = y0 >> s->ps.sps->log2_min_cb_size;
679 if (s->HEVClc->ctb_left_flag || x0b)
680 depth_left = s->tab_ct_depth[(y_cb) * s->ps.sps->min_cb_width + x_cb - 1];
681 if (s->HEVClc->ctb_up_flag || y0b)
682 depth_top = s->tab_ct_depth[(y_cb - 1) * s->ps.sps->min_cb_width + x_cb];
684 inc += (depth_left > ct_depth);
685 inc += (depth_top > ct_depth);
687 return GET_CABAC(elem_offset[SPLIT_CODING_UNIT_FLAG] + inc);
690 int ff_hevc_part_mode_decode(HEVCContext *s, int log2_cb_size)
692 if (GET_CABAC(elem_offset[PART_MODE])) // 1
694 if (log2_cb_size == s->ps.sps->log2_min_cb_size) {
695 if (s->HEVClc->cu.pred_mode == MODE_INTRA) // 0
697 if (GET_CABAC(elem_offset[PART_MODE] + 1)) // 01
699 if (log2_cb_size == 3) // 00
701 if (GET_CABAC(elem_offset[PART_MODE] + 2)) // 001
703 return PART_NxN; // 000
706 if (!s->ps.sps->amp_enabled_flag) {
707 if (GET_CABAC(elem_offset[PART_MODE] + 1)) // 01
712 if (GET_CABAC(elem_offset[PART_MODE] + 1)) { // 01X, 01XX
713 if (GET_CABAC(elem_offset[PART_MODE] + 3)) // 011
715 if (get_cabac_bypass(&s->HEVClc->cc)) // 0101
717 return PART_2NxnU; // 0100
720 if (GET_CABAC(elem_offset[PART_MODE] + 3)) // 001
722 if (get_cabac_bypass(&s->HEVClc->cc)) // 0001
724 return PART_nLx2N; // 0000
727 int ff_hevc_pcm_flag_decode(HEVCContext *s)
729 return get_cabac_terminate(&s->HEVClc->cc);
732 int ff_hevc_prev_intra_luma_pred_flag_decode(HEVCContext *s)
734 return GET_CABAC(elem_offset[PREV_INTRA_LUMA_PRED_FLAG]);
737 int ff_hevc_mpm_idx_decode(HEVCContext *s)
740 while (i < 2 && get_cabac_bypass(&s->HEVClc->cc))
745 int ff_hevc_rem_intra_luma_pred_mode_decode(HEVCContext *s)
748 int value = get_cabac_bypass(&s->HEVClc->cc);
750 for (i = 0; i < 4; i++)
751 value = (value << 1) | get_cabac_bypass(&s->HEVClc->cc);
755 int ff_hevc_intra_chroma_pred_mode_decode(HEVCContext *s)
758 if (!GET_CABAC(elem_offset[INTRA_CHROMA_PRED_MODE]))
761 ret = get_cabac_bypass(&s->HEVClc->cc) << 1;
762 ret |= get_cabac_bypass(&s->HEVClc->cc);
766 int ff_hevc_merge_idx_decode(HEVCContext *s)
768 int i = GET_CABAC(elem_offset[MERGE_IDX]);
771 while (i < s->sh.max_num_merge_cand-1 && get_cabac_bypass(&s->HEVClc->cc))
777 int ff_hevc_merge_flag_decode(HEVCContext *s)
779 return GET_CABAC(elem_offset[MERGE_FLAG]);
782 int ff_hevc_inter_pred_idc_decode(HEVCContext *s, int nPbW, int nPbH)
784 if (nPbW + nPbH == 12)
785 return GET_CABAC(elem_offset[INTER_PRED_IDC] + 4);
786 if (GET_CABAC(elem_offset[INTER_PRED_IDC] + s->HEVClc->ct_depth))
789 return GET_CABAC(elem_offset[INTER_PRED_IDC] + 4);
792 int ff_hevc_ref_idx_lx_decode(HEVCContext *s, int num_ref_idx_lx)
795 int max = num_ref_idx_lx - 1;
796 int max_ctx = FFMIN(max, 2);
798 while (i < max_ctx && GET_CABAC(elem_offset[REF_IDX_L0] + i))
801 while (i < max && get_cabac_bypass(&s->HEVClc->cc))
808 int ff_hevc_mvp_lx_flag_decode(HEVCContext *s)
810 return GET_CABAC(elem_offset[MVP_LX_FLAG]);
813 int ff_hevc_no_residual_syntax_flag_decode(HEVCContext *s)
815 return GET_CABAC(elem_offset[NO_RESIDUAL_DATA_FLAG]);
818 static av_always_inline int abs_mvd_greater0_flag_decode(HEVCContext *s)
820 return GET_CABAC(elem_offset[ABS_MVD_GREATER0_FLAG]);
823 static av_always_inline int abs_mvd_greater1_flag_decode(HEVCContext *s)
825 return GET_CABAC(elem_offset[ABS_MVD_GREATER1_FLAG] + 1);
828 static av_always_inline int mvd_decode(HEVCContext *s)
833 while (k < CABAC_MAX_BIN && get_cabac_bypass(&s->HEVClc->cc)) {
837 if (k == CABAC_MAX_BIN) {
838 av_log(s->avctx, AV_LOG_ERROR, "CABAC_MAX_BIN : %d\n", k);
842 ret += get_cabac_bypass(&s->HEVClc->cc) << k;
843 return get_cabac_bypass_sign(&s->HEVClc->cc, -ret);
846 static av_always_inline int mvd_sign_flag_decode(HEVCContext *s)
848 return get_cabac_bypass_sign(&s->HEVClc->cc, -1);
851 int ff_hevc_split_transform_flag_decode(HEVCContext *s, int log2_trafo_size)
853 return GET_CABAC(elem_offset[SPLIT_TRANSFORM_FLAG] + 5 - log2_trafo_size);
856 int ff_hevc_cbf_cb_cr_decode(HEVCContext *s, int trafo_depth)
858 return GET_CABAC(elem_offset[CBF_CB_CR] + trafo_depth);
861 int ff_hevc_cbf_luma_decode(HEVCContext *s, int trafo_depth)
863 return GET_CABAC(elem_offset[CBF_LUMA] + !trafo_depth);
866 static int hevc_transform_skip_flag_decode(HEVCContext *s, int c_idx)
868 return GET_CABAC(elem_offset[TRANSFORM_SKIP_FLAG] + !!c_idx);
871 static int explicit_rdpcm_flag_decode(HEVCContext *s, int c_idx)
873 return GET_CABAC(elem_offset[EXPLICIT_RDPCM_FLAG] + !!c_idx);
876 static int explicit_rdpcm_dir_flag_decode(HEVCContext *s, int c_idx)
878 return GET_CABAC(elem_offset[EXPLICIT_RDPCM_DIR_FLAG] + !!c_idx);
881 int ff_hevc_log2_res_scale_abs(HEVCContext *s, int idx) {
884 while (i < 4 && GET_CABAC(elem_offset[LOG2_RES_SCALE_ABS] + 4 * idx + i))
890 int ff_hevc_res_scale_sign_flag(HEVCContext *s, int idx) {
891 return GET_CABAC(elem_offset[RES_SCALE_SIGN_FLAG] + idx);
894 static av_always_inline void last_significant_coeff_xy_prefix_decode(HEVCContext *s, int c_idx,
895 int log2_size, int *last_scx_prefix, int *last_scy_prefix)
898 int max = (log2_size << 1) - 1;
899 int ctx_offset, ctx_shift;
902 ctx_offset = 3 * (log2_size - 2) + ((log2_size - 1) >> 2);
903 ctx_shift = (log2_size + 1) >> 2;
906 ctx_shift = log2_size - 2;
909 GET_CABAC(elem_offset[LAST_SIGNIFICANT_COEFF_X_PREFIX] + (i >> ctx_shift) + ctx_offset))
911 *last_scx_prefix = i;
915 GET_CABAC(elem_offset[LAST_SIGNIFICANT_COEFF_Y_PREFIX] + (i >> ctx_shift) + ctx_offset))
917 *last_scy_prefix = i;
920 static av_always_inline int last_significant_coeff_suffix_decode(HEVCContext *s,
921 int last_significant_coeff_prefix)
924 int length = (last_significant_coeff_prefix >> 1) - 1;
925 int value = get_cabac_bypass(&s->HEVClc->cc);
927 for (i = 1; i < length; i++)
928 value = (value << 1) | get_cabac_bypass(&s->HEVClc->cc);
932 static av_always_inline int significant_coeff_group_flag_decode(HEVCContext *s, int c_idx, int ctx_cg)
936 inc = FFMIN(ctx_cg, 1) + (c_idx>0 ? 2 : 0);
938 return GET_CABAC(elem_offset[SIGNIFICANT_COEFF_GROUP_FLAG] + inc);
940 static av_always_inline int significant_coeff_flag_decode(HEVCContext *s, int x_c, int y_c,
941 int offset, const uint8_t *ctx_idx_map)
943 int inc = ctx_idx_map[(y_c << 2) + x_c] + offset;
944 return GET_CABAC(elem_offset[SIGNIFICANT_COEFF_FLAG] + inc);
947 static av_always_inline int significant_coeff_flag_decode_0(HEVCContext *s, int c_idx, int offset)
949 return GET_CABAC(elem_offset[SIGNIFICANT_COEFF_FLAG] + offset);
952 static av_always_inline int coeff_abs_level_greater1_flag_decode(HEVCContext *s, int c_idx, int inc)
958 return GET_CABAC(elem_offset[COEFF_ABS_LEVEL_GREATER1_FLAG] + inc);
961 static av_always_inline int coeff_abs_level_greater2_flag_decode(HEVCContext *s, int c_idx, int inc)
966 return GET_CABAC(elem_offset[COEFF_ABS_LEVEL_GREATER2_FLAG] + inc);
969 static av_always_inline int coeff_abs_level_remaining_decode(HEVCContext *s, int rc_rice_param)
973 int last_coeff_abs_level_remaining;
976 while (prefix < CABAC_MAX_BIN && get_cabac_bypass(&s->HEVClc->cc))
978 if (prefix == CABAC_MAX_BIN) {
979 av_log(s->avctx, AV_LOG_ERROR, "CABAC_MAX_BIN : %d\n", prefix);
983 for (i = 0; i < rc_rice_param; i++)
984 suffix = (suffix << 1) | get_cabac_bypass(&s->HEVClc->cc);
985 last_coeff_abs_level_remaining = (prefix << rc_rice_param) + suffix;
987 int prefix_minus3 = prefix - 3;
988 for (i = 0; i < prefix_minus3 + rc_rice_param; i++)
989 suffix = (suffix << 1) | get_cabac_bypass(&s->HEVClc->cc);
990 last_coeff_abs_level_remaining = (((1 << prefix_minus3) + 3 - 1)
991 << rc_rice_param) + suffix;
993 return last_coeff_abs_level_remaining;
996 static av_always_inline int coeff_sign_flag_decode(HEVCContext *s, uint8_t nb)
1001 for (i = 0; i < nb; i++)
1002 ret = (ret << 1) | get_cabac_bypass(&s->HEVClc->cc);
1006 void ff_hevc_hls_residual_coding(HEVCContext *s, int x0, int y0,
1007 int log2_trafo_size, enum ScanType scan_idx,
1010 #define GET_COORD(offset, n) \
1012 x_c = (x_cg << 2) + scan_x_off[n]; \
1013 y_c = (y_cg << 2) + scan_y_off[n]; \
1015 HEVCLocalContext *lc = s->HEVClc;
1016 int transform_skip_flag = 0;
1018 int last_significant_coeff_x, last_significant_coeff_y;
1022 int greater1_ctx = 1;
1024 int num_last_subset;
1025 int x_cg_last_sig, y_cg_last_sig;
1027 const uint8_t *scan_x_cg, *scan_y_cg, *scan_x_off, *scan_y_off;
1029 ptrdiff_t stride = s->frame->linesize[c_idx];
1030 int hshift = s->ps.sps->hshift[c_idx];
1031 int vshift = s->ps.sps->vshift[c_idx];
1032 uint8_t *dst = &s->frame->data[c_idx][(y0 >> vshift) * stride +
1033 ((x0 >> hshift) << s->ps.sps->pixel_shift)];
1034 int16_t *coeffs = (int16_t*)(c_idx ? lc->edge_emu_buffer2 : lc->edge_emu_buffer);
1035 uint8_t significant_coeff_group_flag[8][8] = {{0}};
1036 int explicit_rdpcm_flag = 0;
1037 int explicit_rdpcm_dir_flag;
1039 int trafo_size = 1 << log2_trafo_size;
1041 int qp,shift,add,scale,scale_m;
1042 static const uint8_t level_scale[] = { 40, 45, 51, 57, 64, 72 };
1043 const uint8_t *scale_matrix = NULL;
1045 int pred_mode_intra = (c_idx == 0) ? lc->tu.intra_pred_mode :
1046 lc->tu.intra_pred_mode_c;
1048 memset(coeffs, 0, trafo_size * trafo_size * sizeof(int16_t));
1050 // Derive QP for dequant
1051 if (!lc->cu.cu_transquant_bypass_flag) {
1052 static const int qp_c[] = { 29, 30, 31, 32, 33, 33, 34, 34, 35, 35, 36, 36, 37, 37 };
1053 static const uint8_t rem6[51 + 4 * 6 + 1] = {
1054 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2,
1055 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5,
1056 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3,
1057 4, 5, 0, 1, 2, 3, 4, 5, 0, 1
1060 static const uint8_t div6[51 + 4 * 6 + 1] = {
1061 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 3, 3, 3,
1062 3, 3, 3, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6,
1063 7, 7, 7, 7, 7, 7, 8, 8, 8, 8, 8, 8, 9, 9, 9, 9, 9, 9, 10, 10, 10, 10,
1064 10, 10, 11, 11, 11, 11, 11, 11, 12, 12
1066 int qp_y = lc->qp_y;
1068 if (s->ps.pps->transform_skip_enabled_flag &&
1069 log2_trafo_size <= s->ps.pps->log2_max_transform_skip_block_size) {
1070 transform_skip_flag = hevc_transform_skip_flag_decode(s, c_idx);
1074 qp = qp_y + s->ps.sps->qp_bd_offset;
1079 offset = s->ps.pps->cb_qp_offset + s->sh.slice_cb_qp_offset +
1080 lc->tu.cu_qp_offset_cb;
1082 offset = s->ps.pps->cr_qp_offset + s->sh.slice_cr_qp_offset +
1083 lc->tu.cu_qp_offset_cr;
1085 qp_i = av_clip(qp_y + offset, - s->ps.sps->qp_bd_offset, 57);
1086 if (s->ps.sps->chroma_format_idc == 1) {
1092 qp = qp_c[qp_i - 30];
1100 qp += s->ps.sps->qp_bd_offset;
1103 shift = s->ps.sps->bit_depth + log2_trafo_size - 5;
1104 add = 1 << (shift-1);
1105 scale = level_scale[rem6[qp]] << (div6[qp]);
1106 scale_m = 16; // default when no custom scaling lists.
1109 if (s->ps.sps->scaling_list_enable_flag && !(transform_skip_flag && log2_trafo_size > 2)) {
1110 const ScalingList *sl = s->ps.pps->scaling_list_data_present_flag ?
1111 &s->ps.pps->scaling_list : &s->ps.sps->scaling_list;
1112 int matrix_id = lc->cu.pred_mode != MODE_INTRA;
1114 matrix_id = 3 * matrix_id + c_idx;
1116 scale_matrix = sl->sl[log2_trafo_size - 2][matrix_id];
1117 if (log2_trafo_size >= 4)
1118 dc_scale = sl->sl_dc[log2_trafo_size - 4][matrix_id];
1127 if (lc->cu.pred_mode == MODE_INTER && s->ps.sps->explicit_rdpcm_enabled_flag &&
1128 (transform_skip_flag || lc->cu.cu_transquant_bypass_flag)) {
1129 explicit_rdpcm_flag = explicit_rdpcm_flag_decode(s, c_idx);
1130 if (explicit_rdpcm_flag) {
1131 explicit_rdpcm_dir_flag = explicit_rdpcm_dir_flag_decode(s, c_idx);
1135 last_significant_coeff_xy_prefix_decode(s, c_idx, log2_trafo_size,
1136 &last_significant_coeff_x, &last_significant_coeff_y);
1138 if (last_significant_coeff_x > 3) {
1139 int suffix = last_significant_coeff_suffix_decode(s, last_significant_coeff_x);
1140 last_significant_coeff_x = (1 << ((last_significant_coeff_x >> 1) - 1)) *
1141 (2 + (last_significant_coeff_x & 1)) +
1145 if (last_significant_coeff_y > 3) {
1146 int suffix = last_significant_coeff_suffix_decode(s, last_significant_coeff_y);
1147 last_significant_coeff_y = (1 << ((last_significant_coeff_y >> 1) - 1)) *
1148 (2 + (last_significant_coeff_y & 1)) +
1152 if (scan_idx == SCAN_VERT)
1153 FFSWAP(int, last_significant_coeff_x, last_significant_coeff_y);
1155 x_cg_last_sig = last_significant_coeff_x >> 2;
1156 y_cg_last_sig = last_significant_coeff_y >> 2;
1160 int last_x_c = last_significant_coeff_x & 3;
1161 int last_y_c = last_significant_coeff_y & 3;
1163 scan_x_off = ff_hevc_diag_scan4x4_x;
1164 scan_y_off = ff_hevc_diag_scan4x4_y;
1165 num_coeff = diag_scan4x4_inv[last_y_c][last_x_c];
1166 if (trafo_size == 4) {
1167 scan_x_cg = scan_1x1;
1168 scan_y_cg = scan_1x1;
1169 } else if (trafo_size == 8) {
1170 num_coeff += diag_scan2x2_inv[y_cg_last_sig][x_cg_last_sig] << 4;
1171 scan_x_cg = diag_scan2x2_x;
1172 scan_y_cg = diag_scan2x2_y;
1173 } else if (trafo_size == 16) {
1174 num_coeff += diag_scan4x4_inv[y_cg_last_sig][x_cg_last_sig] << 4;
1175 scan_x_cg = ff_hevc_diag_scan4x4_x;
1176 scan_y_cg = ff_hevc_diag_scan4x4_y;
1177 } else { // trafo_size == 32
1178 num_coeff += diag_scan8x8_inv[y_cg_last_sig][x_cg_last_sig] << 4;
1179 scan_x_cg = ff_hevc_diag_scan8x8_x;
1180 scan_y_cg = ff_hevc_diag_scan8x8_y;
1185 scan_x_cg = horiz_scan2x2_x;
1186 scan_y_cg = horiz_scan2x2_y;
1187 scan_x_off = horiz_scan4x4_x;
1188 scan_y_off = horiz_scan4x4_y;
1189 num_coeff = horiz_scan8x8_inv[last_significant_coeff_y][last_significant_coeff_x];
1191 default: //SCAN_VERT
1192 scan_x_cg = horiz_scan2x2_y;
1193 scan_y_cg = horiz_scan2x2_x;
1194 scan_x_off = horiz_scan4x4_y;
1195 scan_y_off = horiz_scan4x4_x;
1196 num_coeff = horiz_scan8x8_inv[last_significant_coeff_x][last_significant_coeff_y];
1200 num_last_subset = (num_coeff - 1) >> 4;
1202 for (i = num_last_subset; i >= 0; i--) {
1204 int x_cg, y_cg, x_c, y_c, pos;
1205 int implicit_non_zero_coeff = 0;
1206 int64_t trans_coeff_level;
1208 int offset = i << 4;
1211 uint8_t significant_coeff_flag_idx[16];
1212 uint8_t nb_significant_coeff_flag = 0;
1214 x_cg = scan_x_cg[i];
1215 y_cg = scan_y_cg[i];
1217 if ((i < num_last_subset) && (i > 0)) {
1219 if (x_cg < (1 << (log2_trafo_size - 2)) - 1)
1220 ctx_cg += significant_coeff_group_flag[x_cg + 1][y_cg];
1221 if (y_cg < (1 << (log2_trafo_size - 2)) - 1)
1222 ctx_cg += significant_coeff_group_flag[x_cg][y_cg + 1];
1224 significant_coeff_group_flag[x_cg][y_cg] =
1225 significant_coeff_group_flag_decode(s, c_idx, ctx_cg);
1226 implicit_non_zero_coeff = 1;
1228 significant_coeff_group_flag[x_cg][y_cg] =
1229 ((x_cg == x_cg_last_sig && y_cg == y_cg_last_sig) ||
1230 (x_cg == 0 && y_cg == 0));
1233 last_scan_pos = num_coeff - offset - 1;
1235 if (i == num_last_subset) {
1236 n_end = last_scan_pos - 1;
1237 significant_coeff_flag_idx[0] = last_scan_pos;
1238 nb_significant_coeff_flag = 1;
1243 if (x_cg < ((1 << log2_trafo_size) - 1) >> 2)
1244 prev_sig = !!significant_coeff_group_flag[x_cg + 1][y_cg];
1245 if (y_cg < ((1 << log2_trafo_size) - 1) >> 2)
1246 prev_sig += (!!significant_coeff_group_flag[x_cg][y_cg + 1] << 1);
1248 if (significant_coeff_group_flag[x_cg][y_cg] && n_end >= 0) {
1249 static const uint8_t ctx_idx_map[] = {
1250 0, 1, 4, 5, 2, 3, 4, 5, 6, 6, 8, 8, 7, 7, 8, 8, // log2_trafo_size == 2
1251 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, // prev_sig == 0
1252 2, 2, 2, 2, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, // prev_sig == 1
1253 2, 1, 0, 0, 2, 1, 0, 0, 2, 1, 0, 0, 2, 1, 0, 0, // prev_sig == 2
1254 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2 // default
1256 const uint8_t *ctx_idx_map_p;
1258 if (s->ps.sps->transform_skip_context_enabled_flag &&
1259 (transform_skip_flag || lc->cu.cu_transquant_bypass_flag)) {
1260 ctx_idx_map_p = (uint8_t*) &ctx_idx_map[4 * 16];
1264 scf_offset = 14 + 27;
1269 if (log2_trafo_size == 2) {
1270 ctx_idx_map_p = (uint8_t*) &ctx_idx_map[0];
1272 ctx_idx_map_p = (uint8_t*) &ctx_idx_map[(prev_sig + 1) << 4];
1274 if ((x_cg > 0 || y_cg > 0))
1276 if (log2_trafo_size == 3) {
1277 scf_offset += (scan_idx == SCAN_DIAG) ? 9 : 15;
1282 if (log2_trafo_size == 3)
1289 for (n = n_end; n > 0; n--) {
1290 x_c = scan_x_off[n];
1291 y_c = scan_y_off[n];
1292 if (significant_coeff_flag_decode(s, x_c, y_c, scf_offset, ctx_idx_map_p)) {
1293 significant_coeff_flag_idx[nb_significant_coeff_flag] = n;
1294 nb_significant_coeff_flag++;
1295 implicit_non_zero_coeff = 0;
1298 if (implicit_non_zero_coeff == 0) {
1299 if (s->ps.sps->transform_skip_context_enabled_flag &&
1300 (transform_skip_flag || lc->cu.cu_transquant_bypass_flag)) {
1304 scf_offset = 16 + 27;
1313 scf_offset = 2 + scf_offset;
1316 if (significant_coeff_flag_decode_0(s, c_idx, scf_offset) == 1) {
1317 significant_coeff_flag_idx[nb_significant_coeff_flag] = 0;
1318 nb_significant_coeff_flag++;
1321 significant_coeff_flag_idx[nb_significant_coeff_flag] = 0;
1322 nb_significant_coeff_flag++;
1326 n_end = nb_significant_coeff_flag;
1330 int first_nz_pos_in_cg;
1331 int last_nz_pos_in_cg;
1332 int c_rice_param = 0;
1333 int first_greater1_coeff_idx = -1;
1334 uint8_t coeff_abs_level_greater1_flag[8];
1335 uint16_t coeff_sign_flag;
1341 // initialize first elem of coeff_bas_level_greater1_flag
1342 int ctx_set = (i > 0 && c_idx == 0) ? 2 : 0;
1344 if (s->ps.sps->persistent_rice_adaptation_enabled_flag) {
1345 if (!transform_skip_flag && !lc->cu.cu_transquant_bypass_flag)
1346 sb_type = 2 * (c_idx == 0 ? 1 : 0);
1348 sb_type = 2 * (c_idx == 0 ? 1 : 0) + 1;
1349 c_rice_param = lc->stat_coeff[sb_type] / 4;
1352 if (!(i == num_last_subset) && greater1_ctx == 0)
1355 last_nz_pos_in_cg = significant_coeff_flag_idx[0];
1357 for (m = 0; m < (n_end > 8 ? 8 : n_end); m++) {
1358 int inc = (ctx_set << 2) + greater1_ctx;
1359 coeff_abs_level_greater1_flag[m] =
1360 coeff_abs_level_greater1_flag_decode(s, c_idx, inc);
1361 if (coeff_abs_level_greater1_flag[m]) {
1363 if (first_greater1_coeff_idx == -1)
1364 first_greater1_coeff_idx = m;
1365 } else if (greater1_ctx > 0 && greater1_ctx < 3) {
1369 first_nz_pos_in_cg = significant_coeff_flag_idx[n_end - 1];
1371 if (lc->cu.cu_transquant_bypass_flag ||
1372 (lc->cu.pred_mode == MODE_INTRA &&
1373 s->ps.sps->implicit_rdpcm_enabled_flag && transform_skip_flag &&
1374 (pred_mode_intra == 10 || pred_mode_intra == 26 )) ||
1375 explicit_rdpcm_flag)
1378 sign_hidden = (last_nz_pos_in_cg - first_nz_pos_in_cg >= 4);
1380 if (first_greater1_coeff_idx != -1) {
1381 coeff_abs_level_greater1_flag[first_greater1_coeff_idx] += coeff_abs_level_greater2_flag_decode(s, c_idx, ctx_set);
1383 if (!s->ps.pps->sign_data_hiding_flag || !sign_hidden ) {
1384 coeff_sign_flag = coeff_sign_flag_decode(s, nb_significant_coeff_flag) << (16 - nb_significant_coeff_flag);
1386 coeff_sign_flag = coeff_sign_flag_decode(s, nb_significant_coeff_flag - 1) << (16 - (nb_significant_coeff_flag - 1));
1389 for (m = 0; m < n_end; m++) {
1390 n = significant_coeff_flag_idx[m];
1391 GET_COORD(offset, n);
1393 trans_coeff_level = 1 + coeff_abs_level_greater1_flag[m];
1394 if (trans_coeff_level == ((m == first_greater1_coeff_idx) ? 3 : 2)) {
1395 int last_coeff_abs_level_remaining = coeff_abs_level_remaining_decode(s, c_rice_param);
1397 trans_coeff_level += last_coeff_abs_level_remaining;
1398 if (trans_coeff_level > (3 << c_rice_param))
1399 c_rice_param = s->ps.sps->persistent_rice_adaptation_enabled_flag ? c_rice_param + 1 : FFMIN(c_rice_param + 1, 4);
1400 if (s->ps.sps->persistent_rice_adaptation_enabled_flag && !rice_init) {
1401 int c_rice_p_init = lc->stat_coeff[sb_type] / 4;
1402 if (last_coeff_abs_level_remaining >= (3 << c_rice_p_init))
1403 lc->stat_coeff[sb_type]++;
1404 else if (2 * last_coeff_abs_level_remaining < (1 << c_rice_p_init))
1405 if (lc->stat_coeff[sb_type] > 0)
1406 lc->stat_coeff[sb_type]--;
1411 int last_coeff_abs_level_remaining = coeff_abs_level_remaining_decode(s, c_rice_param);
1413 trans_coeff_level = 1 + last_coeff_abs_level_remaining;
1414 if (trans_coeff_level > (3 << c_rice_param))
1415 c_rice_param = s->ps.sps->persistent_rice_adaptation_enabled_flag ? c_rice_param + 1 : FFMIN(c_rice_param + 1, 4);
1416 if (s->ps.sps->persistent_rice_adaptation_enabled_flag && !rice_init) {
1417 int c_rice_p_init = lc->stat_coeff[sb_type] / 4;
1418 if (last_coeff_abs_level_remaining >= (3 << c_rice_p_init))
1419 lc->stat_coeff[sb_type]++;
1420 else if (2 * last_coeff_abs_level_remaining < (1 << c_rice_p_init))
1421 if (lc->stat_coeff[sb_type] > 0)
1422 lc->stat_coeff[sb_type]--;
1426 if (s->ps.pps->sign_data_hiding_flag && sign_hidden) {
1427 sum_abs += trans_coeff_level;
1428 if (n == first_nz_pos_in_cg && (sum_abs&1))
1429 trans_coeff_level = -trans_coeff_level;
1431 if (coeff_sign_flag >> 15)
1432 trans_coeff_level = -trans_coeff_level;
1433 coeff_sign_flag <<= 1;
1434 if(!lc->cu.cu_transquant_bypass_flag) {
1435 if (s->ps.sps->scaling_list_enable_flag && !(transform_skip_flag && log2_trafo_size > 2)) {
1436 if(y_c || x_c || log2_trafo_size < 4) {
1437 switch(log2_trafo_size) {
1438 case 3: pos = (y_c << 3) + x_c; break;
1439 case 4: pos = ((y_c >> 1) << 3) + (x_c >> 1); break;
1440 case 5: pos = ((y_c >> 2) << 3) + (x_c >> 2); break;
1441 default: pos = (y_c << 2) + x_c; break;
1443 scale_m = scale_matrix[pos];
1448 trans_coeff_level = (trans_coeff_level * (int64_t)scale * (int64_t)scale_m + add) >> shift;
1449 if(trans_coeff_level < 0) {
1450 if((~trans_coeff_level) & 0xFffffffffff8000)
1451 trans_coeff_level = -32768;
1453 if(trans_coeff_level & 0xffffffffffff8000)
1454 trans_coeff_level = 32767;
1457 coeffs[y_c * trafo_size + x_c] = trans_coeff_level;
1462 if (lc->cu.cu_transquant_bypass_flag) {
1463 if (explicit_rdpcm_flag || (s->ps.sps->implicit_rdpcm_enabled_flag &&
1464 (pred_mode_intra == 10 || pred_mode_intra == 26))) {
1465 int mode = s->ps.sps->implicit_rdpcm_enabled_flag ? (pred_mode_intra == 26) : explicit_rdpcm_dir_flag;
1467 s->hevcdsp.transform_rdpcm(coeffs, log2_trafo_size, mode);
1470 if (transform_skip_flag) {
1471 int rot = s->ps.sps->transform_skip_rotation_enabled_flag &&
1472 log2_trafo_size == 2 &&
1473 lc->cu.pred_mode == MODE_INTRA;
1475 for (i = 0; i < 8; i++)
1476 FFSWAP(int16_t, coeffs[i], coeffs[16 - i - 1]);
1479 s->hevcdsp.dequant(coeffs, log2_trafo_size);
1481 if (explicit_rdpcm_flag || (s->ps.sps->implicit_rdpcm_enabled_flag &&
1482 lc->cu.pred_mode == MODE_INTRA &&
1483 (pred_mode_intra == 10 || pred_mode_intra == 26))) {
1484 int mode = explicit_rdpcm_flag ? explicit_rdpcm_dir_flag : (pred_mode_intra == 26);
1486 s->hevcdsp.transform_rdpcm(coeffs, log2_trafo_size, mode);
1488 } else if (lc->cu.pred_mode == MODE_INTRA && c_idx == 0 && log2_trafo_size == 2) {
1489 s->hevcdsp.transform_4x4_luma(coeffs);
1491 int max_xy = FFMAX(last_significant_coeff_x, last_significant_coeff_y);
1493 s->hevcdsp.idct_dc[log2_trafo_size - 2](coeffs);
1495 int col_limit = last_significant_coeff_x + last_significant_coeff_y + 4;
1497 col_limit = FFMIN(4, col_limit);
1498 else if (max_xy < 8)
1499 col_limit = FFMIN(8, col_limit);
1500 else if (max_xy < 12)
1501 col_limit = FFMIN(24, col_limit);
1502 s->hevcdsp.idct[log2_trafo_size - 2](coeffs, col_limit);
1506 if (lc->tu.cross_pf) {
1507 int16_t *coeffs_y = (int16_t*)lc->edge_emu_buffer;
1509 for (i = 0; i < (trafo_size * trafo_size); i++) {
1510 coeffs[i] = coeffs[i] + ((lc->tu.res_scale_val * coeffs_y[i]) >> 3);
1513 s->hevcdsp.add_residual[log2_trafo_size-2](dst, coeffs, stride);
1516 void ff_hevc_hls_mvd_coding(HEVCContext *s, int x0, int y0, int log2_cb_size)
1518 HEVCLocalContext *lc = s->HEVClc;
1519 int x = abs_mvd_greater0_flag_decode(s);
1520 int y = abs_mvd_greater0_flag_decode(s);
1523 x += abs_mvd_greater1_flag_decode(s);
1525 y += abs_mvd_greater1_flag_decode(s);
1528 case 2: lc->pu.mvd.x = mvd_decode(s); break;
1529 case 1: lc->pu.mvd.x = mvd_sign_flag_decode(s); break;
1530 case 0: lc->pu.mvd.x = 0; break;
1534 case 2: lc->pu.mvd.y = mvd_decode(s); break;
1535 case 1: lc->pu.mvd.y = mvd_sign_flag_decode(s); break;
1536 case 0: lc->pu.mvd.y = 0; break;