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 void cabac_reinit(HEVCLocalContext *lc)
467 skip_bytes(&lc->cc, 0);
470 static void cabac_init_decoder(HEVCContext *s)
472 GetBitContext *gb = &s->HEVClc->gb;
475 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 void 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 cabac_init_decoder(s);
508 if (s->sh.dependent_slice_segment_flag == 0 ||
509 (s->ps.pps->tiles_enabled_flag &&
510 s->ps.pps->tile_id[ctb_addr_ts] != s->ps.pps->tile_id[ctb_addr_ts - 1]))
513 if (!s->sh.first_slice_in_pic_flag &&
514 s->ps.pps->entropy_coding_sync_enabled_flag) {
515 if (ctb_addr_ts % s->ps.sps->ctb_width == 0) {
516 if (s->ps.sps->ctb_width == 1)
518 else if (s->sh.dependent_slice_segment_flag == 1)
523 if (s->ps.pps->tiles_enabled_flag &&
524 s->ps.pps->tile_id[ctb_addr_ts] != s->ps.pps->tile_id[ctb_addr_ts - 1]) {
525 if (s->threads_number == 1)
526 cabac_reinit(s->HEVClc);
528 cabac_init_decoder(s);
531 if (s->ps.pps->entropy_coding_sync_enabled_flag) {
532 if (ctb_addr_ts % s->ps.sps->ctb_width == 0) {
533 get_cabac_terminate(&s->HEVClc->cc);
534 if (s->threads_number == 1)
535 cabac_reinit(s->HEVClc);
537 cabac_init_decoder(s);
539 if (s->ps.sps->ctb_width == 1)
548 #define GET_CABAC(ctx) get_cabac(&s->HEVClc->cc, &s->HEVClc->cabac_state[ctx])
550 int ff_hevc_sao_merge_flag_decode(HEVCContext *s)
552 return GET_CABAC(elem_offset[SAO_MERGE_FLAG]);
555 int ff_hevc_sao_type_idx_decode(HEVCContext *s)
557 if (!GET_CABAC(elem_offset[SAO_TYPE_IDX]))
560 if (!get_cabac_bypass(&s->HEVClc->cc))
565 int ff_hevc_sao_band_position_decode(HEVCContext *s)
568 int value = get_cabac_bypass(&s->HEVClc->cc);
570 for (i = 0; i < 4; i++)
571 value = (value << 1) | get_cabac_bypass(&s->HEVClc->cc);
575 int ff_hevc_sao_offset_abs_decode(HEVCContext *s)
578 int length = (1 << (FFMIN(s->ps.sps->bit_depth, 10) - 5)) - 1;
580 while (i < length && get_cabac_bypass(&s->HEVClc->cc))
585 int ff_hevc_sao_offset_sign_decode(HEVCContext *s)
587 return get_cabac_bypass(&s->HEVClc->cc);
590 int ff_hevc_sao_eo_class_decode(HEVCContext *s)
592 int ret = get_cabac_bypass(&s->HEVClc->cc) << 1;
593 ret |= get_cabac_bypass(&s->HEVClc->cc);
597 int ff_hevc_end_of_slice_flag_decode(HEVCContext *s)
599 return get_cabac_terminate(&s->HEVClc->cc);
602 int ff_hevc_cu_transquant_bypass_flag_decode(HEVCContext *s)
604 return GET_CABAC(elem_offset[CU_TRANSQUANT_BYPASS_FLAG]);
607 int ff_hevc_skip_flag_decode(HEVCContext *s, int x0, int y0, int x_cb, int y_cb)
609 int min_cb_width = s->ps.sps->min_cb_width;
611 int x0b = av_mod_uintp2(x0, s->ps.sps->log2_ctb_size);
612 int y0b = av_mod_uintp2(y0, s->ps.sps->log2_ctb_size);
614 if (s->HEVClc->ctb_left_flag || x0b)
615 inc = !!SAMPLE_CTB(s->skip_flag, x_cb - 1, y_cb);
616 if (s->HEVClc->ctb_up_flag || y0b)
617 inc += !!SAMPLE_CTB(s->skip_flag, x_cb, y_cb - 1);
619 return GET_CABAC(elem_offset[SKIP_FLAG] + inc);
622 int ff_hevc_cu_qp_delta_abs(HEVCContext *s)
628 while (prefix_val < 5 && GET_CABAC(elem_offset[CU_QP_DELTA] + inc)) {
632 if (prefix_val >= 5) {
634 while (k < CABAC_MAX_BIN && get_cabac_bypass(&s->HEVClc->cc)) {
635 suffix_val += 1 << k;
638 if (k == CABAC_MAX_BIN)
639 av_log(s->avctx, AV_LOG_ERROR, "CABAC_MAX_BIN : %d\n", k);
642 suffix_val += get_cabac_bypass(&s->HEVClc->cc) << k;
644 return prefix_val + suffix_val;
647 int ff_hevc_cu_qp_delta_sign_flag(HEVCContext *s)
649 return get_cabac_bypass(&s->HEVClc->cc);
652 int ff_hevc_cu_chroma_qp_offset_flag(HEVCContext *s)
654 return GET_CABAC(elem_offset[CU_CHROMA_QP_OFFSET_FLAG]);
657 int ff_hevc_cu_chroma_qp_offset_idx(HEVCContext *s)
659 int c_max= FFMAX(5, s->ps.pps->chroma_qp_offset_list_len_minus1);
662 while (i < c_max && GET_CABAC(elem_offset[CU_CHROMA_QP_OFFSET_IDX]))
668 int ff_hevc_pred_mode_decode(HEVCContext *s)
670 return GET_CABAC(elem_offset[PRED_MODE_FLAG]);
673 int ff_hevc_split_coding_unit_flag_decode(HEVCContext *s, int ct_depth, int x0, int y0)
675 int inc = 0, depth_left = 0, depth_top = 0;
676 int x0b = av_mod_uintp2(x0, s->ps.sps->log2_ctb_size);
677 int y0b = av_mod_uintp2(y0, s->ps.sps->log2_ctb_size);
678 int x_cb = x0 >> s->ps.sps->log2_min_cb_size;
679 int y_cb = y0 >> s->ps.sps->log2_min_cb_size;
681 if (s->HEVClc->ctb_left_flag || x0b)
682 depth_left = s->tab_ct_depth[(y_cb) * s->ps.sps->min_cb_width + x_cb - 1];
683 if (s->HEVClc->ctb_up_flag || y0b)
684 depth_top = s->tab_ct_depth[(y_cb - 1) * s->ps.sps->min_cb_width + x_cb];
686 inc += (depth_left > ct_depth);
687 inc += (depth_top > ct_depth);
689 return GET_CABAC(elem_offset[SPLIT_CODING_UNIT_FLAG] + inc);
692 int ff_hevc_part_mode_decode(HEVCContext *s, int log2_cb_size)
694 if (GET_CABAC(elem_offset[PART_MODE])) // 1
696 if (log2_cb_size == s->ps.sps->log2_min_cb_size) {
697 if (s->HEVClc->cu.pred_mode == MODE_INTRA) // 0
699 if (GET_CABAC(elem_offset[PART_MODE] + 1)) // 01
701 if (log2_cb_size == 3) // 00
703 if (GET_CABAC(elem_offset[PART_MODE] + 2)) // 001
705 return PART_NxN; // 000
708 if (!s->ps.sps->amp_enabled_flag) {
709 if (GET_CABAC(elem_offset[PART_MODE] + 1)) // 01
714 if (GET_CABAC(elem_offset[PART_MODE] + 1)) { // 01X, 01XX
715 if (GET_CABAC(elem_offset[PART_MODE] + 3)) // 011
717 if (get_cabac_bypass(&s->HEVClc->cc)) // 0101
719 return PART_2NxnU; // 0100
722 if (GET_CABAC(elem_offset[PART_MODE] + 3)) // 001
724 if (get_cabac_bypass(&s->HEVClc->cc)) // 0001
726 return PART_nLx2N; // 0000
729 int ff_hevc_pcm_flag_decode(HEVCContext *s)
731 return get_cabac_terminate(&s->HEVClc->cc);
734 int ff_hevc_prev_intra_luma_pred_flag_decode(HEVCContext *s)
736 return GET_CABAC(elem_offset[PREV_INTRA_LUMA_PRED_FLAG]);
739 int ff_hevc_mpm_idx_decode(HEVCContext *s)
742 while (i < 2 && get_cabac_bypass(&s->HEVClc->cc))
747 int ff_hevc_rem_intra_luma_pred_mode_decode(HEVCContext *s)
750 int value = get_cabac_bypass(&s->HEVClc->cc);
752 for (i = 0; i < 4; i++)
753 value = (value << 1) | get_cabac_bypass(&s->HEVClc->cc);
757 int ff_hevc_intra_chroma_pred_mode_decode(HEVCContext *s)
760 if (!GET_CABAC(elem_offset[INTRA_CHROMA_PRED_MODE]))
763 ret = get_cabac_bypass(&s->HEVClc->cc) << 1;
764 ret |= get_cabac_bypass(&s->HEVClc->cc);
768 int ff_hevc_merge_idx_decode(HEVCContext *s)
770 int i = GET_CABAC(elem_offset[MERGE_IDX]);
773 while (i < s->sh.max_num_merge_cand-1 && get_cabac_bypass(&s->HEVClc->cc))
779 int ff_hevc_merge_flag_decode(HEVCContext *s)
781 return GET_CABAC(elem_offset[MERGE_FLAG]);
784 int ff_hevc_inter_pred_idc_decode(HEVCContext *s, int nPbW, int nPbH)
786 if (nPbW + nPbH == 12)
787 return GET_CABAC(elem_offset[INTER_PRED_IDC] + 4);
788 if (GET_CABAC(elem_offset[INTER_PRED_IDC] + s->HEVClc->ct_depth))
791 return GET_CABAC(elem_offset[INTER_PRED_IDC] + 4);
794 int ff_hevc_ref_idx_lx_decode(HEVCContext *s, int num_ref_idx_lx)
797 int max = num_ref_idx_lx - 1;
798 int max_ctx = FFMIN(max, 2);
800 while (i < max_ctx && GET_CABAC(elem_offset[REF_IDX_L0] + i))
803 while (i < max && get_cabac_bypass(&s->HEVClc->cc))
810 int ff_hevc_mvp_lx_flag_decode(HEVCContext *s)
812 return GET_CABAC(elem_offset[MVP_LX_FLAG]);
815 int ff_hevc_no_residual_syntax_flag_decode(HEVCContext *s)
817 return GET_CABAC(elem_offset[NO_RESIDUAL_DATA_FLAG]);
820 static av_always_inline int abs_mvd_greater0_flag_decode(HEVCContext *s)
822 return GET_CABAC(elem_offset[ABS_MVD_GREATER0_FLAG]);
825 static av_always_inline int abs_mvd_greater1_flag_decode(HEVCContext *s)
827 return GET_CABAC(elem_offset[ABS_MVD_GREATER1_FLAG] + 1);
830 static av_always_inline int mvd_decode(HEVCContext *s)
835 while (k < CABAC_MAX_BIN && get_cabac_bypass(&s->HEVClc->cc)) {
839 if (k == CABAC_MAX_BIN) {
840 av_log(s->avctx, AV_LOG_ERROR, "CABAC_MAX_BIN : %d\n", k);
844 ret += get_cabac_bypass(&s->HEVClc->cc) << k;
845 return get_cabac_bypass_sign(&s->HEVClc->cc, -ret);
848 static av_always_inline int mvd_sign_flag_decode(HEVCContext *s)
850 return get_cabac_bypass_sign(&s->HEVClc->cc, -1);
853 int ff_hevc_split_transform_flag_decode(HEVCContext *s, int log2_trafo_size)
855 return GET_CABAC(elem_offset[SPLIT_TRANSFORM_FLAG] + 5 - log2_trafo_size);
858 int ff_hevc_cbf_cb_cr_decode(HEVCContext *s, int trafo_depth)
860 return GET_CABAC(elem_offset[CBF_CB_CR] + trafo_depth);
863 int ff_hevc_cbf_luma_decode(HEVCContext *s, int trafo_depth)
865 return GET_CABAC(elem_offset[CBF_LUMA] + !trafo_depth);
868 static int hevc_transform_skip_flag_decode(HEVCContext *s, int c_idx)
870 return GET_CABAC(elem_offset[TRANSFORM_SKIP_FLAG] + !!c_idx);
873 static int explicit_rdpcm_flag_decode(HEVCContext *s, int c_idx)
875 return GET_CABAC(elem_offset[EXPLICIT_RDPCM_FLAG] + !!c_idx);
878 static int explicit_rdpcm_dir_flag_decode(HEVCContext *s, int c_idx)
880 return GET_CABAC(elem_offset[EXPLICIT_RDPCM_DIR_FLAG] + !!c_idx);
883 int ff_hevc_log2_res_scale_abs(HEVCContext *s, int idx) {
886 while (i < 4 && GET_CABAC(elem_offset[LOG2_RES_SCALE_ABS] + 4 * idx + i))
892 int ff_hevc_res_scale_sign_flag(HEVCContext *s, int idx) {
893 return GET_CABAC(elem_offset[RES_SCALE_SIGN_FLAG] + idx);
896 static av_always_inline void last_significant_coeff_xy_prefix_decode(HEVCContext *s, int c_idx,
897 int log2_size, int *last_scx_prefix, int *last_scy_prefix)
900 int max = (log2_size << 1) - 1;
901 int ctx_offset, ctx_shift;
904 ctx_offset = 3 * (log2_size - 2) + ((log2_size - 1) >> 2);
905 ctx_shift = (log2_size + 1) >> 2;
908 ctx_shift = log2_size - 2;
911 GET_CABAC(elem_offset[LAST_SIGNIFICANT_COEFF_X_PREFIX] + (i >> ctx_shift) + ctx_offset))
913 *last_scx_prefix = i;
917 GET_CABAC(elem_offset[LAST_SIGNIFICANT_COEFF_Y_PREFIX] + (i >> ctx_shift) + ctx_offset))
919 *last_scy_prefix = i;
922 static av_always_inline int last_significant_coeff_suffix_decode(HEVCContext *s,
923 int last_significant_coeff_prefix)
926 int length = (last_significant_coeff_prefix >> 1) - 1;
927 int value = get_cabac_bypass(&s->HEVClc->cc);
929 for (i = 1; i < length; i++)
930 value = (value << 1) | get_cabac_bypass(&s->HEVClc->cc);
934 static av_always_inline int significant_coeff_group_flag_decode(HEVCContext *s, int c_idx, int ctx_cg)
938 inc = FFMIN(ctx_cg, 1) + (c_idx>0 ? 2 : 0);
940 return GET_CABAC(elem_offset[SIGNIFICANT_COEFF_GROUP_FLAG] + inc);
942 static av_always_inline int significant_coeff_flag_decode(HEVCContext *s, int x_c, int y_c,
943 int offset, const uint8_t *ctx_idx_map)
945 int inc = ctx_idx_map[(y_c << 2) + x_c] + offset;
946 return GET_CABAC(elem_offset[SIGNIFICANT_COEFF_FLAG] + inc);
949 static av_always_inline int significant_coeff_flag_decode_0(HEVCContext *s, int c_idx, int offset)
951 return GET_CABAC(elem_offset[SIGNIFICANT_COEFF_FLAG] + offset);
954 static av_always_inline int coeff_abs_level_greater1_flag_decode(HEVCContext *s, int c_idx, int inc)
960 return GET_CABAC(elem_offset[COEFF_ABS_LEVEL_GREATER1_FLAG] + inc);
963 static av_always_inline int coeff_abs_level_greater2_flag_decode(HEVCContext *s, int c_idx, int inc)
968 return GET_CABAC(elem_offset[COEFF_ABS_LEVEL_GREATER2_FLAG] + inc);
971 static av_always_inline int coeff_abs_level_remaining_decode(HEVCContext *s, int rc_rice_param)
975 int last_coeff_abs_level_remaining;
978 while (prefix < CABAC_MAX_BIN && get_cabac_bypass(&s->HEVClc->cc))
980 if (prefix == CABAC_MAX_BIN) {
981 av_log(s->avctx, AV_LOG_ERROR, "CABAC_MAX_BIN : %d\n", prefix);
985 for (i = 0; i < rc_rice_param; i++)
986 suffix = (suffix << 1) | get_cabac_bypass(&s->HEVClc->cc);
987 last_coeff_abs_level_remaining = (prefix << rc_rice_param) + suffix;
989 int prefix_minus3 = prefix - 3;
990 for (i = 0; i < prefix_minus3 + rc_rice_param; i++)
991 suffix = (suffix << 1) | get_cabac_bypass(&s->HEVClc->cc);
992 last_coeff_abs_level_remaining = (((1 << prefix_minus3) + 3 - 1)
993 << rc_rice_param) + suffix;
995 return last_coeff_abs_level_remaining;
998 static av_always_inline int coeff_sign_flag_decode(HEVCContext *s, uint8_t nb)
1003 for (i = 0; i < nb; i++)
1004 ret = (ret << 1) | get_cabac_bypass(&s->HEVClc->cc);
1008 void ff_hevc_hls_residual_coding(HEVCContext *s, int x0, int y0,
1009 int log2_trafo_size, enum ScanType scan_idx,
1012 #define GET_COORD(offset, n) \
1014 x_c = (x_cg << 2) + scan_x_off[n]; \
1015 y_c = (y_cg << 2) + scan_y_off[n]; \
1017 HEVCLocalContext *lc = s->HEVClc;
1018 int transform_skip_flag = 0;
1020 int last_significant_coeff_x, last_significant_coeff_y;
1024 int greater1_ctx = 1;
1026 int num_last_subset;
1027 int x_cg_last_sig, y_cg_last_sig;
1029 const uint8_t *scan_x_cg, *scan_y_cg, *scan_x_off, *scan_y_off;
1031 ptrdiff_t stride = s->frame->linesize[c_idx];
1032 int hshift = s->ps.sps->hshift[c_idx];
1033 int vshift = s->ps.sps->vshift[c_idx];
1034 uint8_t *dst = &s->frame->data[c_idx][(y0 >> vshift) * stride +
1035 ((x0 >> hshift) << s->ps.sps->pixel_shift)];
1036 int16_t *coeffs = (int16_t*)(c_idx ? lc->edge_emu_buffer2 : lc->edge_emu_buffer);
1037 uint8_t significant_coeff_group_flag[8][8] = {{0}};
1038 int explicit_rdpcm_flag = 0;
1039 int explicit_rdpcm_dir_flag;
1041 int trafo_size = 1 << log2_trafo_size;
1043 int qp,shift,add,scale,scale_m;
1044 static const uint8_t level_scale[] = { 40, 45, 51, 57, 64, 72 };
1045 const uint8_t *scale_matrix = NULL;
1047 int pred_mode_intra = (c_idx == 0) ? lc->tu.intra_pred_mode :
1048 lc->tu.intra_pred_mode_c;
1050 memset(coeffs, 0, trafo_size * trafo_size * sizeof(int16_t));
1052 // Derive QP for dequant
1053 if (!lc->cu.cu_transquant_bypass_flag) {
1054 static const int qp_c[] = { 29, 30, 31, 32, 33, 33, 34, 34, 35, 35, 36, 36, 37, 37 };
1055 static const uint8_t rem6[51 + 4 * 6 + 1] = {
1056 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2,
1057 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5,
1058 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3,
1059 4, 5, 0, 1, 2, 3, 4, 5, 0, 1
1062 static const uint8_t div6[51 + 4 * 6 + 1] = {
1063 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 3, 3, 3,
1064 3, 3, 3, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6,
1065 7, 7, 7, 7, 7, 7, 8, 8, 8, 8, 8, 8, 9, 9, 9, 9, 9, 9, 10, 10, 10, 10,
1066 10, 10, 11, 11, 11, 11, 11, 11, 12, 12
1068 int qp_y = lc->qp_y;
1070 if (s->ps.pps->transform_skip_enabled_flag &&
1071 log2_trafo_size <= s->ps.pps->log2_max_transform_skip_block_size) {
1072 transform_skip_flag = hevc_transform_skip_flag_decode(s, c_idx);
1076 qp = qp_y + s->ps.sps->qp_bd_offset;
1081 offset = s->ps.pps->cb_qp_offset + s->sh.slice_cb_qp_offset +
1082 lc->tu.cu_qp_offset_cb;
1084 offset = s->ps.pps->cr_qp_offset + s->sh.slice_cr_qp_offset +
1085 lc->tu.cu_qp_offset_cr;
1087 qp_i = av_clip(qp_y + offset, - s->ps.sps->qp_bd_offset, 57);
1088 if (s->ps.sps->chroma_format_idc == 1) {
1094 qp = qp_c[qp_i - 30];
1102 qp += s->ps.sps->qp_bd_offset;
1105 shift = s->ps.sps->bit_depth + log2_trafo_size - 5;
1106 add = 1 << (shift-1);
1107 scale = level_scale[rem6[qp]] << (div6[qp]);
1108 scale_m = 16; // default when no custom scaling lists.
1111 if (s->ps.sps->scaling_list_enable_flag && !(transform_skip_flag && log2_trafo_size > 2)) {
1112 const ScalingList *sl = s->ps.pps->scaling_list_data_present_flag ?
1113 &s->ps.pps->scaling_list : &s->ps.sps->scaling_list;
1114 int matrix_id = lc->cu.pred_mode != MODE_INTRA;
1116 matrix_id = 3 * matrix_id + c_idx;
1118 scale_matrix = sl->sl[log2_trafo_size - 2][matrix_id];
1119 if (log2_trafo_size >= 4)
1120 dc_scale = sl->sl_dc[log2_trafo_size - 4][matrix_id];
1129 if (lc->cu.pred_mode == MODE_INTER && s->ps.sps->explicit_rdpcm_enabled_flag &&
1130 (transform_skip_flag || lc->cu.cu_transquant_bypass_flag)) {
1131 explicit_rdpcm_flag = explicit_rdpcm_flag_decode(s, c_idx);
1132 if (explicit_rdpcm_flag) {
1133 explicit_rdpcm_dir_flag = explicit_rdpcm_dir_flag_decode(s, c_idx);
1137 last_significant_coeff_xy_prefix_decode(s, c_idx, log2_trafo_size,
1138 &last_significant_coeff_x, &last_significant_coeff_y);
1140 if (last_significant_coeff_x > 3) {
1141 int suffix = last_significant_coeff_suffix_decode(s, last_significant_coeff_x);
1142 last_significant_coeff_x = (1 << ((last_significant_coeff_x >> 1) - 1)) *
1143 (2 + (last_significant_coeff_x & 1)) +
1147 if (last_significant_coeff_y > 3) {
1148 int suffix = last_significant_coeff_suffix_decode(s, last_significant_coeff_y);
1149 last_significant_coeff_y = (1 << ((last_significant_coeff_y >> 1) - 1)) *
1150 (2 + (last_significant_coeff_y & 1)) +
1154 if (scan_idx == SCAN_VERT)
1155 FFSWAP(int, last_significant_coeff_x, last_significant_coeff_y);
1157 x_cg_last_sig = last_significant_coeff_x >> 2;
1158 y_cg_last_sig = last_significant_coeff_y >> 2;
1162 int last_x_c = last_significant_coeff_x & 3;
1163 int last_y_c = last_significant_coeff_y & 3;
1165 scan_x_off = ff_hevc_diag_scan4x4_x;
1166 scan_y_off = ff_hevc_diag_scan4x4_y;
1167 num_coeff = diag_scan4x4_inv[last_y_c][last_x_c];
1168 if (trafo_size == 4) {
1169 scan_x_cg = scan_1x1;
1170 scan_y_cg = scan_1x1;
1171 } else if (trafo_size == 8) {
1172 num_coeff += diag_scan2x2_inv[y_cg_last_sig][x_cg_last_sig] << 4;
1173 scan_x_cg = diag_scan2x2_x;
1174 scan_y_cg = diag_scan2x2_y;
1175 } else if (trafo_size == 16) {
1176 num_coeff += diag_scan4x4_inv[y_cg_last_sig][x_cg_last_sig] << 4;
1177 scan_x_cg = ff_hevc_diag_scan4x4_x;
1178 scan_y_cg = ff_hevc_diag_scan4x4_y;
1179 } else { // trafo_size == 32
1180 num_coeff += diag_scan8x8_inv[y_cg_last_sig][x_cg_last_sig] << 4;
1181 scan_x_cg = ff_hevc_diag_scan8x8_x;
1182 scan_y_cg = ff_hevc_diag_scan8x8_y;
1187 scan_x_cg = horiz_scan2x2_x;
1188 scan_y_cg = horiz_scan2x2_y;
1189 scan_x_off = horiz_scan4x4_x;
1190 scan_y_off = horiz_scan4x4_y;
1191 num_coeff = horiz_scan8x8_inv[last_significant_coeff_y][last_significant_coeff_x];
1193 default: //SCAN_VERT
1194 scan_x_cg = horiz_scan2x2_y;
1195 scan_y_cg = horiz_scan2x2_x;
1196 scan_x_off = horiz_scan4x4_y;
1197 scan_y_off = horiz_scan4x4_x;
1198 num_coeff = horiz_scan8x8_inv[last_significant_coeff_x][last_significant_coeff_y];
1202 num_last_subset = (num_coeff - 1) >> 4;
1204 for (i = num_last_subset; i >= 0; i--) {
1206 int x_cg, y_cg, x_c, y_c, pos;
1207 int implicit_non_zero_coeff = 0;
1208 int64_t trans_coeff_level;
1210 int offset = i << 4;
1213 uint8_t significant_coeff_flag_idx[16];
1214 uint8_t nb_significant_coeff_flag = 0;
1216 x_cg = scan_x_cg[i];
1217 y_cg = scan_y_cg[i];
1219 if ((i < num_last_subset) && (i > 0)) {
1221 if (x_cg < (1 << (log2_trafo_size - 2)) - 1)
1222 ctx_cg += significant_coeff_group_flag[x_cg + 1][y_cg];
1223 if (y_cg < (1 << (log2_trafo_size - 2)) - 1)
1224 ctx_cg += significant_coeff_group_flag[x_cg][y_cg + 1];
1226 significant_coeff_group_flag[x_cg][y_cg] =
1227 significant_coeff_group_flag_decode(s, c_idx, ctx_cg);
1228 implicit_non_zero_coeff = 1;
1230 significant_coeff_group_flag[x_cg][y_cg] =
1231 ((x_cg == x_cg_last_sig && y_cg == y_cg_last_sig) ||
1232 (x_cg == 0 && y_cg == 0));
1235 last_scan_pos = num_coeff - offset - 1;
1237 if (i == num_last_subset) {
1238 n_end = last_scan_pos - 1;
1239 significant_coeff_flag_idx[0] = last_scan_pos;
1240 nb_significant_coeff_flag = 1;
1245 if (x_cg < ((1 << log2_trafo_size) - 1) >> 2)
1246 prev_sig = !!significant_coeff_group_flag[x_cg + 1][y_cg];
1247 if (y_cg < ((1 << log2_trafo_size) - 1) >> 2)
1248 prev_sig += (!!significant_coeff_group_flag[x_cg][y_cg + 1] << 1);
1250 if (significant_coeff_group_flag[x_cg][y_cg] && n_end >= 0) {
1251 static const uint8_t ctx_idx_map[] = {
1252 0, 1, 4, 5, 2, 3, 4, 5, 6, 6, 8, 8, 7, 7, 8, 8, // log2_trafo_size == 2
1253 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, // prev_sig == 0
1254 2, 2, 2, 2, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, // prev_sig == 1
1255 2, 1, 0, 0, 2, 1, 0, 0, 2, 1, 0, 0, 2, 1, 0, 0, // prev_sig == 2
1256 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2 // default
1258 const uint8_t *ctx_idx_map_p;
1260 if (s->ps.sps->transform_skip_context_enabled_flag &&
1261 (transform_skip_flag || lc->cu.cu_transquant_bypass_flag)) {
1262 ctx_idx_map_p = (uint8_t*) &ctx_idx_map[4 * 16];
1266 scf_offset = 14 + 27;
1271 if (log2_trafo_size == 2) {
1272 ctx_idx_map_p = (uint8_t*) &ctx_idx_map[0];
1274 ctx_idx_map_p = (uint8_t*) &ctx_idx_map[(prev_sig + 1) << 4];
1276 if ((x_cg > 0 || y_cg > 0))
1278 if (log2_trafo_size == 3) {
1279 scf_offset += (scan_idx == SCAN_DIAG) ? 9 : 15;
1284 if (log2_trafo_size == 3)
1291 for (n = n_end; n > 0; n--) {
1292 x_c = scan_x_off[n];
1293 y_c = scan_y_off[n];
1294 if (significant_coeff_flag_decode(s, x_c, y_c, scf_offset, ctx_idx_map_p)) {
1295 significant_coeff_flag_idx[nb_significant_coeff_flag] = n;
1296 nb_significant_coeff_flag++;
1297 implicit_non_zero_coeff = 0;
1300 if (implicit_non_zero_coeff == 0) {
1301 if (s->ps.sps->transform_skip_context_enabled_flag &&
1302 (transform_skip_flag || lc->cu.cu_transquant_bypass_flag)) {
1306 scf_offset = 16 + 27;
1315 scf_offset = 2 + scf_offset;
1318 if (significant_coeff_flag_decode_0(s, c_idx, scf_offset) == 1) {
1319 significant_coeff_flag_idx[nb_significant_coeff_flag] = 0;
1320 nb_significant_coeff_flag++;
1323 significant_coeff_flag_idx[nb_significant_coeff_flag] = 0;
1324 nb_significant_coeff_flag++;
1328 n_end = nb_significant_coeff_flag;
1332 int first_nz_pos_in_cg;
1333 int last_nz_pos_in_cg;
1334 int c_rice_param = 0;
1335 int first_greater1_coeff_idx = -1;
1336 uint8_t coeff_abs_level_greater1_flag[8];
1337 uint16_t coeff_sign_flag;
1343 // initialize first elem of coeff_bas_level_greater1_flag
1344 int ctx_set = (i > 0 && c_idx == 0) ? 2 : 0;
1346 if (s->ps.sps->persistent_rice_adaptation_enabled_flag) {
1347 if (!transform_skip_flag && !lc->cu.cu_transquant_bypass_flag)
1348 sb_type = 2 * (c_idx == 0 ? 1 : 0);
1350 sb_type = 2 * (c_idx == 0 ? 1 : 0) + 1;
1351 c_rice_param = lc->stat_coeff[sb_type] / 4;
1354 if (!(i == num_last_subset) && greater1_ctx == 0)
1357 last_nz_pos_in_cg = significant_coeff_flag_idx[0];
1359 for (m = 0; m < (n_end > 8 ? 8 : n_end); m++) {
1360 int inc = (ctx_set << 2) + greater1_ctx;
1361 coeff_abs_level_greater1_flag[m] =
1362 coeff_abs_level_greater1_flag_decode(s, c_idx, inc);
1363 if (coeff_abs_level_greater1_flag[m]) {
1365 if (first_greater1_coeff_idx == -1)
1366 first_greater1_coeff_idx = m;
1367 } else if (greater1_ctx > 0 && greater1_ctx < 3) {
1371 first_nz_pos_in_cg = significant_coeff_flag_idx[n_end - 1];
1373 if (lc->cu.cu_transquant_bypass_flag ||
1374 (lc->cu.pred_mode == MODE_INTRA &&
1375 s->ps.sps->implicit_rdpcm_enabled_flag && transform_skip_flag &&
1376 (pred_mode_intra == 10 || pred_mode_intra == 26 )) ||
1377 explicit_rdpcm_flag)
1380 sign_hidden = (last_nz_pos_in_cg - first_nz_pos_in_cg >= 4);
1382 if (first_greater1_coeff_idx != -1) {
1383 coeff_abs_level_greater1_flag[first_greater1_coeff_idx] += coeff_abs_level_greater2_flag_decode(s, c_idx, ctx_set);
1385 if (!s->ps.pps->sign_data_hiding_flag || !sign_hidden ) {
1386 coeff_sign_flag = coeff_sign_flag_decode(s, nb_significant_coeff_flag) << (16 - nb_significant_coeff_flag);
1388 coeff_sign_flag = coeff_sign_flag_decode(s, nb_significant_coeff_flag - 1) << (16 - (nb_significant_coeff_flag - 1));
1391 for (m = 0; m < n_end; m++) {
1392 n = significant_coeff_flag_idx[m];
1393 GET_COORD(offset, n);
1395 trans_coeff_level = 1 + coeff_abs_level_greater1_flag[m];
1396 if (trans_coeff_level == ((m == first_greater1_coeff_idx) ? 3 : 2)) {
1397 int last_coeff_abs_level_remaining = coeff_abs_level_remaining_decode(s, c_rice_param);
1399 trans_coeff_level += last_coeff_abs_level_remaining;
1400 if (trans_coeff_level > (3 << c_rice_param))
1401 c_rice_param = s->ps.sps->persistent_rice_adaptation_enabled_flag ? c_rice_param + 1 : FFMIN(c_rice_param + 1, 4);
1402 if (s->ps.sps->persistent_rice_adaptation_enabled_flag && !rice_init) {
1403 int c_rice_p_init = lc->stat_coeff[sb_type] / 4;
1404 if (last_coeff_abs_level_remaining >= (3 << c_rice_p_init))
1405 lc->stat_coeff[sb_type]++;
1406 else if (2 * last_coeff_abs_level_remaining < (1 << c_rice_p_init))
1407 if (lc->stat_coeff[sb_type] > 0)
1408 lc->stat_coeff[sb_type]--;
1413 int last_coeff_abs_level_remaining = coeff_abs_level_remaining_decode(s, c_rice_param);
1415 trans_coeff_level = 1 + last_coeff_abs_level_remaining;
1416 if (trans_coeff_level > (3 << c_rice_param))
1417 c_rice_param = s->ps.sps->persistent_rice_adaptation_enabled_flag ? c_rice_param + 1 : FFMIN(c_rice_param + 1, 4);
1418 if (s->ps.sps->persistent_rice_adaptation_enabled_flag && !rice_init) {
1419 int c_rice_p_init = lc->stat_coeff[sb_type] / 4;
1420 if (last_coeff_abs_level_remaining >= (3 << c_rice_p_init))
1421 lc->stat_coeff[sb_type]++;
1422 else if (2 * last_coeff_abs_level_remaining < (1 << c_rice_p_init))
1423 if (lc->stat_coeff[sb_type] > 0)
1424 lc->stat_coeff[sb_type]--;
1428 if (s->ps.pps->sign_data_hiding_flag && sign_hidden) {
1429 sum_abs += trans_coeff_level;
1430 if (n == first_nz_pos_in_cg && (sum_abs&1))
1431 trans_coeff_level = -trans_coeff_level;
1433 if (coeff_sign_flag >> 15)
1434 trans_coeff_level = -trans_coeff_level;
1435 coeff_sign_flag <<= 1;
1436 if(!lc->cu.cu_transquant_bypass_flag) {
1437 if (s->ps.sps->scaling_list_enable_flag && !(transform_skip_flag && log2_trafo_size > 2)) {
1438 if(y_c || x_c || log2_trafo_size < 4) {
1439 switch(log2_trafo_size) {
1440 case 3: pos = (y_c << 3) + x_c; break;
1441 case 4: pos = ((y_c >> 1) << 3) + (x_c >> 1); break;
1442 case 5: pos = ((y_c >> 2) << 3) + (x_c >> 2); break;
1443 default: pos = (y_c << 2) + x_c; break;
1445 scale_m = scale_matrix[pos];
1450 trans_coeff_level = (trans_coeff_level * (int64_t)scale * (int64_t)scale_m + add) >> shift;
1451 if(trans_coeff_level < 0) {
1452 if((~trans_coeff_level) & 0xFffffffffff8000)
1453 trans_coeff_level = -32768;
1455 if(trans_coeff_level & 0xffffffffffff8000)
1456 trans_coeff_level = 32767;
1459 coeffs[y_c * trafo_size + x_c] = trans_coeff_level;
1464 if (lc->cu.cu_transquant_bypass_flag) {
1465 if (explicit_rdpcm_flag || (s->ps.sps->implicit_rdpcm_enabled_flag &&
1466 (pred_mode_intra == 10 || pred_mode_intra == 26))) {
1467 int mode = s->ps.sps->implicit_rdpcm_enabled_flag ? (pred_mode_intra == 26) : explicit_rdpcm_dir_flag;
1469 s->hevcdsp.transform_rdpcm(coeffs, log2_trafo_size, mode);
1472 if (transform_skip_flag) {
1473 int rot = s->ps.sps->transform_skip_rotation_enabled_flag &&
1474 log2_trafo_size == 2 &&
1475 lc->cu.pred_mode == MODE_INTRA;
1477 for (i = 0; i < 8; i++)
1478 FFSWAP(int16_t, coeffs[i], coeffs[16 - i - 1]);
1481 s->hevcdsp.dequant(coeffs, log2_trafo_size);
1483 if (explicit_rdpcm_flag || (s->ps.sps->implicit_rdpcm_enabled_flag &&
1484 lc->cu.pred_mode == MODE_INTRA &&
1485 (pred_mode_intra == 10 || pred_mode_intra == 26))) {
1486 int mode = explicit_rdpcm_flag ? explicit_rdpcm_dir_flag : (pred_mode_intra == 26);
1488 s->hevcdsp.transform_rdpcm(coeffs, log2_trafo_size, mode);
1490 } else if (lc->cu.pred_mode == MODE_INTRA && c_idx == 0 && log2_trafo_size == 2) {
1491 s->hevcdsp.transform_4x4_luma(coeffs);
1493 int max_xy = FFMAX(last_significant_coeff_x, last_significant_coeff_y);
1495 s->hevcdsp.idct_dc[log2_trafo_size - 2](coeffs);
1497 int col_limit = last_significant_coeff_x + last_significant_coeff_y + 4;
1499 col_limit = FFMIN(4, col_limit);
1500 else if (max_xy < 8)
1501 col_limit = FFMIN(8, col_limit);
1502 else if (max_xy < 12)
1503 col_limit = FFMIN(24, col_limit);
1504 s->hevcdsp.idct[log2_trafo_size - 2](coeffs, col_limit);
1508 if (lc->tu.cross_pf) {
1509 int16_t *coeffs_y = (int16_t*)lc->edge_emu_buffer;
1511 for (i = 0; i < (trafo_size * trafo_size); i++) {
1512 coeffs[i] = coeffs[i] + ((lc->tu.res_scale_val * coeffs_y[i]) >> 3);
1515 s->hevcdsp.add_residual[log2_trafo_size-2](dst, coeffs, stride);
1518 void ff_hevc_hls_mvd_coding(HEVCContext *s, int x0, int y0, int log2_cb_size)
1520 HEVCLocalContext *lc = s->HEVClc;
1521 int x = abs_mvd_greater0_flag_decode(s);
1522 int y = abs_mvd_greater0_flag_decode(s);
1525 x += abs_mvd_greater1_flag_decode(s);
1527 y += abs_mvd_greater1_flag_decode(s);
1530 case 2: lc->pu.mvd.x = mvd_decode(s); break;
1531 case 1: lc->pu.mvd.x = mvd_sign_flag_decode(s); break;
1532 case 0: lc->pu.mvd.x = 0; break;
1536 case 2: lc->pu.mvd.y = mvd_decode(s); break;
1537 case 1: lc->pu.mvd.y = mvd_sign_flag_decode(s); break;
1538 case 0: lc->pu.mvd.y = 0; break;