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);
840 ret += get_cabac_bypass(&s->HEVClc->cc) << k;
841 return get_cabac_bypass_sign(&s->HEVClc->cc, -ret);
844 static av_always_inline int mvd_sign_flag_decode(HEVCContext *s)
846 return get_cabac_bypass_sign(&s->HEVClc->cc, -1);
849 int ff_hevc_split_transform_flag_decode(HEVCContext *s, int log2_trafo_size)
851 return GET_CABAC(elem_offset[SPLIT_TRANSFORM_FLAG] + 5 - log2_trafo_size);
854 int ff_hevc_cbf_cb_cr_decode(HEVCContext *s, int trafo_depth)
856 return GET_CABAC(elem_offset[CBF_CB_CR] + trafo_depth);
859 int ff_hevc_cbf_luma_decode(HEVCContext *s, int trafo_depth)
861 return GET_CABAC(elem_offset[CBF_LUMA] + !trafo_depth);
864 static int hevc_transform_skip_flag_decode(HEVCContext *s, int c_idx)
866 return GET_CABAC(elem_offset[TRANSFORM_SKIP_FLAG] + !!c_idx);
869 static int explicit_rdpcm_flag_decode(HEVCContext *s, int c_idx)
871 return GET_CABAC(elem_offset[EXPLICIT_RDPCM_FLAG] + !!c_idx);
874 static int explicit_rdpcm_dir_flag_decode(HEVCContext *s, int c_idx)
876 return GET_CABAC(elem_offset[EXPLICIT_RDPCM_DIR_FLAG] + !!c_idx);
879 int ff_hevc_log2_res_scale_abs(HEVCContext *s, int idx) {
882 while (i < 4 && GET_CABAC(elem_offset[LOG2_RES_SCALE_ABS] + 4 * idx + i))
888 int ff_hevc_res_scale_sign_flag(HEVCContext *s, int idx) {
889 return GET_CABAC(elem_offset[RES_SCALE_SIGN_FLAG] + idx);
892 static av_always_inline void last_significant_coeff_xy_prefix_decode(HEVCContext *s, int c_idx,
893 int log2_size, int *last_scx_prefix, int *last_scy_prefix)
896 int max = (log2_size << 1) - 1;
897 int ctx_offset, ctx_shift;
900 ctx_offset = 3 * (log2_size - 2) + ((log2_size - 1) >> 2);
901 ctx_shift = (log2_size + 1) >> 2;
904 ctx_shift = log2_size - 2;
907 GET_CABAC(elem_offset[LAST_SIGNIFICANT_COEFF_X_PREFIX] + (i >> ctx_shift) + ctx_offset))
909 *last_scx_prefix = i;
913 GET_CABAC(elem_offset[LAST_SIGNIFICANT_COEFF_Y_PREFIX] + (i >> ctx_shift) + ctx_offset))
915 *last_scy_prefix = i;
918 static av_always_inline int last_significant_coeff_suffix_decode(HEVCContext *s,
919 int last_significant_coeff_prefix)
922 int length = (last_significant_coeff_prefix >> 1) - 1;
923 int value = get_cabac_bypass(&s->HEVClc->cc);
925 for (i = 1; i < length; i++)
926 value = (value << 1) | get_cabac_bypass(&s->HEVClc->cc);
930 static av_always_inline int significant_coeff_group_flag_decode(HEVCContext *s, int c_idx, int ctx_cg)
934 inc = FFMIN(ctx_cg, 1) + (c_idx>0 ? 2 : 0);
936 return GET_CABAC(elem_offset[SIGNIFICANT_COEFF_GROUP_FLAG] + inc);
938 static av_always_inline int significant_coeff_flag_decode(HEVCContext *s, int x_c, int y_c,
939 int offset, const uint8_t *ctx_idx_map)
941 int inc = ctx_idx_map[(y_c << 2) + x_c] + offset;
942 return GET_CABAC(elem_offset[SIGNIFICANT_COEFF_FLAG] + inc);
945 static av_always_inline int significant_coeff_flag_decode_0(HEVCContext *s, int c_idx, int offset)
947 return GET_CABAC(elem_offset[SIGNIFICANT_COEFF_FLAG] + offset);
950 static av_always_inline int coeff_abs_level_greater1_flag_decode(HEVCContext *s, int c_idx, int inc)
956 return GET_CABAC(elem_offset[COEFF_ABS_LEVEL_GREATER1_FLAG] + inc);
959 static av_always_inline int coeff_abs_level_greater2_flag_decode(HEVCContext *s, int c_idx, int inc)
964 return GET_CABAC(elem_offset[COEFF_ABS_LEVEL_GREATER2_FLAG] + inc);
967 static av_always_inline int coeff_abs_level_remaining_decode(HEVCContext *s, int rc_rice_param)
971 int last_coeff_abs_level_remaining;
974 while (prefix < CABAC_MAX_BIN && get_cabac_bypass(&s->HEVClc->cc))
976 if (prefix == CABAC_MAX_BIN)
977 av_log(s->avctx, AV_LOG_ERROR, "CABAC_MAX_BIN : %d\n", prefix);
979 for (i = 0; i < rc_rice_param; i++)
980 suffix = (suffix << 1) | get_cabac_bypass(&s->HEVClc->cc);
981 last_coeff_abs_level_remaining = (prefix << rc_rice_param) + suffix;
983 int prefix_minus3 = prefix - 3;
984 for (i = 0; i < prefix_minus3 + rc_rice_param; i++)
985 suffix = (suffix << 1) | get_cabac_bypass(&s->HEVClc->cc);
986 last_coeff_abs_level_remaining = (((1 << prefix_minus3) + 3 - 1)
987 << rc_rice_param) + suffix;
989 return last_coeff_abs_level_remaining;
992 static av_always_inline int coeff_sign_flag_decode(HEVCContext *s, uint8_t nb)
997 for (i = 0; i < nb; i++)
998 ret = (ret << 1) | get_cabac_bypass(&s->HEVClc->cc);
1002 void ff_hevc_hls_residual_coding(HEVCContext *s, int x0, int y0,
1003 int log2_trafo_size, enum ScanType scan_idx,
1006 #define GET_COORD(offset, n) \
1008 x_c = (x_cg << 2) + scan_x_off[n]; \
1009 y_c = (y_cg << 2) + scan_y_off[n]; \
1011 HEVCLocalContext *lc = s->HEVClc;
1012 int transform_skip_flag = 0;
1014 int last_significant_coeff_x, last_significant_coeff_y;
1018 int greater1_ctx = 1;
1020 int num_last_subset;
1021 int x_cg_last_sig, y_cg_last_sig;
1023 const uint8_t *scan_x_cg, *scan_y_cg, *scan_x_off, *scan_y_off;
1025 ptrdiff_t stride = s->frame->linesize[c_idx];
1026 int hshift = s->ps.sps->hshift[c_idx];
1027 int vshift = s->ps.sps->vshift[c_idx];
1028 uint8_t *dst = &s->frame->data[c_idx][(y0 >> vshift) * stride +
1029 ((x0 >> hshift) << s->ps.sps->pixel_shift)];
1030 int16_t *coeffs = (int16_t*)(c_idx ? lc->edge_emu_buffer2 : lc->edge_emu_buffer);
1031 uint8_t significant_coeff_group_flag[8][8] = {{0}};
1032 int explicit_rdpcm_flag = 0;
1033 int explicit_rdpcm_dir_flag;
1035 int trafo_size = 1 << log2_trafo_size;
1037 int qp,shift,add,scale,scale_m;
1038 const uint8_t level_scale[] = { 40, 45, 51, 57, 64, 72 };
1039 const uint8_t *scale_matrix = NULL;
1041 int pred_mode_intra = (c_idx == 0) ? lc->tu.intra_pred_mode :
1042 lc->tu.intra_pred_mode_c;
1044 memset(coeffs, 0, trafo_size * trafo_size * sizeof(int16_t));
1046 // Derive QP for dequant
1047 if (!lc->cu.cu_transquant_bypass_flag) {
1048 static const int qp_c[] = { 29, 30, 31, 32, 33, 33, 34, 34, 35, 35, 36, 36, 37, 37 };
1049 static const uint8_t rem6[51 + 4 * 6 + 1] = {
1050 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2,
1051 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5,
1052 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3,
1053 4, 5, 0, 1, 2, 3, 4, 5, 0, 1
1056 static const uint8_t div6[51 + 4 * 6 + 1] = {
1057 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 3, 3, 3,
1058 3, 3, 3, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6,
1059 7, 7, 7, 7, 7, 7, 8, 8, 8, 8, 8, 8, 9, 9, 9, 9, 9, 9, 10, 10, 10, 10,
1060 10, 10, 11, 11, 11, 11, 11, 11, 12, 12
1062 int qp_y = lc->qp_y;
1064 if (s->ps.pps->transform_skip_enabled_flag &&
1065 log2_trafo_size <= s->ps.pps->log2_max_transform_skip_block_size) {
1066 transform_skip_flag = hevc_transform_skip_flag_decode(s, c_idx);
1070 qp = qp_y + s->ps.sps->qp_bd_offset;
1075 offset = s->ps.pps->cb_qp_offset + s->sh.slice_cb_qp_offset +
1076 lc->tu.cu_qp_offset_cb;
1078 offset = s->ps.pps->cr_qp_offset + s->sh.slice_cr_qp_offset +
1079 lc->tu.cu_qp_offset_cr;
1081 qp_i = av_clip(qp_y + offset, - s->ps.sps->qp_bd_offset, 57);
1082 if (s->ps.sps->chroma_format_idc == 1) {
1088 qp = qp_c[qp_i - 30];
1096 qp += s->ps.sps->qp_bd_offset;
1099 shift = s->ps.sps->bit_depth + log2_trafo_size - 5;
1100 add = 1 << (shift-1);
1101 scale = level_scale[rem6[qp]] << (div6[qp]);
1102 scale_m = 16; // default when no custom scaling lists.
1105 if (s->ps.sps->scaling_list_enable_flag && !(transform_skip_flag && log2_trafo_size > 2)) {
1106 const ScalingList *sl = s->ps.pps->scaling_list_data_present_flag ?
1107 &s->ps.pps->scaling_list : &s->ps.sps->scaling_list;
1108 int matrix_id = lc->cu.pred_mode != MODE_INTRA;
1110 matrix_id = 3 * matrix_id + c_idx;
1112 scale_matrix = sl->sl[log2_trafo_size - 2][matrix_id];
1113 if (log2_trafo_size >= 4)
1114 dc_scale = sl->sl_dc[log2_trafo_size - 4][matrix_id];
1123 if (lc->cu.pred_mode == MODE_INTER && s->ps.sps->explicit_rdpcm_enabled_flag &&
1124 (transform_skip_flag || lc->cu.cu_transquant_bypass_flag)) {
1125 explicit_rdpcm_flag = explicit_rdpcm_flag_decode(s, c_idx);
1126 if (explicit_rdpcm_flag) {
1127 explicit_rdpcm_dir_flag = explicit_rdpcm_dir_flag_decode(s, c_idx);
1131 last_significant_coeff_xy_prefix_decode(s, c_idx, log2_trafo_size,
1132 &last_significant_coeff_x, &last_significant_coeff_y);
1134 if (last_significant_coeff_x > 3) {
1135 int suffix = last_significant_coeff_suffix_decode(s, last_significant_coeff_x);
1136 last_significant_coeff_x = (1 << ((last_significant_coeff_x >> 1) - 1)) *
1137 (2 + (last_significant_coeff_x & 1)) +
1141 if (last_significant_coeff_y > 3) {
1142 int suffix = last_significant_coeff_suffix_decode(s, last_significant_coeff_y);
1143 last_significant_coeff_y = (1 << ((last_significant_coeff_y >> 1) - 1)) *
1144 (2 + (last_significant_coeff_y & 1)) +
1148 if (scan_idx == SCAN_VERT)
1149 FFSWAP(int, last_significant_coeff_x, last_significant_coeff_y);
1151 x_cg_last_sig = last_significant_coeff_x >> 2;
1152 y_cg_last_sig = last_significant_coeff_y >> 2;
1156 int last_x_c = last_significant_coeff_x & 3;
1157 int last_y_c = last_significant_coeff_y & 3;
1159 scan_x_off = ff_hevc_diag_scan4x4_x;
1160 scan_y_off = ff_hevc_diag_scan4x4_y;
1161 num_coeff = diag_scan4x4_inv[last_y_c][last_x_c];
1162 if (trafo_size == 4) {
1163 scan_x_cg = scan_1x1;
1164 scan_y_cg = scan_1x1;
1165 } else if (trafo_size == 8) {
1166 num_coeff += diag_scan2x2_inv[y_cg_last_sig][x_cg_last_sig] << 4;
1167 scan_x_cg = diag_scan2x2_x;
1168 scan_y_cg = diag_scan2x2_y;
1169 } else if (trafo_size == 16) {
1170 num_coeff += diag_scan4x4_inv[y_cg_last_sig][x_cg_last_sig] << 4;
1171 scan_x_cg = ff_hevc_diag_scan4x4_x;
1172 scan_y_cg = ff_hevc_diag_scan4x4_y;
1173 } else { // trafo_size == 32
1174 num_coeff += diag_scan8x8_inv[y_cg_last_sig][x_cg_last_sig] << 4;
1175 scan_x_cg = ff_hevc_diag_scan8x8_x;
1176 scan_y_cg = ff_hevc_diag_scan8x8_y;
1181 scan_x_cg = horiz_scan2x2_x;
1182 scan_y_cg = horiz_scan2x2_y;
1183 scan_x_off = horiz_scan4x4_x;
1184 scan_y_off = horiz_scan4x4_y;
1185 num_coeff = horiz_scan8x8_inv[last_significant_coeff_y][last_significant_coeff_x];
1187 default: //SCAN_VERT
1188 scan_x_cg = horiz_scan2x2_y;
1189 scan_y_cg = horiz_scan2x2_x;
1190 scan_x_off = horiz_scan4x4_y;
1191 scan_y_off = horiz_scan4x4_x;
1192 num_coeff = horiz_scan8x8_inv[last_significant_coeff_x][last_significant_coeff_y];
1196 num_last_subset = (num_coeff - 1) >> 4;
1198 for (i = num_last_subset; i >= 0; i--) {
1200 int x_cg, y_cg, x_c, y_c, pos;
1201 int implicit_non_zero_coeff = 0;
1202 int64_t trans_coeff_level;
1204 int offset = i << 4;
1207 uint8_t significant_coeff_flag_idx[16];
1208 uint8_t nb_significant_coeff_flag = 0;
1210 x_cg = scan_x_cg[i];
1211 y_cg = scan_y_cg[i];
1213 if ((i < num_last_subset) && (i > 0)) {
1215 if (x_cg < (1 << (log2_trafo_size - 2)) - 1)
1216 ctx_cg += significant_coeff_group_flag[x_cg + 1][y_cg];
1217 if (y_cg < (1 << (log2_trafo_size - 2)) - 1)
1218 ctx_cg += significant_coeff_group_flag[x_cg][y_cg + 1];
1220 significant_coeff_group_flag[x_cg][y_cg] =
1221 significant_coeff_group_flag_decode(s, c_idx, ctx_cg);
1222 implicit_non_zero_coeff = 1;
1224 significant_coeff_group_flag[x_cg][y_cg] =
1225 ((x_cg == x_cg_last_sig && y_cg == y_cg_last_sig) ||
1226 (x_cg == 0 && y_cg == 0));
1229 last_scan_pos = num_coeff - offset - 1;
1231 if (i == num_last_subset) {
1232 n_end = last_scan_pos - 1;
1233 significant_coeff_flag_idx[0] = last_scan_pos;
1234 nb_significant_coeff_flag = 1;
1239 if (x_cg < ((1 << log2_trafo_size) - 1) >> 2)
1240 prev_sig = !!significant_coeff_group_flag[x_cg + 1][y_cg];
1241 if (y_cg < ((1 << log2_trafo_size) - 1) >> 2)
1242 prev_sig += (!!significant_coeff_group_flag[x_cg][y_cg + 1] << 1);
1244 if (significant_coeff_group_flag[x_cg][y_cg] && n_end >= 0) {
1245 static const uint8_t ctx_idx_map[] = {
1246 0, 1, 4, 5, 2, 3, 4, 5, 6, 6, 8, 8, 7, 7, 8, 8, // log2_trafo_size == 2
1247 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, // prev_sig == 0
1248 2, 2, 2, 2, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, // prev_sig == 1
1249 2, 1, 0, 0, 2, 1, 0, 0, 2, 1, 0, 0, 2, 1, 0, 0, // prev_sig == 2
1250 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2 // default
1252 const uint8_t *ctx_idx_map_p;
1254 if (s->ps.sps->transform_skip_context_enabled_flag &&
1255 (transform_skip_flag || lc->cu.cu_transquant_bypass_flag)) {
1256 ctx_idx_map_p = (uint8_t*) &ctx_idx_map[4 * 16];
1260 scf_offset = 14 + 27;
1265 if (log2_trafo_size == 2) {
1266 ctx_idx_map_p = (uint8_t*) &ctx_idx_map[0];
1268 ctx_idx_map_p = (uint8_t*) &ctx_idx_map[(prev_sig + 1) << 4];
1270 if ((x_cg > 0 || y_cg > 0))
1272 if (log2_trafo_size == 3) {
1273 scf_offset += (scan_idx == SCAN_DIAG) ? 9 : 15;
1278 if (log2_trafo_size == 3)
1285 for (n = n_end; n > 0; n--) {
1286 x_c = scan_x_off[n];
1287 y_c = scan_y_off[n];
1288 if (significant_coeff_flag_decode(s, x_c, y_c, scf_offset, ctx_idx_map_p)) {
1289 significant_coeff_flag_idx[nb_significant_coeff_flag] = n;
1290 nb_significant_coeff_flag++;
1291 implicit_non_zero_coeff = 0;
1294 if (implicit_non_zero_coeff == 0) {
1295 if (s->ps.sps->transform_skip_context_enabled_flag &&
1296 (transform_skip_flag || lc->cu.cu_transquant_bypass_flag)) {
1300 scf_offset = 16 + 27;
1309 scf_offset = 2 + scf_offset;
1312 if (significant_coeff_flag_decode_0(s, c_idx, scf_offset) == 1) {
1313 significant_coeff_flag_idx[nb_significant_coeff_flag] = 0;
1314 nb_significant_coeff_flag++;
1317 significant_coeff_flag_idx[nb_significant_coeff_flag] = 0;
1318 nb_significant_coeff_flag++;
1322 n_end = nb_significant_coeff_flag;
1326 int first_nz_pos_in_cg;
1327 int last_nz_pos_in_cg;
1328 int c_rice_param = 0;
1329 int first_greater1_coeff_idx = -1;
1330 uint8_t coeff_abs_level_greater1_flag[8];
1331 uint16_t coeff_sign_flag;
1337 // initialize first elem of coeff_bas_level_greater1_flag
1338 int ctx_set = (i > 0 && c_idx == 0) ? 2 : 0;
1340 if (s->ps.sps->persistent_rice_adaptation_enabled_flag) {
1341 if (!transform_skip_flag && !lc->cu.cu_transquant_bypass_flag)
1342 sb_type = 2 * (c_idx == 0 ? 1 : 0);
1344 sb_type = 2 * (c_idx == 0 ? 1 : 0) + 1;
1345 c_rice_param = lc->stat_coeff[sb_type] / 4;
1348 if (!(i == num_last_subset) && greater1_ctx == 0)
1351 last_nz_pos_in_cg = significant_coeff_flag_idx[0];
1353 for (m = 0; m < (n_end > 8 ? 8 : n_end); m++) {
1354 int inc = (ctx_set << 2) + greater1_ctx;
1355 coeff_abs_level_greater1_flag[m] =
1356 coeff_abs_level_greater1_flag_decode(s, c_idx, inc);
1357 if (coeff_abs_level_greater1_flag[m]) {
1359 if (first_greater1_coeff_idx == -1)
1360 first_greater1_coeff_idx = m;
1361 } else if (greater1_ctx > 0 && greater1_ctx < 3) {
1365 first_nz_pos_in_cg = significant_coeff_flag_idx[n_end - 1];
1367 if (lc->cu.cu_transquant_bypass_flag ||
1368 (lc->cu.pred_mode == MODE_INTRA &&
1369 s->ps.sps->implicit_rdpcm_enabled_flag && transform_skip_flag &&
1370 (pred_mode_intra == 10 || pred_mode_intra == 26 )) ||
1371 explicit_rdpcm_flag)
1374 sign_hidden = (last_nz_pos_in_cg - first_nz_pos_in_cg >= 4);
1376 if (first_greater1_coeff_idx != -1) {
1377 coeff_abs_level_greater1_flag[first_greater1_coeff_idx] += coeff_abs_level_greater2_flag_decode(s, c_idx, ctx_set);
1379 if (!s->ps.pps->sign_data_hiding_flag || !sign_hidden ) {
1380 coeff_sign_flag = coeff_sign_flag_decode(s, nb_significant_coeff_flag) << (16 - nb_significant_coeff_flag);
1382 coeff_sign_flag = coeff_sign_flag_decode(s, nb_significant_coeff_flag - 1) << (16 - (nb_significant_coeff_flag - 1));
1385 for (m = 0; m < n_end; m++) {
1386 n = significant_coeff_flag_idx[m];
1387 GET_COORD(offset, n);
1389 trans_coeff_level = 1 + coeff_abs_level_greater1_flag[m];
1390 if (trans_coeff_level == ((m == first_greater1_coeff_idx) ? 3 : 2)) {
1391 int last_coeff_abs_level_remaining = coeff_abs_level_remaining_decode(s, c_rice_param);
1393 trans_coeff_level += last_coeff_abs_level_remaining;
1394 if (trans_coeff_level > (3 << c_rice_param))
1395 c_rice_param = s->ps.sps->persistent_rice_adaptation_enabled_flag ? c_rice_param + 1 : FFMIN(c_rice_param + 1, 4);
1396 if (s->ps.sps->persistent_rice_adaptation_enabled_flag && !rice_init) {
1397 int c_rice_p_init = lc->stat_coeff[sb_type] / 4;
1398 if (last_coeff_abs_level_remaining >= (3 << c_rice_p_init))
1399 lc->stat_coeff[sb_type]++;
1400 else if (2 * last_coeff_abs_level_remaining < (1 << c_rice_p_init))
1401 if (lc->stat_coeff[sb_type] > 0)
1402 lc->stat_coeff[sb_type]--;
1407 int last_coeff_abs_level_remaining = coeff_abs_level_remaining_decode(s, c_rice_param);
1409 trans_coeff_level = 1 + last_coeff_abs_level_remaining;
1410 if (trans_coeff_level > (3 << c_rice_param))
1411 c_rice_param = s->ps.sps->persistent_rice_adaptation_enabled_flag ? c_rice_param + 1 : FFMIN(c_rice_param + 1, 4);
1412 if (s->ps.sps->persistent_rice_adaptation_enabled_flag && !rice_init) {
1413 int c_rice_p_init = lc->stat_coeff[sb_type] / 4;
1414 if (last_coeff_abs_level_remaining >= (3 << c_rice_p_init))
1415 lc->stat_coeff[sb_type]++;
1416 else if (2 * last_coeff_abs_level_remaining < (1 << c_rice_p_init))
1417 if (lc->stat_coeff[sb_type] > 0)
1418 lc->stat_coeff[sb_type]--;
1422 if (s->ps.pps->sign_data_hiding_flag && sign_hidden) {
1423 sum_abs += trans_coeff_level;
1424 if (n == first_nz_pos_in_cg && (sum_abs&1))
1425 trans_coeff_level = -trans_coeff_level;
1427 if (coeff_sign_flag >> 15)
1428 trans_coeff_level = -trans_coeff_level;
1429 coeff_sign_flag <<= 1;
1430 if(!lc->cu.cu_transquant_bypass_flag) {
1431 if (s->ps.sps->scaling_list_enable_flag && !(transform_skip_flag && log2_trafo_size > 2)) {
1432 if(y_c || x_c || log2_trafo_size < 4) {
1433 switch(log2_trafo_size) {
1434 case 3: pos = (y_c << 3) + x_c; break;
1435 case 4: pos = ((y_c >> 1) << 3) + (x_c >> 1); break;
1436 case 5: pos = ((y_c >> 2) << 3) + (x_c >> 2); break;
1437 default: pos = (y_c << 2) + x_c; break;
1439 scale_m = scale_matrix[pos];
1444 trans_coeff_level = (trans_coeff_level * (int64_t)scale * (int64_t)scale_m + add) >> shift;
1445 if(trans_coeff_level < 0) {
1446 if((~trans_coeff_level) & 0xFffffffffff8000)
1447 trans_coeff_level = -32768;
1449 if(trans_coeff_level & 0xffffffffffff8000)
1450 trans_coeff_level = 32767;
1453 coeffs[y_c * trafo_size + x_c] = trans_coeff_level;
1458 if (lc->cu.cu_transquant_bypass_flag) {
1459 if (explicit_rdpcm_flag || (s->ps.sps->implicit_rdpcm_enabled_flag &&
1460 (pred_mode_intra == 10 || pred_mode_intra == 26))) {
1461 int mode = s->ps.sps->implicit_rdpcm_enabled_flag ? (pred_mode_intra == 26) : explicit_rdpcm_dir_flag;
1463 s->hevcdsp.transform_rdpcm(coeffs, log2_trafo_size, mode);
1466 if (transform_skip_flag) {
1467 int rot = s->ps.sps->transform_skip_rotation_enabled_flag &&
1468 log2_trafo_size == 2 &&
1469 lc->cu.pred_mode == MODE_INTRA;
1471 for (i = 0; i < 8; i++)
1472 FFSWAP(int16_t, coeffs[i], coeffs[16 - i - 1]);
1475 s->hevcdsp.transform_skip(coeffs, log2_trafo_size);
1477 if (explicit_rdpcm_flag || (s->ps.sps->implicit_rdpcm_enabled_flag &&
1478 lc->cu.pred_mode == MODE_INTRA &&
1479 (pred_mode_intra == 10 || pred_mode_intra == 26))) {
1480 int mode = explicit_rdpcm_flag ? explicit_rdpcm_dir_flag : (pred_mode_intra == 26);
1482 s->hevcdsp.transform_rdpcm(coeffs, log2_trafo_size, mode);
1484 } else if (lc->cu.pred_mode == MODE_INTRA && c_idx == 0 && log2_trafo_size == 2) {
1485 s->hevcdsp.idct_4x4_luma(coeffs);
1487 int max_xy = FFMAX(last_significant_coeff_x, last_significant_coeff_y);
1489 s->hevcdsp.idct_dc[log2_trafo_size-2](coeffs);
1491 int col_limit = last_significant_coeff_x + last_significant_coeff_y + 4;
1493 col_limit = FFMIN(4, col_limit);
1494 else if (max_xy < 8)
1495 col_limit = FFMIN(8, col_limit);
1496 else if (max_xy < 12)
1497 col_limit = FFMIN(24, col_limit);
1498 s->hevcdsp.idct[log2_trafo_size-2](coeffs, col_limit);
1502 if (lc->tu.cross_pf) {
1503 int16_t *coeffs_y = (int16_t*)lc->edge_emu_buffer;
1505 for (i = 0; i < (trafo_size * trafo_size); i++) {
1506 coeffs[i] = coeffs[i] + ((lc->tu.res_scale_val * coeffs_y[i]) >> 3);
1509 s->hevcdsp.transform_add[log2_trafo_size-2](dst, coeffs, stride);
1512 void ff_hevc_hls_mvd_coding(HEVCContext *s, int x0, int y0, int log2_cb_size)
1514 HEVCLocalContext *lc = s->HEVClc;
1515 int x = abs_mvd_greater0_flag_decode(s);
1516 int y = abs_mvd_greater0_flag_decode(s);
1519 x += abs_mvd_greater1_flag_decode(s);
1521 y += abs_mvd_greater1_flag_decode(s);
1524 case 2: lc->pu.mvd.x = mvd_decode(s); break;
1525 case 1: lc->pu.mvd.x = mvd_sign_flag_decode(s); break;
1526 case 0: lc->pu.mvd.x = 0; break;
1530 case 2: lc->pu.mvd.y = mvd_decode(s); break;
1531 case 1: lc->pu.mvd.y = mvd_sign_flag_decode(s); break;
1532 case 0: lc->pu.mvd.y = 0; break;