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 100
33 * number of bin by SyntaxElement.
35 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 18, // last_significant_coeff_x_prefix
70 18, // last_significant_coeff_y_prefix
71 0, // last_significant_coeff_x_suffix
72 0, // last_significant_coeff_y_suffix
73 4, // significant_coeff_group_flag
74 42, // significant_coeff_flag
75 24, // coeff_abs_level_greater1_flag
76 6, // coeff_abs_level_greater2_flag
77 0, // coeff_abs_level_remaining
82 * Offset to ctxIdx 0 in init_values and states, indexed by SyntaxElement.
84 static const int elem_offset[sizeof(num_bins_in_se)] = {
132 * Indexed by init_type
134 static const uint8_t init_values[3][HEVC_CONTEXTS] = {
140 // split_coding_unit_flag
142 // cu_transquant_bypass_flag
152 // prev_intra_luma_pred_mode
154 // intra_chroma_pred_mode
161 CNU, CNU, CNU, CNU, CNU,
166 // abs_mvd_greater1_flag
168 // abs_mvd_greater1_flag
172 // no_residual_data_flag
174 // split_transform_flag
180 // transform_skip_flag
182 // last_significant_coeff_x_prefix
183 110, 110, 124, 125, 140, 153, 125, 127, 140, 109, 111, 143, 127, 111,
185 // last_significant_coeff_y_prefix
186 110, 110, 124, 125, 140, 153, 125, 127, 140, 109, 111, 143, 127, 111,
188 // significant_coeff_group_flag
190 // significant_coeff_flag
191 111, 111, 125, 110, 110, 94, 124, 108, 124, 107, 125, 141, 179, 153,
192 125, 107, 125, 141, 179, 153, 125, 107, 125, 141, 179, 153, 125, 140,
193 139, 182, 182, 152, 136, 152, 136, 153, 136, 139, 111, 136, 139, 111,
194 // coeff_abs_level_greater1_flag
195 140, 92, 137, 138, 140, 152, 138, 139, 153, 74, 149, 92, 139, 107,
196 122, 152, 140, 179, 166, 182, 140, 227, 122, 197,
197 // coeff_abs_level_greater2_flag
198 138, 153, 136, 167, 152, 152,
205 // split_coding_unit_flag
207 // cu_transquant_bypass_flag
217 // prev_intra_luma_pred_mode
219 // intra_chroma_pred_mode
231 // abs_mvd_greater1_flag
233 // abs_mvd_greater1_flag
237 // no_residual_data_flag
239 // split_transform_flag
245 // transform_skip_flag
247 // last_significant_coeff_x_prefix
248 125, 110, 94, 110, 95, 79, 125, 111, 110, 78, 110, 111, 111, 95,
250 // last_significant_coeff_y_prefix
251 125, 110, 94, 110, 95, 79, 125, 111, 110, 78, 110, 111, 111, 95,
253 // significant_coeff_group_flag
255 // significant_coeff_flag
256 155, 154, 139, 153, 139, 123, 123, 63, 153, 166, 183, 140, 136, 153,
257 154, 166, 183, 140, 136, 153, 154, 166, 183, 140, 136, 153, 154, 170,
258 153, 123, 123, 107, 121, 107, 121, 167, 151, 183, 140, 151, 183, 140,
259 // coeff_abs_level_greater1_flag
260 154, 196, 196, 167, 154, 152, 167, 182, 182, 134, 149, 136, 153, 121,
261 136, 137, 169, 194, 166, 167, 154, 167, 137, 182,
262 // coeff_abs_level_greater2_flag
263 107, 167, 91, 122, 107, 167,
270 // split_coding_unit_flag
272 // cu_transquant_bypass_flag
282 // prev_intra_luma_pred_mode
284 // intra_chroma_pred_mode
296 // abs_mvd_greater1_flag
298 // abs_mvd_greater1_flag
302 // no_residual_data_flag
304 // split_transform_flag
310 // transform_skip_flag
312 // last_significant_coeff_x_prefix
313 125, 110, 124, 110, 95, 94, 125, 111, 111, 79, 125, 126, 111, 111,
315 // last_significant_coeff_y_prefix
316 125, 110, 124, 110, 95, 94, 125, 111, 111, 79, 125, 126, 111, 111,
318 // significant_coeff_group_flag
320 // significant_coeff_flag
321 170, 154, 139, 153, 139, 123, 123, 63, 124, 166, 183, 140, 136, 153,
322 154, 166, 183, 140, 136, 153, 154, 166, 183, 140, 136, 153, 154, 170,
323 153, 138, 138, 122, 121, 122, 121, 167, 151, 183, 140, 151, 183, 140,
324 // coeff_abs_level_greater1_flag
325 154, 196, 167, 167, 154, 152, 167, 182, 182, 134, 149, 136, 153, 121,
326 136, 122, 169, 208, 166, 167, 154, 152, 167, 182,
327 // coeff_abs_level_greater2_flag
328 107, 167, 91, 107, 107, 167,
332 static const uint8_t scan_1x1[1] = {
336 static const uint8_t horiz_scan2x2_x[4] = {
340 static const uint8_t horiz_scan2x2_y[4] = {
344 static const uint8_t horiz_scan4x4_x[16] = {
351 static const uint8_t horiz_scan4x4_y[16] = {
358 static const uint8_t horiz_scan8x8_inv[8][8] = {
359 { 0, 1, 2, 3, 16, 17, 18, 19, },
360 { 4, 5, 6, 7, 20, 21, 22, 23, },
361 { 8, 9, 10, 11, 24, 25, 26, 27, },
362 { 12, 13, 14, 15, 28, 29, 30, 31, },
363 { 32, 33, 34, 35, 48, 49, 50, 51, },
364 { 36, 37, 38, 39, 52, 53, 54, 55, },
365 { 40, 41, 42, 43, 56, 57, 58, 59, },
366 { 44, 45, 46, 47, 60, 61, 62, 63, },
369 static const uint8_t diag_scan4x1_x[4] = {
373 static const uint8_t diag_scan1x4_y[4] = {
377 static const uint8_t diag_scan2x2_x[4] = {
381 static const uint8_t diag_scan2x2_y[4] = {
385 static const uint8_t diag_scan2x2_inv[2][2] = {
390 static const uint8_t diag_scan8x2_x[16] = {
397 static const uint8_t diag_scan8x2_y[16] = {
404 static const uint8_t diag_scan8x2_inv[2][8] = {
405 { 0, 2, 4, 6, 8, 10, 12, 14, },
406 { 1, 3, 5, 7, 9, 11, 13, 15, },
409 static const uint8_t diag_scan2x8_x[16] = {
416 static const uint8_t diag_scan2x8_y[16] = {
423 static const uint8_t diag_scan2x8_inv[8][2] = {
434 const uint8_t ff_hevc_diag_scan4x4_x[16] = {
441 const uint8_t ff_hevc_diag_scan4x4_y[16] = {
448 static const uint8_t diag_scan4x4_inv[4][4] = {
455 const uint8_t ff_hevc_diag_scan8x8_x[64] = {
474 const uint8_t ff_hevc_diag_scan8x8_y[64] = {
493 static const uint8_t diag_scan8x8_inv[8][8] = {
494 { 0, 2, 5, 9, 14, 20, 27, 35, },
495 { 1, 4, 8, 13, 19, 26, 34, 42, },
496 { 3, 7, 12, 18, 25, 33, 41, 48, },
497 { 6, 11, 17, 24, 32, 40, 47, 53, },
498 { 10, 16, 23, 31, 39, 46, 52, 57, },
499 { 15, 22, 30, 38, 45, 51, 56, 60, },
500 { 21, 29, 37, 44, 50, 55, 59, 62, },
501 { 28, 36, 43, 49, 54, 58, 61, 63, },
504 void ff_hevc_save_states(HEVCContext *s, int ctb_addr_ts)
506 if (s->pps->entropy_coding_sync_enabled_flag &&
507 ((ctb_addr_ts % s->sps->ctb_width) == 2 ||
508 (s->sps->ctb_width == 2 &&
509 (ctb_addr_ts % s->sps->ctb_width) == 0))) {
510 memcpy(s->cabac_state, s->HEVClc->cabac_state, HEVC_CONTEXTS);
514 static void load_states(HEVCContext *s)
516 memcpy(s->HEVClc->cabac_state, s->cabac_state, HEVC_CONTEXTS);
519 static void cabac_reinit(HEVCLocalContext *lc)
521 skip_bytes(&lc->cc, 0);
524 static void cabac_init_decoder(HEVCContext *s)
526 GetBitContext *gb = &s->HEVClc->gb;
529 ff_init_cabac_decoder(&s->HEVClc->cc,
530 gb->buffer + get_bits_count(gb) / 8,
531 (get_bits_left(gb) + 7) / 8);
534 static void cabac_init_state(HEVCContext *s)
536 int init_type = 2 - s->sh.slice_type;
539 if (s->sh.cabac_init_flag && s->sh.slice_type != I_SLICE)
542 for (i = 0; i < HEVC_CONTEXTS; i++) {
543 int init_value = init_values[init_type][i];
544 int m = (init_value >> 4) * 5 - 45;
545 int n = ((init_value & 15) << 3) - 16;
546 int pre = 2 * (((m * av_clip_c(s->sh.slice_qp, 0, 51)) >> 4) + n) - 127;
550 pre = 124 + (pre & 1);
551 s->HEVClc->cabac_state[i] = pre;
555 void ff_hevc_cabac_init(HEVCContext *s, int ctb_addr_ts)
557 if (ctb_addr_ts == s->pps->ctb_addr_rs_to_ts[s->sh.slice_ctb_addr_rs]) {
558 cabac_init_decoder(s);
559 if ((s->sh.dependent_slice_segment_flag == 0) ||
560 (s->pps->tiles_enabled_flag &&
561 (s->pps->tile_id[ctb_addr_ts] != s->pps->tile_id[ctb_addr_ts - 1])))
564 if (!s->sh.first_slice_in_pic_flag && s->pps->entropy_coding_sync_enabled_flag) {
565 if ((ctb_addr_ts % s->sps->ctb_width) == 0) {
566 if (s->sps->ctb_width == 1)
568 else if (s->sh.dependent_slice_segment_flag == 1)
573 if (s->pps->tiles_enabled_flag &&
574 (s->pps->tile_id[ctb_addr_ts] != s->pps->tile_id[ctb_addr_ts - 1])) {
575 if (s->threads_number == 1)
576 cabac_reinit(s->HEVClc);
578 cabac_init_decoder(s);
581 if (s->pps->entropy_coding_sync_enabled_flag) {
582 if ((ctb_addr_ts % s->sps->ctb_width) == 0) {
583 get_cabac_terminate(&s->HEVClc->cc);
584 if (s->threads_number == 1)
585 cabac_reinit(s->HEVClc);
587 cabac_init_decoder(s);
589 if (s->sps->ctb_width == 1)
598 #define GET_CABAC(ctx) get_cabac(&s->HEVClc->cc, &s->HEVClc->cabac_state[ctx])
600 int ff_hevc_sao_merge_flag_decode(HEVCContext *s)
602 return GET_CABAC(elem_offset[SAO_MERGE_FLAG]);
605 int ff_hevc_sao_type_idx_decode(HEVCContext *s)
607 if (!GET_CABAC(elem_offset[SAO_TYPE_IDX]))
610 if (!get_cabac_bypass(&s->HEVClc->cc))
615 int ff_hevc_sao_band_position_decode(HEVCContext *s)
618 int value = get_cabac_bypass(&s->HEVClc->cc);
620 for (i = 0; i < 4; i++)
621 value = (value << 1) | get_cabac_bypass(&s->HEVClc->cc);
625 int ff_hevc_sao_offset_abs_decode(HEVCContext *s)
628 int length = (1 << (FFMIN(s->sps->bit_depth, 10) - 5)) - 1;
630 while (i < length && get_cabac_bypass(&s->HEVClc->cc))
635 int ff_hevc_sao_offset_sign_decode(HEVCContext *s)
637 return get_cabac_bypass(&s->HEVClc->cc);
640 int ff_hevc_sao_eo_class_decode(HEVCContext *s)
642 int ret = (get_cabac_bypass(&s->HEVClc->cc) << 1);
643 ret |= get_cabac_bypass(&s->HEVClc->cc);
647 int ff_hevc_end_of_slice_flag_decode(HEVCContext *s)
649 return get_cabac_terminate(&s->HEVClc->cc);
652 int ff_hevc_cu_transquant_bypass_flag_decode(HEVCContext *s)
654 return GET_CABAC(elem_offset[CU_TRANSQUANT_BYPASS_FLAG]);
657 int ff_hevc_skip_flag_decode(HEVCContext *s, int x0, int y0, int x_cb, int y_cb)
659 int min_cb_width = s->sps->min_cb_width;
661 int x0b = x0 & ((1 << s->sps->log2_ctb_size) - 1);
662 int y0b = y0 & ((1 << s->sps->log2_ctb_size) - 1);
664 if (s->HEVClc->ctb_left_flag || x0b)
665 inc = !!SAMPLE_CTB(s->skip_flag, x_cb-1, y_cb);
666 if (s->HEVClc->ctb_up_flag || y0b)
667 inc += !!SAMPLE_CTB(s->skip_flag, x_cb, y_cb-1);
669 return GET_CABAC(elem_offset[SKIP_FLAG] + inc);
672 int ff_hevc_cu_qp_delta_abs(HEVCContext *s)
678 while (prefix_val < 5 && GET_CABAC(elem_offset[CU_QP_DELTA] + inc)) {
682 if (prefix_val >= 5) {
684 while (k < CABAC_MAX_BIN && get_cabac_bypass(&s->HEVClc->cc)) {
685 suffix_val += 1 << k;
688 if (k == CABAC_MAX_BIN)
689 av_log(s->avctx, AV_LOG_ERROR, "CABAC_MAX_BIN : %d\n", k);
692 suffix_val += get_cabac_bypass(&s->HEVClc->cc) << k;
694 return prefix_val + suffix_val;
697 int ff_hevc_cu_qp_delta_sign_flag(HEVCContext *s)
699 return get_cabac_bypass(&s->HEVClc->cc);
702 int ff_hevc_pred_mode_decode(HEVCContext *s)
704 return GET_CABAC(elem_offset[PRED_MODE_FLAG]);
707 int ff_hevc_split_coding_unit_flag_decode(HEVCContext *s, int ct_depth, int x0, int y0)
709 int inc = 0, depth_left = 0, depth_top = 0;
710 int x0b = x0 & ((1 << s->sps->log2_ctb_size) - 1);
711 int y0b = y0 & ((1 << s->sps->log2_ctb_size) - 1);
712 int x_cb = x0 >> s->sps->log2_min_cb_size;
713 int y_cb = y0 >> s->sps->log2_min_cb_size;
715 if (s->HEVClc->ctb_left_flag || x0b)
716 depth_left = s->tab_ct_depth[(y_cb)*s->sps->min_cb_width + x_cb-1];
717 if (s->HEVClc->ctb_up_flag || y0b)
718 depth_top = s->tab_ct_depth[(y_cb-1)*s->sps->min_cb_width + x_cb];
720 inc += (depth_left > ct_depth);
721 inc += (depth_top > ct_depth);
722 return GET_CABAC(elem_offset[SPLIT_CODING_UNIT_FLAG] + inc);
725 int ff_hevc_part_mode_decode(HEVCContext *s, int log2_cb_size)
727 if (GET_CABAC(elem_offset[PART_MODE])) // 1
729 if (log2_cb_size == s->sps->log2_min_cb_size) {
730 if (s->HEVClc->cu.pred_mode == MODE_INTRA) // 0
732 if (GET_CABAC(elem_offset[PART_MODE] + 1)) // 01
734 if (log2_cb_size == 3) // 00
736 if (GET_CABAC(elem_offset[PART_MODE] + 2)) // 001
738 return PART_NxN; // 000
741 if (!s->sps->amp_enabled_flag) {
742 if (GET_CABAC(elem_offset[PART_MODE] + 1)) // 01
747 if (GET_CABAC(elem_offset[PART_MODE] + 1)) { // 01X, 01XX
748 if (GET_CABAC(elem_offset[PART_MODE] + 3)) // 011
750 if (get_cabac_bypass(&s->HEVClc->cc)) // 0101
752 return PART_2NxnU; // 0100
755 if (GET_CABAC(elem_offset[PART_MODE] + 3)) // 001
757 if (get_cabac_bypass(&s->HEVClc->cc)) // 0001
759 return PART_nLx2N; // 0000
762 int ff_hevc_pcm_flag_decode(HEVCContext *s)
764 return get_cabac_terminate(&s->HEVClc->cc);
767 int ff_hevc_prev_intra_luma_pred_flag_decode(HEVCContext *s)
769 return GET_CABAC(elem_offset[PREV_INTRA_LUMA_PRED_FLAG]);
772 int ff_hevc_mpm_idx_decode(HEVCContext *s)
775 while (i < 2 && get_cabac_bypass(&s->HEVClc->cc))
780 int ff_hevc_rem_intra_luma_pred_mode_decode(HEVCContext *s)
783 int value = get_cabac_bypass(&s->HEVClc->cc);
785 for (i = 0; i < 4; i++)
786 value = (value << 1) | get_cabac_bypass(&s->HEVClc->cc);
790 int ff_hevc_intra_chroma_pred_mode_decode(HEVCContext *s)
793 if (!GET_CABAC(elem_offset[INTRA_CHROMA_PRED_MODE]))
796 ret = (get_cabac_bypass(&s->HEVClc->cc) << 1);
797 ret |= get_cabac_bypass(&s->HEVClc->cc);
801 int ff_hevc_merge_idx_decode(HEVCContext *s)
803 int i = GET_CABAC(elem_offset[MERGE_IDX]);
806 while (i < s->sh.max_num_merge_cand-1 && get_cabac_bypass(&s->HEVClc->cc))
812 int ff_hevc_merge_flag_decode(HEVCContext *s)
814 return GET_CABAC(elem_offset[MERGE_FLAG]);
817 int ff_hevc_inter_pred_idc_decode(HEVCContext *s, int nPbW, int nPbH)
819 if (nPbW + nPbH == 12)
820 return GET_CABAC(elem_offset[INTER_PRED_IDC] + 4);
821 if (GET_CABAC(elem_offset[INTER_PRED_IDC] + s->HEVClc->ct.depth))
824 return GET_CABAC(elem_offset[INTER_PRED_IDC] + 4);
827 int ff_hevc_ref_idx_lx_decode(HEVCContext *s, int num_ref_idx_lx)
830 int max = num_ref_idx_lx - 1;
831 int max_ctx = FFMIN(max, 2);
833 while (i < max_ctx && GET_CABAC(elem_offset[REF_IDX_L0] + i))
836 while (i < max && get_cabac_bypass(&s->HEVClc->cc))
843 int ff_hevc_mvp_lx_flag_decode(HEVCContext *s)
845 return GET_CABAC(elem_offset[MVP_LX_FLAG]);
848 int ff_hevc_no_residual_syntax_flag_decode(HEVCContext *s)
850 return GET_CABAC(elem_offset[NO_RESIDUAL_DATA_FLAG]);
853 static av_always_inline int abs_mvd_greater0_flag_decode(HEVCContext *s)
855 return GET_CABAC(elem_offset[ABS_MVD_GREATER0_FLAG]);
858 static av_always_inline int abs_mvd_greater1_flag_decode(HEVCContext *s)
860 return GET_CABAC(elem_offset[ABS_MVD_GREATER1_FLAG] + 1);
863 static av_always_inline int mvd_decode(HEVCContext *s)
868 while (k < CABAC_MAX_BIN && get_cabac_bypass(&s->HEVClc->cc)) {
872 if (k == CABAC_MAX_BIN)
873 av_log(s->avctx, AV_LOG_ERROR, "CABAC_MAX_BIN : %d\n", k);
875 ret += get_cabac_bypass(&s->HEVClc->cc) << k;
876 return get_cabac_bypass_sign(&s->HEVClc->cc, -ret);
879 static av_always_inline int mvd_sign_flag_decode(HEVCContext *s)
881 return get_cabac_bypass_sign(&s->HEVClc->cc, -1);
884 int ff_hevc_split_transform_flag_decode(HEVCContext *s, int log2_trafo_size)
886 return GET_CABAC(elem_offset[SPLIT_TRANSFORM_FLAG] + 5 - log2_trafo_size);
889 int ff_hevc_cbf_cb_cr_decode(HEVCContext *s, int trafo_depth)
891 return GET_CABAC(elem_offset[CBF_CB_CR] + trafo_depth);
894 int ff_hevc_cbf_luma_decode(HEVCContext *s, int trafo_depth)
896 return GET_CABAC(elem_offset[CBF_LUMA] + !trafo_depth);
899 int ff_hevc_transform_skip_flag_decode(HEVCContext *s, int c_idx)
901 return GET_CABAC(elem_offset[TRANSFORM_SKIP_FLAG] + !!c_idx);
904 #define LAST_SIG_COEFF(elem) \
906 int max = (log2_size << 1) - 1; \
907 int ctx_offset, ctx_shift; \
910 ctx_offset = 3 * (log2_size - 2) + ((log2_size - 1) >> 2); \
911 ctx_shift = (log2_size + 1) >> 2; \
914 ctx_shift = log2_size - 2; \
917 GET_CABAC(elem_offset[elem] + (i >> ctx_shift) + ctx_offset)) \
921 static av_always_inline int last_significant_coeff_x_prefix_decode(HEVCContext *s, int c_idx,
924 LAST_SIG_COEFF(LAST_SIGNIFICANT_COEFF_X_PREFIX)
927 static av_always_inline int last_significant_coeff_y_prefix_decode(HEVCContext *s, int c_idx,
930 LAST_SIG_COEFF(LAST_SIGNIFICANT_COEFF_Y_PREFIX)
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);
954 static av_always_inline int significant_coeff_flag_decode(HEVCContext *s, int c_idx, int x_c, int y_c,
955 int log2_trafo_size, int scan_idx, int prev_sig)
957 static const uint8_t ctx_idx_map[] = {
958 0, 1, 4, 5, 2, 3, 4, 5, 6, 6, 8, 8, 7, 7, 8, 8
965 if (x_c + y_c == 0) {
967 } else if (log2_trafo_size == 2) {
968 sig_ctx = ctx_idx_map[(y_c << 2) + x_c];
974 sig_ctx = ((x_off + y_off) == 0) ? 2 : ((x_off + y_off) <= 2) ? 1 : 0;
978 sig_ctx = 2 - FFMIN(y_c & 3, 2);
981 sig_ctx = 2 - FFMIN(x_c & 3, 2);
987 if (c_idx == 0 && (x_cg > 0 || y_cg > 0))
990 if (log2_trafo_size == 3) {
991 sig_ctx += (scan_idx == SCAN_DIAG) ? 9 : 15;
993 sig_ctx += c_idx ? 12 : 21;
1003 return GET_CABAC(elem_offset[SIGNIFICANT_COEFF_FLAG] + inc);
1006 static av_always_inline int coeff_abs_level_greater1_flag_decode(HEVCContext *s, int c_idx, int inc)
1012 return GET_CABAC(elem_offset[COEFF_ABS_LEVEL_GREATER1_FLAG] + inc);
1015 static av_always_inline int coeff_abs_level_greater2_flag_decode(HEVCContext *s, int c_idx, int inc)
1020 return GET_CABAC(elem_offset[COEFF_ABS_LEVEL_GREATER2_FLAG] + inc);
1023 static av_always_inline int coeff_abs_level_remaining_decode(HEVCContext *s, int base_level, int rc_rice_param)
1027 int last_coeff_abs_level_remaining;
1030 while (prefix < CABAC_MAX_BIN && get_cabac_bypass(&s->HEVClc->cc))
1032 if (prefix == CABAC_MAX_BIN)
1033 av_log(s->avctx, AV_LOG_ERROR, "CABAC_MAX_BIN : %d\n", prefix);
1035 for (i = 0; i < rc_rice_param; i++)
1036 suffix = (suffix << 1) | get_cabac_bypass(&s->HEVClc->cc);
1037 last_coeff_abs_level_remaining = (prefix << rc_rice_param) + suffix;
1039 int prefix_minus3 = prefix - 3;
1040 for (i = 0; i < prefix_minus3 + rc_rice_param; i++)
1041 suffix = (suffix << 1) | get_cabac_bypass(&s->HEVClc->cc);
1042 last_coeff_abs_level_remaining = (((1 << prefix_minus3) + 3 - 1)
1043 << rc_rice_param) + suffix;
1045 return last_coeff_abs_level_remaining;
1048 static av_always_inline int coeff_sign_flag_decode(HEVCContext *s, uint8_t nb)
1053 for (i = 0; i < nb; i++)
1054 ret = (ret << 1) | get_cabac_bypass(&s->HEVClc->cc);
1058 void ff_hevc_hls_residual_coding(HEVCContext *s, int x0, int y0,
1059 int log2_trafo_size, enum ScanType scan_idx,
1062 #define GET_COORD(offset, n) \
1064 x_c = (scan_x_cg[offset >> 4] << 2) + scan_x_off[n]; \
1065 y_c = (scan_y_cg[offset >> 4] << 2) + scan_y_off[n]; \
1067 HEVCLocalContext *lc = s->HEVClc;
1068 int transform_skip_flag = 0;
1070 int last_significant_coeff_x, last_significant_coeff_y;
1074 int greater1_ctx = 1;
1076 int num_last_subset;
1077 int x_cg_last_sig, y_cg_last_sig;
1079 const uint8_t *scan_x_cg, *scan_y_cg, *scan_x_off, *scan_y_off;
1081 ptrdiff_t stride = s->frame->linesize[c_idx];
1082 int hshift = s->sps->hshift[c_idx];
1083 int vshift = s->sps->vshift[c_idx];
1084 uint8_t *dst = &s->frame->data[c_idx][(y0 >> vshift) * stride +
1085 ((x0 >> hshift) << s->sps->pixel_shift)];
1086 DECLARE_ALIGNED(16, int16_t, coeffs[MAX_TB_SIZE * MAX_TB_SIZE]) = {0};
1087 DECLARE_ALIGNED(8, uint8_t, significant_coeff_group_flag[8][8]) = {{0}};
1089 int trafo_size = 1 << log2_trafo_size;
1091 int qp,shift,add,scale,scale_m;
1092 const uint8_t level_scale[] = { 40, 45, 51, 57, 64, 72 };
1093 const uint8_t *scale_matrix;
1096 // Derive QP for dequant
1097 if (!lc->cu.cu_transquant_bypass_flag) {
1098 static const int qp_c[] = { 29, 30, 31, 32, 33, 33, 34, 34, 35, 35, 36, 36, 37, 37 };
1099 static const uint8_t rem6[51 + 2 * 6 + 1] = {
1100 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2,
1101 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5,
1102 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3,
1105 static const uint8_t div6[51 + 2 * 6 + 1] = {
1106 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 3, 3, 3,
1107 3, 3, 3, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6,
1108 7, 7, 7, 7, 7, 7, 8, 8, 8, 8, 8, 8, 9, 9, 9, 9, 9, 9, 10, 10, 10, 10,
1110 int qp_y = lc->qp_y;
1113 qp = qp_y + s->sps->qp_bd_offset;
1118 offset = s->pps->cb_qp_offset + s->sh.slice_cb_qp_offset;
1120 offset = s->pps->cr_qp_offset + s->sh.slice_cr_qp_offset;
1122 qp_i = av_clip_c(qp_y + offset, - s->sps->qp_bd_offset, 57);
1128 qp = qp_c[qp_i - 30];
1130 qp += s->sps->qp_bd_offset;
1133 shift = s->sps->bit_depth + log2_trafo_size - 5;
1134 add = 1 << (shift-1);
1135 scale = level_scale[rem6[qp]] << (div6[qp]);
1136 scale_m = 16; // default when no custom scaling lists.
1139 if (s->sps->scaling_list_enable_flag) {
1140 const ScalingList *sl = s->pps->scaling_list_data_present_flag ?
1141 &s->pps->scaling_list : &s->sps->scaling_list;
1142 int matrix_id = lc->cu.pred_mode != MODE_INTRA;
1144 if (log2_trafo_size != 5)
1145 matrix_id = 3 * matrix_id + c_idx;
1147 scale_matrix = sl->sl[log2_trafo_size - 2][matrix_id];
1148 if (log2_trafo_size >= 4)
1149 dc_scale = sl->sl_dc[log2_trafo_size - 4][matrix_id];
1153 if (s->pps->transform_skip_enabled_flag && !lc->cu.cu_transquant_bypass_flag &&
1154 log2_trafo_size == 2) {
1155 transform_skip_flag = ff_hevc_transform_skip_flag_decode(s, c_idx);
1158 last_significant_coeff_x =
1159 last_significant_coeff_x_prefix_decode(s, c_idx, log2_trafo_size);
1160 last_significant_coeff_y =
1161 last_significant_coeff_y_prefix_decode(s, c_idx, log2_trafo_size);
1163 if (last_significant_coeff_x > 3) {
1164 int suffix = last_significant_coeff_suffix_decode(s, last_significant_coeff_x);
1165 last_significant_coeff_x = (1 << ((last_significant_coeff_x >> 1) - 1)) *
1166 (2 + (last_significant_coeff_x & 1)) +
1170 if (last_significant_coeff_y > 3) {
1171 int suffix = last_significant_coeff_suffix_decode(s, last_significant_coeff_y);
1172 last_significant_coeff_y = (1 << ((last_significant_coeff_y >> 1) - 1)) *
1173 (2 + (last_significant_coeff_y & 1)) +
1177 if (scan_idx == SCAN_VERT)
1178 FFSWAP(int, last_significant_coeff_x, last_significant_coeff_y);
1180 x_cg_last_sig = last_significant_coeff_x >> 2;
1181 y_cg_last_sig = last_significant_coeff_y >> 2;
1185 int last_x_c = last_significant_coeff_x & 3;
1186 int last_y_c = last_significant_coeff_y & 3;
1188 scan_x_off = ff_hevc_diag_scan4x4_x;
1189 scan_y_off = ff_hevc_diag_scan4x4_y;
1190 num_coeff = diag_scan4x4_inv[last_y_c][last_x_c];
1191 if (trafo_size == 4) {
1192 scan_x_cg = scan_1x1;
1193 scan_y_cg = scan_1x1;
1194 } else if (trafo_size == 8) {
1195 num_coeff += diag_scan2x2_inv[y_cg_last_sig][x_cg_last_sig] << 4;
1196 scan_x_cg = diag_scan2x2_x;
1197 scan_y_cg = diag_scan2x2_y;
1198 } else if (trafo_size == 16) {
1199 num_coeff += diag_scan4x4_inv[y_cg_last_sig][x_cg_last_sig] << 4;
1200 scan_x_cg = ff_hevc_diag_scan4x4_x;
1201 scan_y_cg = ff_hevc_diag_scan4x4_y;
1202 } else { // trafo_size == 32
1203 num_coeff += diag_scan8x8_inv[y_cg_last_sig][x_cg_last_sig] << 4;
1204 scan_x_cg = ff_hevc_diag_scan8x8_x;
1205 scan_y_cg = ff_hevc_diag_scan8x8_y;
1210 scan_x_cg = horiz_scan2x2_x;
1211 scan_y_cg = horiz_scan2x2_y;
1212 scan_x_off = horiz_scan4x4_x;
1213 scan_y_off = horiz_scan4x4_y;
1214 num_coeff = horiz_scan8x8_inv[last_significant_coeff_y][last_significant_coeff_x];
1216 default: //SCAN_VERT
1217 scan_x_cg = horiz_scan2x2_y;
1218 scan_y_cg = horiz_scan2x2_x;
1219 scan_x_off = horiz_scan4x4_y;
1220 scan_y_off = horiz_scan4x4_x;
1221 num_coeff = horiz_scan8x8_inv[last_significant_coeff_x][last_significant_coeff_y];
1225 num_last_subset = (num_coeff - 1) >> 4;
1227 for (i = num_last_subset; i >= 0; i--) {
1229 int x_cg, y_cg, x_c, y_c, pos;
1230 int implicit_non_zero_coeff = 0;
1231 int64_t trans_coeff_level;
1233 int offset = i << 4;
1235 uint8_t significant_coeff_flag_idx[16];
1236 uint8_t nb_significant_coeff_flag = 0;
1238 x_cg = scan_x_cg[i];
1239 y_cg = scan_y_cg[i];
1241 if ((i < num_last_subset) && (i > 0)) {
1243 if (x_cg < (1 << (log2_trafo_size - 2)) - 1)
1244 ctx_cg += significant_coeff_group_flag[x_cg + 1][y_cg];
1245 if (y_cg < (1 << (log2_trafo_size - 2)) - 1)
1246 ctx_cg += significant_coeff_group_flag[x_cg][y_cg + 1];
1248 significant_coeff_group_flag[x_cg][y_cg] =
1249 significant_coeff_group_flag_decode(s, c_idx, ctx_cg);
1250 implicit_non_zero_coeff = 1;
1252 significant_coeff_group_flag[x_cg][y_cg] =
1253 ((x_cg == x_cg_last_sig && y_cg == y_cg_last_sig) ||
1254 (x_cg == 0 && y_cg == 0));
1257 last_scan_pos = num_coeff - offset - 1;
1259 if (i == num_last_subset) {
1260 n_end = last_scan_pos - 1;
1261 significant_coeff_flag_idx[0] = last_scan_pos;
1262 nb_significant_coeff_flag = 1;
1267 if (x_cg < ((1 << log2_trafo_size) - 1) >> 2)
1268 prev_sig = significant_coeff_group_flag[x_cg + 1][y_cg];
1269 if (y_cg < ((1 << log2_trafo_size) - 1) >> 2)
1270 prev_sig += (significant_coeff_group_flag[x_cg][y_cg + 1] << 1);
1272 for (n = n_end; n >= 0; n--) {
1273 GET_COORD(offset, n);
1275 if (significant_coeff_group_flag[x_cg][y_cg] &&
1276 (n > 0 || implicit_non_zero_coeff == 0)) {
1277 if (significant_coeff_flag_decode(s, c_idx, x_c, y_c, log2_trafo_size, scan_idx, prev_sig) == 1) {
1278 significant_coeff_flag_idx[nb_significant_coeff_flag] = n;
1279 nb_significant_coeff_flag++;
1280 implicit_non_zero_coeff = 0;
1283 int last_cg = (x_c == (x_cg << 2) && y_c == (y_cg << 2));
1284 if (last_cg && implicit_non_zero_coeff && significant_coeff_group_flag[x_cg][y_cg]) {
1285 significant_coeff_flag_idx[nb_significant_coeff_flag] = n;
1286 nb_significant_coeff_flag++;
1291 n_end = nb_significant_coeff_flag;
1295 int first_nz_pos_in_cg = 16;
1296 int last_nz_pos_in_cg = -1;
1297 int c_rice_param = 0;
1298 int first_greater1_coeff_idx = -1;
1299 uint8_t coeff_abs_level_greater1_flag[16] = {0};
1300 uint16_t coeff_sign_flag;
1302 int sign_hidden = 0;
1304 // initialize first elem of coeff_bas_level_greater1_flag
1305 int ctx_set = (i > 0 && c_idx == 0) ? 2 : 0;
1307 if (!(i == num_last_subset) && greater1_ctx == 0)
1310 last_nz_pos_in_cg = significant_coeff_flag_idx[0];
1312 for (m = 0; m < (n_end > 8 ? 8 : n_end); m++) {
1313 int n_idx = significant_coeff_flag_idx[m];
1314 int inc = (ctx_set << 2) + greater1_ctx;
1315 coeff_abs_level_greater1_flag[n_idx] =
1316 coeff_abs_level_greater1_flag_decode(s, c_idx, inc);
1317 if (coeff_abs_level_greater1_flag[n_idx]) {
1319 } else if (greater1_ctx > 0 && greater1_ctx < 3) {
1323 if (coeff_abs_level_greater1_flag[n_idx] &&
1324 first_greater1_coeff_idx == -1)
1325 first_greater1_coeff_idx = n_idx;
1327 first_nz_pos_in_cg = significant_coeff_flag_idx[n_end - 1];
1328 sign_hidden = (last_nz_pos_in_cg - first_nz_pos_in_cg >= 4 &&
1329 !lc->cu.cu_transquant_bypass_flag);
1331 if (first_greater1_coeff_idx != -1) {
1332 coeff_abs_level_greater1_flag[first_greater1_coeff_idx] += coeff_abs_level_greater2_flag_decode(s, c_idx, ctx_set);
1334 if (!s->pps->sign_data_hiding_flag || !sign_hidden ) {
1335 coeff_sign_flag = coeff_sign_flag_decode(s, nb_significant_coeff_flag) << (16 - nb_significant_coeff_flag);
1337 coeff_sign_flag = coeff_sign_flag_decode(s, nb_significant_coeff_flag - 1) << (16 - (nb_significant_coeff_flag - 1));
1340 for (m = 0; m < n_end; m++) {
1341 n = significant_coeff_flag_idx[m];
1342 GET_COORD(offset, n);
1343 trans_coeff_level = 1 + coeff_abs_level_greater1_flag[n];
1344 if (trans_coeff_level == ((m < 8) ?
1345 ((n == first_greater1_coeff_idx) ? 3 : 2) : 1)) {
1346 int last_coeff_abs_level_remaining = coeff_abs_level_remaining_decode(s, trans_coeff_level, c_rice_param);
1348 trans_coeff_level += last_coeff_abs_level_remaining;
1349 if (trans_coeff_level > (3 << c_rice_param))
1350 c_rice_param = FFMIN(c_rice_param + 1, 4);
1353 if (s->pps->sign_data_hiding_flag && sign_hidden) {
1354 sum_abs += trans_coeff_level;
1355 if (n == first_nz_pos_in_cg && (sum_abs&1))
1356 trans_coeff_level = -trans_coeff_level;
1358 if (coeff_sign_flag >> 15)
1359 trans_coeff_level = -trans_coeff_level;
1360 coeff_sign_flag <<= 1;
1361 if(!lc->cu.cu_transquant_bypass_flag) {
1362 if(s->sps->scaling_list_enable_flag) {
1363 if(y_c || x_c || log2_trafo_size < 4) {
1364 switch(log2_trafo_size) {
1365 case 3: pos = (y_c << 3) + x_c; break;
1366 case 4: pos = ((y_c >> 1) << 3) + (x_c >> 1); break;
1367 case 5: pos = ((y_c >> 2) << 3) + (x_c >> 2); break;
1368 default: pos = (y_c << 2) + x_c;
1370 scale_m = scale_matrix[pos];
1375 trans_coeff_level = (trans_coeff_level * (int64_t)scale * (int64_t)scale_m + add) >> shift;
1376 if(trans_coeff_level < 0) {
1377 if((~trans_coeff_level) & 0xFffffffffff8000)
1378 trans_coeff_level = -32768;
1380 if(trans_coeff_level & 0xffffffffffff8000)
1381 trans_coeff_level = 32767;
1384 coeffs[y_c * trafo_size + x_c] = trans_coeff_level;
1389 if (lc->cu.cu_transquant_bypass_flag) {
1390 s->hevcdsp.transquant_bypass[log2_trafo_size-2](dst, coeffs, stride);
1392 if (transform_skip_flag)
1393 s->hevcdsp.transform_skip(dst, coeffs, stride);
1394 else if (lc->cu.pred_mode == MODE_INTRA && c_idx == 0 && log2_trafo_size == 2)
1395 s->hevcdsp.transform_4x4_luma_add(dst, coeffs, stride);
1397 s->hevcdsp.transform_add[log2_trafo_size-2](dst, coeffs, stride);
1401 void ff_hevc_hls_mvd_coding(HEVCContext *s, int x0, int y0, int log2_cb_size)
1403 HEVCLocalContext *lc = s->HEVClc;
1404 int x = abs_mvd_greater0_flag_decode(s);
1405 int y = abs_mvd_greater0_flag_decode(s);
1408 x += abs_mvd_greater1_flag_decode(s);
1410 y += abs_mvd_greater1_flag_decode(s);
1413 case 2: lc->pu.mvd.x = mvd_decode(s); break;
1414 case 1: lc->pu.mvd.x = mvd_sign_flag_decode(s); break;
1415 case 0: lc->pu.mvd.x = 0; break;
1419 case 2: lc->pu.mvd.y = mvd_decode(s); break;
1420 case 1: lc->pu.mvd.y = mvd_sign_flag_decode(s); break;
1421 case 0: lc->pu.mvd.y = 0; break;