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"
32 #define CABAC_MAX_BIN 31
35 * number of bin by SyntaxElement.
37 static const int8_t num_bins_in_se[] = {
41 0, // sao_band_position
44 0, // end_of_slice_flag
45 3, // split_coding_unit_flag
46 1, // cu_transquant_bypass_flag
52 1, // prev_intra_luma_pred_mode
54 0, // rem_intra_luma_pred_mode
55 2, // intra_chroma_pred_mode
61 2, // abs_mvd_greater0_flag
62 2, // abs_mvd_greater1_flag
66 1, // no_residual_data_flag
67 3, // split_transform_flag
70 2, // transform_skip_flag[][]
71 2, // explicit_rdpcm_flag[][]
72 2, // explicit_rdpcm_dir_flag[][]
73 18, // last_significant_coeff_x_prefix
74 18, // last_significant_coeff_y_prefix
75 0, // last_significant_coeff_x_suffix
76 0, // last_significant_coeff_y_suffix
77 4, // significant_coeff_group_flag
78 44, // significant_coeff_flag
79 24, // coeff_abs_level_greater1_flag
80 6, // coeff_abs_level_greater2_flag
81 0, // coeff_abs_level_remaining
83 8, // log2_res_scale_abs
84 2, // res_scale_sign_flag
85 1, // cu_chroma_qp_offset_flag
86 1, // cu_chroma_qp_offset_idx
90 * Offset to ctxIdx 0 in init_values and states, indexed by SyntaxElement.
92 static const int elem_offset[sizeof(num_bins_in_se)] = {
96 2, // sao_band_position
99 2, // end_of_slice_flag
100 2, // split_coding_unit_flag
101 5, // cu_transquant_bypass_flag
107 17, // prev_intra_luma_pred_mode
109 18, // rem_intra_luma_pred_mode
110 18, // intra_chroma_pred_mode
113 22, // inter_pred_idc
116 31, // abs_mvd_greater0_flag
117 33, // abs_mvd_greater1_flag
118 35, // abs_mvd_minus2
121 36, // no_residual_data_flag
122 37, // split_transform_flag
124 42, // cbf_cb, cbf_cr
125 46, // transform_skip_flag[][]
126 48, // explicit_rdpcm_flag[][]
127 50, // explicit_rdpcm_dir_flag[][]
128 52, // last_significant_coeff_x_prefix
129 70, // last_significant_coeff_y_prefix
130 88, // last_significant_coeff_x_suffix
131 88, // last_significant_coeff_y_suffix
132 88, // significant_coeff_group_flag
133 92, // significant_coeff_flag
134 136, // coeff_abs_level_greater1_flag
135 160, // coeff_abs_level_greater2_flag
136 166, // coeff_abs_level_remaining
137 166, // coeff_sign_flag
138 166, // log2_res_scale_abs
139 174, // res_scale_sign_flag
140 176, // cu_chroma_qp_offset_flag
141 177, // cu_chroma_qp_offset_idx
146 * Indexed by init_type
148 static const uint8_t init_values[3][HEVC_CONTEXTS] = {
153 // split_coding_unit_flag
155 // cu_transquant_bypass_flag
165 // prev_intra_luma_pred_mode
167 // intra_chroma_pred_mode
174 CNU, CNU, CNU, CNU, CNU,
179 // abs_mvd_greater1_flag
181 // abs_mvd_greater1_flag
185 // no_residual_data_flag
187 // split_transform_flag
193 // transform_skip_flag
195 // explicit_rdpcm_flag
197 // explicit_rdpcm_dir_flag
199 // last_significant_coeff_x_prefix
200 110, 110, 124, 125, 140, 153, 125, 127, 140, 109, 111, 143, 127, 111,
202 // last_significant_coeff_y_prefix
203 110, 110, 124, 125, 140, 153, 125, 127, 140, 109, 111, 143, 127, 111,
205 // significant_coeff_group_flag
207 // significant_coeff_flag
208 111, 111, 125, 110, 110, 94, 124, 108, 124, 107, 125, 141, 179, 153,
209 125, 107, 125, 141, 179, 153, 125, 107, 125, 141, 179, 153, 125, 140,
210 139, 182, 182, 152, 136, 152, 136, 153, 136, 139, 111, 136, 139, 111,
212 // coeff_abs_level_greater1_flag
213 140, 92, 137, 138, 140, 152, 138, 139, 153, 74, 149, 92, 139, 107,
214 122, 152, 140, 179, 166, 182, 140, 227, 122, 197,
215 // coeff_abs_level_greater2_flag
216 138, 153, 136, 167, 152, 152,
217 // log2_res_scale_abs
218 154, 154, 154, 154, 154, 154, 154, 154,
219 // res_scale_sign_flag
221 // cu_chroma_qp_offset_flag
223 // cu_chroma_qp_offset_idx
230 // split_coding_unit_flag
232 // cu_transquant_bypass_flag
242 // prev_intra_luma_pred_mode
244 // intra_chroma_pred_mode
256 // abs_mvd_greater1_flag
258 // abs_mvd_greater1_flag
262 // no_residual_data_flag
264 // split_transform_flag
270 // transform_skip_flag
272 // explicit_rdpcm_flag
274 // explicit_rdpcm_dir_flag
276 // last_significant_coeff_x_prefix
277 125, 110, 94, 110, 95, 79, 125, 111, 110, 78, 110, 111, 111, 95,
279 // last_significant_coeff_y_prefix
280 125, 110, 94, 110, 95, 79, 125, 111, 110, 78, 110, 111, 111, 95,
282 // significant_coeff_group_flag
284 // significant_coeff_flag
285 155, 154, 139, 153, 139, 123, 123, 63, 153, 166, 183, 140, 136, 153,
286 154, 166, 183, 140, 136, 153, 154, 166, 183, 140, 136, 153, 154, 170,
287 153, 123, 123, 107, 121, 107, 121, 167, 151, 183, 140, 151, 183, 140,
289 // coeff_abs_level_greater1_flag
290 154, 196, 196, 167, 154, 152, 167, 182, 182, 134, 149, 136, 153, 121,
291 136, 137, 169, 194, 166, 167, 154, 167, 137, 182,
292 // coeff_abs_level_greater2_flag
293 107, 167, 91, 122, 107, 167,
294 // log2_res_scale_abs
295 154, 154, 154, 154, 154, 154, 154, 154,
296 // res_scale_sign_flag
298 // cu_chroma_qp_offset_flag
300 // cu_chroma_qp_offset_idx
307 // split_coding_unit_flag
309 // cu_transquant_bypass_flag
319 // prev_intra_luma_pred_mode
321 // intra_chroma_pred_mode
333 // abs_mvd_greater1_flag
335 // abs_mvd_greater1_flag
339 // no_residual_data_flag
341 // split_transform_flag
347 // transform_skip_flag
349 // explicit_rdpcm_flag
351 // explicit_rdpcm_dir_flag
353 // last_significant_coeff_x_prefix
354 125, 110, 124, 110, 95, 94, 125, 111, 111, 79, 125, 126, 111, 111,
356 // last_significant_coeff_y_prefix
357 125, 110, 124, 110, 95, 94, 125, 111, 111, 79, 125, 126, 111, 111,
359 // significant_coeff_group_flag
361 // significant_coeff_flag
362 170, 154, 139, 153, 139, 123, 123, 63, 124, 166, 183, 140, 136, 153,
363 154, 166, 183, 140, 136, 153, 154, 166, 183, 140, 136, 153, 154, 170,
364 153, 138, 138, 122, 121, 122, 121, 167, 151, 183, 140, 151, 183, 140,
366 // coeff_abs_level_greater1_flag
367 154, 196, 167, 167, 154, 152, 167, 182, 182, 134, 149, 136, 153, 121,
368 136, 122, 169, 208, 166, 167, 154, 152, 167, 182,
369 // coeff_abs_level_greater2_flag
370 107, 167, 91, 107, 107, 167,
371 // log2_res_scale_abs
372 154, 154, 154, 154, 154, 154, 154, 154,
373 // res_scale_sign_flag
375 // cu_chroma_qp_offset_flag
377 // cu_chroma_qp_offset_idx
382 static const uint8_t scan_1x1[1] = {
386 static const uint8_t horiz_scan2x2_x[4] = {
390 static const uint8_t horiz_scan2x2_y[4] = {
394 static const uint8_t horiz_scan4x4_x[16] = {
401 static const uint8_t horiz_scan4x4_y[16] = {
408 static const uint8_t horiz_scan8x8_inv[8][8] = {
409 { 0, 1, 2, 3, 16, 17, 18, 19, },
410 { 4, 5, 6, 7, 20, 21, 22, 23, },
411 { 8, 9, 10, 11, 24, 25, 26, 27, },
412 { 12, 13, 14, 15, 28, 29, 30, 31, },
413 { 32, 33, 34, 35, 48, 49, 50, 51, },
414 { 36, 37, 38, 39, 52, 53, 54, 55, },
415 { 40, 41, 42, 43, 56, 57, 58, 59, },
416 { 44, 45, 46, 47, 60, 61, 62, 63, },
419 static const uint8_t diag_scan2x2_x[4] = {
423 static const uint8_t diag_scan2x2_y[4] = {
427 static const uint8_t diag_scan2x2_inv[2][2] = {
432 static const uint8_t diag_scan4x4_inv[4][4] = {
439 static const uint8_t diag_scan8x8_inv[8][8] = {
440 { 0, 2, 5, 9, 14, 20, 27, 35, },
441 { 1, 4, 8, 13, 19, 26, 34, 42, },
442 { 3, 7, 12, 18, 25, 33, 41, 48, },
443 { 6, 11, 17, 24, 32, 40, 47, 53, },
444 { 10, 16, 23, 31, 39, 46, 52, 57, },
445 { 15, 22, 30, 38, 45, 51, 56, 60, },
446 { 21, 29, 37, 44, 50, 55, 59, 62, },
447 { 28, 36, 43, 49, 54, 58, 61, 63, },
450 void ff_hevc_save_states(HEVCContext *s, int ctb_addr_ts)
452 if (s->ps.pps->entropy_coding_sync_enabled_flag &&
453 (ctb_addr_ts % s->ps.sps->ctb_width == 2 ||
454 (s->ps.sps->ctb_width == 2 &&
455 ctb_addr_ts % s->ps.sps->ctb_width == 0))) {
456 memcpy(s->cabac_state, s->HEVClc->cabac_state, HEVC_CONTEXTS);
460 static void load_states(HEVCContext *s)
462 memcpy(s->HEVClc->cabac_state, s->cabac_state, HEVC_CONTEXTS);
465 static int cabac_reinit(HEVCLocalContext *lc)
467 return skip_bytes(&lc->cc, 0) == NULL ? AVERROR_INVALIDDATA : 0;
470 static int cabac_init_decoder(HEVCContext *s)
472 GetBitContext *gb = &s->HEVClc->gb;
475 return ff_init_cabac_decoder(&s->HEVClc->cc,
476 gb->buffer + get_bits_count(gb) / 8,
477 (get_bits_left(gb) + 7) / 8);
480 static void cabac_init_state(HEVCContext *s)
482 int init_type = 2 - s->sh.slice_type;
485 if (s->sh.cabac_init_flag && s->sh.slice_type != HEVC_SLICE_I)
488 for (i = 0; i < HEVC_CONTEXTS; i++) {
489 int init_value = init_values[init_type][i];
490 int m = (init_value >> 4) * 5 - 45;
491 int n = ((init_value & 15) << 3) - 16;
492 int pre = 2 * (((m * av_clip(s->sh.slice_qp, 0, 51)) >> 4) + n) - 127;
496 pre = 124 + (pre & 1);
497 s->HEVClc->cabac_state[i] = pre;
500 for (i = 0; i < 4; i++)
501 s->HEVClc->stat_coeff[i] = 0;
504 int ff_hevc_cabac_init(HEVCContext *s, int ctb_addr_ts)
506 if (ctb_addr_ts == s->ps.pps->ctb_addr_rs_to_ts[s->sh.slice_ctb_addr_rs]) {
507 int ret = cabac_init_decoder(s);
510 if (s->sh.dependent_slice_segment_flag == 0 ||
511 (s->ps.pps->tiles_enabled_flag &&
512 s->ps.pps->tile_id[ctb_addr_ts] != s->ps.pps->tile_id[ctb_addr_ts - 1]))
515 if (!s->sh.first_slice_in_pic_flag &&
516 s->ps.pps->entropy_coding_sync_enabled_flag) {
517 if (ctb_addr_ts % s->ps.sps->ctb_width == 0) {
518 if (s->ps.sps->ctb_width == 1)
520 else if (s->sh.dependent_slice_segment_flag == 1)
525 if (s->ps.pps->tiles_enabled_flag &&
526 s->ps.pps->tile_id[ctb_addr_ts] != s->ps.pps->tile_id[ctb_addr_ts - 1]) {
528 if (s->threads_number == 1)
529 ret = cabac_reinit(s->HEVClc);
531 ret = cabac_init_decoder(s);
537 if (s->ps.pps->entropy_coding_sync_enabled_flag) {
538 if (ctb_addr_ts % s->ps.sps->ctb_width == 0) {
540 get_cabac_terminate(&s->HEVClc->cc);
541 if (s->threads_number == 1)
542 ret = cabac_reinit(s->HEVClc);
544 ret = cabac_init_decoder(s);
549 if (s->ps.sps->ctb_width == 1)
559 #define GET_CABAC(ctx) get_cabac(&s->HEVClc->cc, &s->HEVClc->cabac_state[ctx])
561 int ff_hevc_sao_merge_flag_decode(HEVCContext *s)
563 return GET_CABAC(elem_offset[SAO_MERGE_FLAG]);
566 int ff_hevc_sao_type_idx_decode(HEVCContext *s)
568 if (!GET_CABAC(elem_offset[SAO_TYPE_IDX]))
571 if (!get_cabac_bypass(&s->HEVClc->cc))
576 int ff_hevc_sao_band_position_decode(HEVCContext *s)
579 int value = get_cabac_bypass(&s->HEVClc->cc);
581 for (i = 0; i < 4; i++)
582 value = (value << 1) | get_cabac_bypass(&s->HEVClc->cc);
586 int ff_hevc_sao_offset_abs_decode(HEVCContext *s)
589 int length = (1 << (FFMIN(s->ps.sps->bit_depth, 10) - 5)) - 1;
591 while (i < length && get_cabac_bypass(&s->HEVClc->cc))
596 int ff_hevc_sao_offset_sign_decode(HEVCContext *s)
598 return get_cabac_bypass(&s->HEVClc->cc);
601 int ff_hevc_sao_eo_class_decode(HEVCContext *s)
603 int ret = get_cabac_bypass(&s->HEVClc->cc) << 1;
604 ret |= get_cabac_bypass(&s->HEVClc->cc);
608 int ff_hevc_end_of_slice_flag_decode(HEVCContext *s)
610 return get_cabac_terminate(&s->HEVClc->cc);
613 int ff_hevc_cu_transquant_bypass_flag_decode(HEVCContext *s)
615 return GET_CABAC(elem_offset[CU_TRANSQUANT_BYPASS_FLAG]);
618 int ff_hevc_skip_flag_decode(HEVCContext *s, int x0, int y0, int x_cb, int y_cb)
620 int min_cb_width = s->ps.sps->min_cb_width;
622 int x0b = av_mod_uintp2(x0, s->ps.sps->log2_ctb_size);
623 int y0b = av_mod_uintp2(y0, s->ps.sps->log2_ctb_size);
625 if (s->HEVClc->ctb_left_flag || x0b)
626 inc = !!SAMPLE_CTB(s->skip_flag, x_cb - 1, y_cb);
627 if (s->HEVClc->ctb_up_flag || y0b)
628 inc += !!SAMPLE_CTB(s->skip_flag, x_cb, y_cb - 1);
630 return GET_CABAC(elem_offset[SKIP_FLAG] + inc);
633 int ff_hevc_cu_qp_delta_abs(HEVCContext *s)
639 while (prefix_val < 5 && GET_CABAC(elem_offset[CU_QP_DELTA] + inc)) {
643 if (prefix_val >= 5) {
645 while (k < CABAC_MAX_BIN && get_cabac_bypass(&s->HEVClc->cc)) {
646 suffix_val += 1 << k;
649 if (k == CABAC_MAX_BIN)
650 av_log(s->avctx, AV_LOG_ERROR, "CABAC_MAX_BIN : %d\n", k);
653 suffix_val += get_cabac_bypass(&s->HEVClc->cc) << k;
655 return prefix_val + suffix_val;
658 int ff_hevc_cu_qp_delta_sign_flag(HEVCContext *s)
660 return get_cabac_bypass(&s->HEVClc->cc);
663 int ff_hevc_cu_chroma_qp_offset_flag(HEVCContext *s)
665 return GET_CABAC(elem_offset[CU_CHROMA_QP_OFFSET_FLAG]);
668 int ff_hevc_cu_chroma_qp_offset_idx(HEVCContext *s)
670 int c_max= FFMAX(5, s->ps.pps->chroma_qp_offset_list_len_minus1);
673 while (i < c_max && GET_CABAC(elem_offset[CU_CHROMA_QP_OFFSET_IDX]))
679 int ff_hevc_pred_mode_decode(HEVCContext *s)
681 return GET_CABAC(elem_offset[PRED_MODE_FLAG]);
684 int ff_hevc_split_coding_unit_flag_decode(HEVCContext *s, int ct_depth, int x0, int y0)
686 int inc = 0, depth_left = 0, depth_top = 0;
687 int x0b = av_mod_uintp2(x0, s->ps.sps->log2_ctb_size);
688 int y0b = av_mod_uintp2(y0, s->ps.sps->log2_ctb_size);
689 int x_cb = x0 >> s->ps.sps->log2_min_cb_size;
690 int y_cb = y0 >> s->ps.sps->log2_min_cb_size;
692 if (s->HEVClc->ctb_left_flag || x0b)
693 depth_left = s->tab_ct_depth[(y_cb) * s->ps.sps->min_cb_width + x_cb - 1];
694 if (s->HEVClc->ctb_up_flag || y0b)
695 depth_top = s->tab_ct_depth[(y_cb - 1) * s->ps.sps->min_cb_width + x_cb];
697 inc += (depth_left > ct_depth);
698 inc += (depth_top > ct_depth);
700 return GET_CABAC(elem_offset[SPLIT_CODING_UNIT_FLAG] + inc);
703 int ff_hevc_part_mode_decode(HEVCContext *s, int log2_cb_size)
705 if (GET_CABAC(elem_offset[PART_MODE])) // 1
707 if (log2_cb_size == s->ps.sps->log2_min_cb_size) {
708 if (s->HEVClc->cu.pred_mode == MODE_INTRA) // 0
710 if (GET_CABAC(elem_offset[PART_MODE] + 1)) // 01
712 if (log2_cb_size == 3) // 00
714 if (GET_CABAC(elem_offset[PART_MODE] + 2)) // 001
716 return PART_NxN; // 000
719 if (!s->ps.sps->amp_enabled_flag) {
720 if (GET_CABAC(elem_offset[PART_MODE] + 1)) // 01
725 if (GET_CABAC(elem_offset[PART_MODE] + 1)) { // 01X, 01XX
726 if (GET_CABAC(elem_offset[PART_MODE] + 3)) // 011
728 if (get_cabac_bypass(&s->HEVClc->cc)) // 0101
730 return PART_2NxnU; // 0100
733 if (GET_CABAC(elem_offset[PART_MODE] + 3)) // 001
735 if (get_cabac_bypass(&s->HEVClc->cc)) // 0001
737 return PART_nLx2N; // 0000
740 int ff_hevc_pcm_flag_decode(HEVCContext *s)
742 return get_cabac_terminate(&s->HEVClc->cc);
745 int ff_hevc_prev_intra_luma_pred_flag_decode(HEVCContext *s)
747 return GET_CABAC(elem_offset[PREV_INTRA_LUMA_PRED_FLAG]);
750 int ff_hevc_mpm_idx_decode(HEVCContext *s)
753 while (i < 2 && get_cabac_bypass(&s->HEVClc->cc))
758 int ff_hevc_rem_intra_luma_pred_mode_decode(HEVCContext *s)
761 int value = get_cabac_bypass(&s->HEVClc->cc);
763 for (i = 0; i < 4; i++)
764 value = (value << 1) | get_cabac_bypass(&s->HEVClc->cc);
768 int ff_hevc_intra_chroma_pred_mode_decode(HEVCContext *s)
771 if (!GET_CABAC(elem_offset[INTRA_CHROMA_PRED_MODE]))
774 ret = get_cabac_bypass(&s->HEVClc->cc) << 1;
775 ret |= get_cabac_bypass(&s->HEVClc->cc);
779 int ff_hevc_merge_idx_decode(HEVCContext *s)
781 int i = GET_CABAC(elem_offset[MERGE_IDX]);
784 while (i < s->sh.max_num_merge_cand-1 && get_cabac_bypass(&s->HEVClc->cc))
790 int ff_hevc_merge_flag_decode(HEVCContext *s)
792 return GET_CABAC(elem_offset[MERGE_FLAG]);
795 int ff_hevc_inter_pred_idc_decode(HEVCContext *s, int nPbW, int nPbH)
797 if (nPbW + nPbH == 12)
798 return GET_CABAC(elem_offset[INTER_PRED_IDC] + 4);
799 if (GET_CABAC(elem_offset[INTER_PRED_IDC] + s->HEVClc->ct_depth))
802 return GET_CABAC(elem_offset[INTER_PRED_IDC] + 4);
805 int ff_hevc_ref_idx_lx_decode(HEVCContext *s, int num_ref_idx_lx)
808 int max = num_ref_idx_lx - 1;
809 int max_ctx = FFMIN(max, 2);
811 while (i < max_ctx && GET_CABAC(elem_offset[REF_IDX_L0] + i))
814 while (i < max && get_cabac_bypass(&s->HEVClc->cc))
821 int ff_hevc_mvp_lx_flag_decode(HEVCContext *s)
823 return GET_CABAC(elem_offset[MVP_LX_FLAG]);
826 int ff_hevc_no_residual_syntax_flag_decode(HEVCContext *s)
828 return GET_CABAC(elem_offset[NO_RESIDUAL_DATA_FLAG]);
831 static av_always_inline int abs_mvd_greater0_flag_decode(HEVCContext *s)
833 return GET_CABAC(elem_offset[ABS_MVD_GREATER0_FLAG]);
836 static av_always_inline int abs_mvd_greater1_flag_decode(HEVCContext *s)
838 return GET_CABAC(elem_offset[ABS_MVD_GREATER1_FLAG] + 1);
841 static av_always_inline int mvd_decode(HEVCContext *s)
846 while (k < CABAC_MAX_BIN && get_cabac_bypass(&s->HEVClc->cc)) {
850 if (k == CABAC_MAX_BIN) {
851 av_log(s->avctx, AV_LOG_ERROR, "CABAC_MAX_BIN : %d\n", k);
855 ret += get_cabac_bypass(&s->HEVClc->cc) << k;
856 return get_cabac_bypass_sign(&s->HEVClc->cc, -ret);
859 static av_always_inline int mvd_sign_flag_decode(HEVCContext *s)
861 return get_cabac_bypass_sign(&s->HEVClc->cc, -1);
864 int ff_hevc_split_transform_flag_decode(HEVCContext *s, int log2_trafo_size)
866 return GET_CABAC(elem_offset[SPLIT_TRANSFORM_FLAG] + 5 - log2_trafo_size);
869 int ff_hevc_cbf_cb_cr_decode(HEVCContext *s, int trafo_depth)
871 return GET_CABAC(elem_offset[CBF_CB_CR] + trafo_depth);
874 int ff_hevc_cbf_luma_decode(HEVCContext *s, int trafo_depth)
876 return GET_CABAC(elem_offset[CBF_LUMA] + !trafo_depth);
879 static int hevc_transform_skip_flag_decode(HEVCContext *s, int c_idx)
881 return GET_CABAC(elem_offset[TRANSFORM_SKIP_FLAG] + !!c_idx);
884 static int explicit_rdpcm_flag_decode(HEVCContext *s, int c_idx)
886 return GET_CABAC(elem_offset[EXPLICIT_RDPCM_FLAG] + !!c_idx);
889 static int explicit_rdpcm_dir_flag_decode(HEVCContext *s, int c_idx)
891 return GET_CABAC(elem_offset[EXPLICIT_RDPCM_DIR_FLAG] + !!c_idx);
894 int ff_hevc_log2_res_scale_abs(HEVCContext *s, int idx) {
897 while (i < 4 && GET_CABAC(elem_offset[LOG2_RES_SCALE_ABS] + 4 * idx + i))
903 int ff_hevc_res_scale_sign_flag(HEVCContext *s, int idx) {
904 return GET_CABAC(elem_offset[RES_SCALE_SIGN_FLAG] + idx);
907 static av_always_inline void last_significant_coeff_xy_prefix_decode(HEVCContext *s, int c_idx,
908 int log2_size, int *last_scx_prefix, int *last_scy_prefix)
911 int max = (log2_size << 1) - 1;
912 int ctx_offset, ctx_shift;
915 ctx_offset = 3 * (log2_size - 2) + ((log2_size - 1) >> 2);
916 ctx_shift = (log2_size + 1) >> 2;
919 ctx_shift = log2_size - 2;
922 GET_CABAC(elem_offset[LAST_SIGNIFICANT_COEFF_X_PREFIX] + (i >> ctx_shift) + ctx_offset))
924 *last_scx_prefix = i;
928 GET_CABAC(elem_offset[LAST_SIGNIFICANT_COEFF_Y_PREFIX] + (i >> ctx_shift) + ctx_offset))
930 *last_scy_prefix = i;
933 static av_always_inline int last_significant_coeff_suffix_decode(HEVCContext *s,
934 int last_significant_coeff_prefix)
937 int length = (last_significant_coeff_prefix >> 1) - 1;
938 int value = get_cabac_bypass(&s->HEVClc->cc);
940 for (i = 1; i < length; i++)
941 value = (value << 1) | get_cabac_bypass(&s->HEVClc->cc);
945 static av_always_inline int significant_coeff_group_flag_decode(HEVCContext *s, int c_idx, int ctx_cg)
949 inc = FFMIN(ctx_cg, 1) + (c_idx>0 ? 2 : 0);
951 return GET_CABAC(elem_offset[SIGNIFICANT_COEFF_GROUP_FLAG] + inc);
953 static av_always_inline int significant_coeff_flag_decode(HEVCContext *s, int x_c, int y_c,
954 int offset, const uint8_t *ctx_idx_map)
956 int inc = ctx_idx_map[(y_c << 2) + x_c] + offset;
957 return GET_CABAC(elem_offset[SIGNIFICANT_COEFF_FLAG] + inc);
960 static av_always_inline int significant_coeff_flag_decode_0(HEVCContext *s, int c_idx, int offset)
962 return GET_CABAC(elem_offset[SIGNIFICANT_COEFF_FLAG] + offset);
965 static av_always_inline int coeff_abs_level_greater1_flag_decode(HEVCContext *s, int c_idx, int inc)
971 return GET_CABAC(elem_offset[COEFF_ABS_LEVEL_GREATER1_FLAG] + inc);
974 static av_always_inline int coeff_abs_level_greater2_flag_decode(HEVCContext *s, int c_idx, int inc)
979 return GET_CABAC(elem_offset[COEFF_ABS_LEVEL_GREATER2_FLAG] + inc);
982 static av_always_inline int coeff_abs_level_remaining_decode(HEVCContext *s, int rc_rice_param)
986 int last_coeff_abs_level_remaining;
989 while (prefix < CABAC_MAX_BIN && get_cabac_bypass(&s->HEVClc->cc))
991 if (prefix == CABAC_MAX_BIN) {
992 av_log(s->avctx, AV_LOG_ERROR, "CABAC_MAX_BIN : %d\n", prefix);
996 for (i = 0; i < rc_rice_param; i++)
997 suffix = (suffix << 1) | get_cabac_bypass(&s->HEVClc->cc);
998 last_coeff_abs_level_remaining = (prefix << rc_rice_param) + suffix;
1000 int prefix_minus3 = prefix - 3;
1001 for (i = 0; i < prefix_minus3 + rc_rice_param; i++)
1002 suffix = (suffix << 1) | get_cabac_bypass(&s->HEVClc->cc);
1003 last_coeff_abs_level_remaining = (((1 << prefix_minus3) + 3 - 1)
1004 << rc_rice_param) + suffix;
1006 return last_coeff_abs_level_remaining;
1009 static av_always_inline int coeff_sign_flag_decode(HEVCContext *s, uint8_t nb)
1014 for (i = 0; i < nb; i++)
1015 ret = (ret << 1) | get_cabac_bypass(&s->HEVClc->cc);
1019 void ff_hevc_hls_residual_coding(HEVCContext *s, int x0, int y0,
1020 int log2_trafo_size, enum ScanType scan_idx,
1023 #define GET_COORD(offset, n) \
1025 x_c = (x_cg << 2) + scan_x_off[n]; \
1026 y_c = (y_cg << 2) + scan_y_off[n]; \
1028 HEVCLocalContext *lc = s->HEVClc;
1029 int transform_skip_flag = 0;
1031 int last_significant_coeff_x, last_significant_coeff_y;
1035 int greater1_ctx = 1;
1037 int num_last_subset;
1038 int x_cg_last_sig, y_cg_last_sig;
1040 const uint8_t *scan_x_cg, *scan_y_cg, *scan_x_off, *scan_y_off;
1042 ptrdiff_t stride = s->frame->linesize[c_idx];
1043 int hshift = s->ps.sps->hshift[c_idx];
1044 int vshift = s->ps.sps->vshift[c_idx];
1045 uint8_t *dst = &s->frame->data[c_idx][(y0 >> vshift) * stride +
1046 ((x0 >> hshift) << s->ps.sps->pixel_shift)];
1047 int16_t *coeffs = (int16_t*)(c_idx ? lc->edge_emu_buffer2 : lc->edge_emu_buffer);
1048 uint8_t significant_coeff_group_flag[8][8] = {{0}};
1049 int explicit_rdpcm_flag = 0;
1050 int explicit_rdpcm_dir_flag;
1052 int trafo_size = 1 << log2_trafo_size;
1054 int qp,shift,add,scale,scale_m;
1055 static const uint8_t level_scale[] = { 40, 45, 51, 57, 64, 72 };
1056 const uint8_t *scale_matrix = NULL;
1058 int pred_mode_intra = (c_idx == 0) ? lc->tu.intra_pred_mode :
1059 lc->tu.intra_pred_mode_c;
1061 memset(coeffs, 0, trafo_size * trafo_size * sizeof(int16_t));
1063 // Derive QP for dequant
1064 if (!lc->cu.cu_transquant_bypass_flag) {
1065 static const int qp_c[] = { 29, 30, 31, 32, 33, 33, 34, 34, 35, 35, 36, 36, 37, 37 };
1066 static const uint8_t rem6[51 + 4 * 6 + 1] = {
1067 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2,
1068 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5,
1069 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3,
1070 4, 5, 0, 1, 2, 3, 4, 5, 0, 1
1073 static const uint8_t div6[51 + 4 * 6 + 1] = {
1074 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 3, 3, 3,
1075 3, 3, 3, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6,
1076 7, 7, 7, 7, 7, 7, 8, 8, 8, 8, 8, 8, 9, 9, 9, 9, 9, 9, 10, 10, 10, 10,
1077 10, 10, 11, 11, 11, 11, 11, 11, 12, 12
1079 int qp_y = lc->qp_y;
1081 if (s->ps.pps->transform_skip_enabled_flag &&
1082 log2_trafo_size <= s->ps.pps->log2_max_transform_skip_block_size) {
1083 transform_skip_flag = hevc_transform_skip_flag_decode(s, c_idx);
1087 qp = qp_y + s->ps.sps->qp_bd_offset;
1092 offset = s->ps.pps->cb_qp_offset + s->sh.slice_cb_qp_offset +
1093 lc->tu.cu_qp_offset_cb;
1095 offset = s->ps.pps->cr_qp_offset + s->sh.slice_cr_qp_offset +
1096 lc->tu.cu_qp_offset_cr;
1098 qp_i = av_clip(qp_y + offset, - s->ps.sps->qp_bd_offset, 57);
1099 if (s->ps.sps->chroma_format_idc == 1) {
1105 qp = qp_c[qp_i - 30];
1113 qp += s->ps.sps->qp_bd_offset;
1116 shift = s->ps.sps->bit_depth + log2_trafo_size - 5;
1117 add = 1 << (shift-1);
1118 scale = level_scale[rem6[qp]] << (div6[qp]);
1119 scale_m = 16; // default when no custom scaling lists.
1122 if (s->ps.sps->scaling_list_enable_flag && !(transform_skip_flag && log2_trafo_size > 2)) {
1123 const ScalingList *sl = s->ps.pps->scaling_list_data_present_flag ?
1124 &s->ps.pps->scaling_list : &s->ps.sps->scaling_list;
1125 int matrix_id = lc->cu.pred_mode != MODE_INTRA;
1127 matrix_id = 3 * matrix_id + c_idx;
1129 scale_matrix = sl->sl[log2_trafo_size - 2][matrix_id];
1130 if (log2_trafo_size >= 4)
1131 dc_scale = sl->sl_dc[log2_trafo_size - 4][matrix_id];
1140 if (lc->cu.pred_mode == MODE_INTER && s->ps.sps->explicit_rdpcm_enabled_flag &&
1141 (transform_skip_flag || lc->cu.cu_transquant_bypass_flag)) {
1142 explicit_rdpcm_flag = explicit_rdpcm_flag_decode(s, c_idx);
1143 if (explicit_rdpcm_flag) {
1144 explicit_rdpcm_dir_flag = explicit_rdpcm_dir_flag_decode(s, c_idx);
1148 last_significant_coeff_xy_prefix_decode(s, c_idx, log2_trafo_size,
1149 &last_significant_coeff_x, &last_significant_coeff_y);
1151 if (last_significant_coeff_x > 3) {
1152 int suffix = last_significant_coeff_suffix_decode(s, last_significant_coeff_x);
1153 last_significant_coeff_x = (1 << ((last_significant_coeff_x >> 1) - 1)) *
1154 (2 + (last_significant_coeff_x & 1)) +
1158 if (last_significant_coeff_y > 3) {
1159 int suffix = last_significant_coeff_suffix_decode(s, last_significant_coeff_y);
1160 last_significant_coeff_y = (1 << ((last_significant_coeff_y >> 1) - 1)) *
1161 (2 + (last_significant_coeff_y & 1)) +
1165 if (scan_idx == SCAN_VERT)
1166 FFSWAP(int, last_significant_coeff_x, last_significant_coeff_y);
1168 x_cg_last_sig = last_significant_coeff_x >> 2;
1169 y_cg_last_sig = last_significant_coeff_y >> 2;
1173 int last_x_c = last_significant_coeff_x & 3;
1174 int last_y_c = last_significant_coeff_y & 3;
1176 scan_x_off = ff_hevc_diag_scan4x4_x;
1177 scan_y_off = ff_hevc_diag_scan4x4_y;
1178 num_coeff = diag_scan4x4_inv[last_y_c][last_x_c];
1179 if (trafo_size == 4) {
1180 scan_x_cg = scan_1x1;
1181 scan_y_cg = scan_1x1;
1182 } else if (trafo_size == 8) {
1183 num_coeff += diag_scan2x2_inv[y_cg_last_sig][x_cg_last_sig] << 4;
1184 scan_x_cg = diag_scan2x2_x;
1185 scan_y_cg = diag_scan2x2_y;
1186 } else if (trafo_size == 16) {
1187 num_coeff += diag_scan4x4_inv[y_cg_last_sig][x_cg_last_sig] << 4;
1188 scan_x_cg = ff_hevc_diag_scan4x4_x;
1189 scan_y_cg = ff_hevc_diag_scan4x4_y;
1190 } else { // trafo_size == 32
1191 num_coeff += diag_scan8x8_inv[y_cg_last_sig][x_cg_last_sig] << 4;
1192 scan_x_cg = ff_hevc_diag_scan8x8_x;
1193 scan_y_cg = ff_hevc_diag_scan8x8_y;
1198 scan_x_cg = horiz_scan2x2_x;
1199 scan_y_cg = horiz_scan2x2_y;
1200 scan_x_off = horiz_scan4x4_x;
1201 scan_y_off = horiz_scan4x4_y;
1202 num_coeff = horiz_scan8x8_inv[last_significant_coeff_y][last_significant_coeff_x];
1204 default: //SCAN_VERT
1205 scan_x_cg = horiz_scan2x2_y;
1206 scan_y_cg = horiz_scan2x2_x;
1207 scan_x_off = horiz_scan4x4_y;
1208 scan_y_off = horiz_scan4x4_x;
1209 num_coeff = horiz_scan8x8_inv[last_significant_coeff_x][last_significant_coeff_y];
1213 num_last_subset = (num_coeff - 1) >> 4;
1215 for (i = num_last_subset; i >= 0; i--) {
1217 int x_cg, y_cg, x_c, y_c, pos;
1218 int implicit_non_zero_coeff = 0;
1219 int64_t trans_coeff_level;
1221 int offset = i << 4;
1224 uint8_t significant_coeff_flag_idx[16];
1225 uint8_t nb_significant_coeff_flag = 0;
1227 x_cg = scan_x_cg[i];
1228 y_cg = scan_y_cg[i];
1230 if ((i < num_last_subset) && (i > 0)) {
1232 if (x_cg < (1 << (log2_trafo_size - 2)) - 1)
1233 ctx_cg += significant_coeff_group_flag[x_cg + 1][y_cg];
1234 if (y_cg < (1 << (log2_trafo_size - 2)) - 1)
1235 ctx_cg += significant_coeff_group_flag[x_cg][y_cg + 1];
1237 significant_coeff_group_flag[x_cg][y_cg] =
1238 significant_coeff_group_flag_decode(s, c_idx, ctx_cg);
1239 implicit_non_zero_coeff = 1;
1241 significant_coeff_group_flag[x_cg][y_cg] =
1242 ((x_cg == x_cg_last_sig && y_cg == y_cg_last_sig) ||
1243 (x_cg == 0 && y_cg == 0));
1246 last_scan_pos = num_coeff - offset - 1;
1248 if (i == num_last_subset) {
1249 n_end = last_scan_pos - 1;
1250 significant_coeff_flag_idx[0] = last_scan_pos;
1251 nb_significant_coeff_flag = 1;
1256 if (x_cg < ((1 << log2_trafo_size) - 1) >> 2)
1257 prev_sig = !!significant_coeff_group_flag[x_cg + 1][y_cg];
1258 if (y_cg < ((1 << log2_trafo_size) - 1) >> 2)
1259 prev_sig += (!!significant_coeff_group_flag[x_cg][y_cg + 1] << 1);
1261 if (significant_coeff_group_flag[x_cg][y_cg] && n_end >= 0) {
1262 static const uint8_t ctx_idx_map[] = {
1263 0, 1, 4, 5, 2, 3, 4, 5, 6, 6, 8, 8, 7, 7, 8, 8, // log2_trafo_size == 2
1264 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, // prev_sig == 0
1265 2, 2, 2, 2, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, // prev_sig == 1
1266 2, 1, 0, 0, 2, 1, 0, 0, 2, 1, 0, 0, 2, 1, 0, 0, // prev_sig == 2
1267 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2 // default
1269 const uint8_t *ctx_idx_map_p;
1271 if (s->ps.sps->transform_skip_context_enabled_flag &&
1272 (transform_skip_flag || lc->cu.cu_transquant_bypass_flag)) {
1273 ctx_idx_map_p = (uint8_t*) &ctx_idx_map[4 * 16];
1277 scf_offset = 14 + 27;
1282 if (log2_trafo_size == 2) {
1283 ctx_idx_map_p = (uint8_t*) &ctx_idx_map[0];
1285 ctx_idx_map_p = (uint8_t*) &ctx_idx_map[(prev_sig + 1) << 4];
1287 if ((x_cg > 0 || y_cg > 0))
1289 if (log2_trafo_size == 3) {
1290 scf_offset += (scan_idx == SCAN_DIAG) ? 9 : 15;
1295 if (log2_trafo_size == 3)
1302 for (n = n_end; n > 0; n--) {
1303 x_c = scan_x_off[n];
1304 y_c = scan_y_off[n];
1305 if (significant_coeff_flag_decode(s, x_c, y_c, scf_offset, ctx_idx_map_p)) {
1306 significant_coeff_flag_idx[nb_significant_coeff_flag] = n;
1307 nb_significant_coeff_flag++;
1308 implicit_non_zero_coeff = 0;
1311 if (implicit_non_zero_coeff == 0) {
1312 if (s->ps.sps->transform_skip_context_enabled_flag &&
1313 (transform_skip_flag || lc->cu.cu_transquant_bypass_flag)) {
1317 scf_offset = 16 + 27;
1326 scf_offset = 2 + scf_offset;
1329 if (significant_coeff_flag_decode_0(s, c_idx, scf_offset) == 1) {
1330 significant_coeff_flag_idx[nb_significant_coeff_flag] = 0;
1331 nb_significant_coeff_flag++;
1334 significant_coeff_flag_idx[nb_significant_coeff_flag] = 0;
1335 nb_significant_coeff_flag++;
1339 n_end = nb_significant_coeff_flag;
1343 int first_nz_pos_in_cg;
1344 int last_nz_pos_in_cg;
1345 int c_rice_param = 0;
1346 int first_greater1_coeff_idx = -1;
1347 uint8_t coeff_abs_level_greater1_flag[8];
1348 uint16_t coeff_sign_flag;
1354 // initialize first elem of coeff_bas_level_greater1_flag
1355 int ctx_set = (i > 0 && c_idx == 0) ? 2 : 0;
1357 if (s->ps.sps->persistent_rice_adaptation_enabled_flag) {
1358 if (!transform_skip_flag && !lc->cu.cu_transquant_bypass_flag)
1359 sb_type = 2 * (c_idx == 0 ? 1 : 0);
1361 sb_type = 2 * (c_idx == 0 ? 1 : 0) + 1;
1362 c_rice_param = lc->stat_coeff[sb_type] / 4;
1365 if (!(i == num_last_subset) && greater1_ctx == 0)
1368 last_nz_pos_in_cg = significant_coeff_flag_idx[0];
1370 for (m = 0; m < (n_end > 8 ? 8 : n_end); m++) {
1371 int inc = (ctx_set << 2) + greater1_ctx;
1372 coeff_abs_level_greater1_flag[m] =
1373 coeff_abs_level_greater1_flag_decode(s, c_idx, inc);
1374 if (coeff_abs_level_greater1_flag[m]) {
1376 if (first_greater1_coeff_idx == -1)
1377 first_greater1_coeff_idx = m;
1378 } else if (greater1_ctx > 0 && greater1_ctx < 3) {
1382 first_nz_pos_in_cg = significant_coeff_flag_idx[n_end - 1];
1384 if (lc->cu.cu_transquant_bypass_flag ||
1385 (lc->cu.pred_mode == MODE_INTRA &&
1386 s->ps.sps->implicit_rdpcm_enabled_flag && transform_skip_flag &&
1387 (pred_mode_intra == 10 || pred_mode_intra == 26 )) ||
1388 explicit_rdpcm_flag)
1391 sign_hidden = (last_nz_pos_in_cg - first_nz_pos_in_cg >= 4);
1393 if (first_greater1_coeff_idx != -1) {
1394 coeff_abs_level_greater1_flag[first_greater1_coeff_idx] += coeff_abs_level_greater2_flag_decode(s, c_idx, ctx_set);
1396 if (!s->ps.pps->sign_data_hiding_flag || !sign_hidden ) {
1397 coeff_sign_flag = coeff_sign_flag_decode(s, nb_significant_coeff_flag) << (16 - nb_significant_coeff_flag);
1399 coeff_sign_flag = coeff_sign_flag_decode(s, nb_significant_coeff_flag - 1) << (16 - (nb_significant_coeff_flag - 1));
1402 for (m = 0; m < n_end; m++) {
1403 n = significant_coeff_flag_idx[m];
1404 GET_COORD(offset, n);
1406 trans_coeff_level = 1 + coeff_abs_level_greater1_flag[m];
1407 if (trans_coeff_level == ((m == first_greater1_coeff_idx) ? 3 : 2)) {
1408 int last_coeff_abs_level_remaining = coeff_abs_level_remaining_decode(s, c_rice_param);
1410 trans_coeff_level += last_coeff_abs_level_remaining;
1411 if (trans_coeff_level > (3 << c_rice_param))
1412 c_rice_param = s->ps.sps->persistent_rice_adaptation_enabled_flag ? c_rice_param + 1 : FFMIN(c_rice_param + 1, 4);
1413 if (s->ps.sps->persistent_rice_adaptation_enabled_flag && !rice_init) {
1414 int c_rice_p_init = lc->stat_coeff[sb_type] / 4;
1415 if (last_coeff_abs_level_remaining >= (3 << c_rice_p_init))
1416 lc->stat_coeff[sb_type]++;
1417 else if (2 * last_coeff_abs_level_remaining < (1 << c_rice_p_init))
1418 if (lc->stat_coeff[sb_type] > 0)
1419 lc->stat_coeff[sb_type]--;
1424 int last_coeff_abs_level_remaining = coeff_abs_level_remaining_decode(s, c_rice_param);
1426 trans_coeff_level = 1 + last_coeff_abs_level_remaining;
1427 if (trans_coeff_level > (3 << c_rice_param))
1428 c_rice_param = s->ps.sps->persistent_rice_adaptation_enabled_flag ? c_rice_param + 1 : FFMIN(c_rice_param + 1, 4);
1429 if (s->ps.sps->persistent_rice_adaptation_enabled_flag && !rice_init) {
1430 int c_rice_p_init = lc->stat_coeff[sb_type] / 4;
1431 if (last_coeff_abs_level_remaining >= (3 << c_rice_p_init))
1432 lc->stat_coeff[sb_type]++;
1433 else if (2 * last_coeff_abs_level_remaining < (1 << c_rice_p_init))
1434 if (lc->stat_coeff[sb_type] > 0)
1435 lc->stat_coeff[sb_type]--;
1439 if (s->ps.pps->sign_data_hiding_flag && sign_hidden) {
1440 sum_abs += trans_coeff_level;
1441 if (n == first_nz_pos_in_cg && (sum_abs&1))
1442 trans_coeff_level = -trans_coeff_level;
1444 if (coeff_sign_flag >> 15)
1445 trans_coeff_level = -trans_coeff_level;
1446 coeff_sign_flag <<= 1;
1447 if(!lc->cu.cu_transquant_bypass_flag) {
1448 if (s->ps.sps->scaling_list_enable_flag && !(transform_skip_flag && log2_trafo_size > 2)) {
1449 if(y_c || x_c || log2_trafo_size < 4) {
1450 switch(log2_trafo_size) {
1451 case 3: pos = (y_c << 3) + x_c; break;
1452 case 4: pos = ((y_c >> 1) << 3) + (x_c >> 1); break;
1453 case 5: pos = ((y_c >> 2) << 3) + (x_c >> 2); break;
1454 default: pos = (y_c << 2) + x_c; break;
1456 scale_m = scale_matrix[pos];
1461 trans_coeff_level = (trans_coeff_level * (int64_t)scale * (int64_t)scale_m + add) >> shift;
1462 if(trans_coeff_level < 0) {
1463 if((~trans_coeff_level) & 0xFffffffffff8000)
1464 trans_coeff_level = -32768;
1466 if(trans_coeff_level & 0xffffffffffff8000)
1467 trans_coeff_level = 32767;
1470 coeffs[y_c * trafo_size + x_c] = trans_coeff_level;
1475 if (lc->cu.cu_transquant_bypass_flag) {
1476 if (explicit_rdpcm_flag || (s->ps.sps->implicit_rdpcm_enabled_flag &&
1477 (pred_mode_intra == 10 || pred_mode_intra == 26))) {
1478 int mode = s->ps.sps->implicit_rdpcm_enabled_flag ? (pred_mode_intra == 26) : explicit_rdpcm_dir_flag;
1480 s->hevcdsp.transform_rdpcm(coeffs, log2_trafo_size, mode);
1483 if (transform_skip_flag) {
1484 int rot = s->ps.sps->transform_skip_rotation_enabled_flag &&
1485 log2_trafo_size == 2 &&
1486 lc->cu.pred_mode == MODE_INTRA;
1488 for (i = 0; i < 8; i++)
1489 FFSWAP(int16_t, coeffs[i], coeffs[16 - i - 1]);
1492 s->hevcdsp.dequant(coeffs, log2_trafo_size);
1494 if (explicit_rdpcm_flag || (s->ps.sps->implicit_rdpcm_enabled_flag &&
1495 lc->cu.pred_mode == MODE_INTRA &&
1496 (pred_mode_intra == 10 || pred_mode_intra == 26))) {
1497 int mode = explicit_rdpcm_flag ? explicit_rdpcm_dir_flag : (pred_mode_intra == 26);
1499 s->hevcdsp.transform_rdpcm(coeffs, log2_trafo_size, mode);
1501 } else if (lc->cu.pred_mode == MODE_INTRA && c_idx == 0 && log2_trafo_size == 2) {
1502 s->hevcdsp.transform_4x4_luma(coeffs);
1504 int max_xy = FFMAX(last_significant_coeff_x, last_significant_coeff_y);
1506 s->hevcdsp.idct_dc[log2_trafo_size - 2](coeffs);
1508 int col_limit = last_significant_coeff_x + last_significant_coeff_y + 4;
1510 col_limit = FFMIN(4, col_limit);
1511 else if (max_xy < 8)
1512 col_limit = FFMIN(8, col_limit);
1513 else if (max_xy < 12)
1514 col_limit = FFMIN(24, col_limit);
1515 s->hevcdsp.idct[log2_trafo_size - 2](coeffs, col_limit);
1519 if (lc->tu.cross_pf) {
1520 int16_t *coeffs_y = (int16_t*)lc->edge_emu_buffer;
1522 for (i = 0; i < (trafo_size * trafo_size); i++) {
1523 coeffs[i] = coeffs[i] + ((lc->tu.res_scale_val * coeffs_y[i]) >> 3);
1526 s->hevcdsp.add_residual[log2_trafo_size-2](dst, coeffs, stride);
1529 void ff_hevc_hls_mvd_coding(HEVCContext *s, int x0, int y0, int log2_cb_size)
1531 HEVCLocalContext *lc = s->HEVClc;
1532 int x = abs_mvd_greater0_flag_decode(s);
1533 int y = abs_mvd_greater0_flag_decode(s);
1536 x += abs_mvd_greater1_flag_decode(s);
1538 y += abs_mvd_greater1_flag_decode(s);
1541 case 2: lc->pu.mvd.x = mvd_decode(s); break;
1542 case 1: lc->pu.mvd.x = mvd_sign_flag_decode(s); break;
1543 case 0: lc->pu.mvd.x = 0; break;
1547 case 2: lc->pu.mvd.y = mvd_decode(s); break;
1548 case 1: lc->pu.mvd.y = mvd_sign_flag_decode(s); break;
1549 case 0: lc->pu.mvd.y = 0; break;