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 47, // transform_skip_flag[][]
126 49, // explicit_rdpcm_flag[][]
127 51, // explicit_rdpcm_dir_flag[][]
128 53, // last_significant_coeff_x_prefix
129 71, // last_significant_coeff_y_prefix
130 89, // last_significant_coeff_x_suffix
131 89, // last_significant_coeff_y_suffix
132 89, // significant_coeff_group_flag
133 93, // significant_coeff_flag
134 137, // coeff_abs_level_greater1_flag
135 161, // coeff_abs_level_greater2_flag
136 167, // coeff_abs_level_remaining
137 167, // coeff_sign_flag
138 167, // log2_res_scale_abs
139 175, // res_scale_sign_flag
140 177, // cu_chroma_qp_offset_flag
141 178, // 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
192 94, 138, 182, 154, 154,
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
269 149, 107, 167, 154, 154,
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
346 149, 92, 167, 154, 154,
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);
457 if (s->ps.sps->persistent_rice_adaptation_enabled_flag) {
458 memcpy(s->stat_coeff, s->HEVClc->stat_coeff, HEVC_STAT_COEFFS);
463 static void load_states(HEVCContext *s, int thread)
465 memcpy(s->HEVClc->cabac_state, s->cabac_state, HEVC_CONTEXTS);
466 if (s->ps.sps->persistent_rice_adaptation_enabled_flag) {
467 const HEVCContext *prev = s->sList[(thread + s->threads_number - 1) % s->threads_number];
468 memcpy(s->HEVClc->stat_coeff, prev->stat_coeff, HEVC_STAT_COEFFS);
472 static int cabac_reinit(HEVCLocalContext *lc)
474 return skip_bytes(&lc->cc, 0) == NULL ? AVERROR_INVALIDDATA : 0;
477 static int cabac_init_decoder(HEVCContext *s)
479 GetBitContext *gb = &s->HEVClc->gb;
482 return ff_init_cabac_decoder(&s->HEVClc->cc,
483 gb->buffer + get_bits_count(gb) / 8,
484 (get_bits_left(gb) + 7) / 8);
487 static void cabac_init_state(HEVCContext *s)
489 int init_type = 2 - s->sh.slice_type;
492 if (s->sh.cabac_init_flag && s->sh.slice_type != HEVC_SLICE_I)
495 for (i = 0; i < HEVC_CONTEXTS; i++) {
496 int init_value = init_values[init_type][i];
497 int m = (init_value >> 4) * 5 - 45;
498 int n = ((init_value & 15) << 3) - 16;
499 int pre = 2 * (((m * av_clip(s->sh.slice_qp, 0, 51)) >> 4) + n) - 127;
503 pre = 124 + (pre & 1);
504 s->HEVClc->cabac_state[i] = pre;
507 for (i = 0; i < 4; i++)
508 s->HEVClc->stat_coeff[i] = 0;
511 int ff_hevc_cabac_init(HEVCContext *s, int ctb_addr_ts, int thread)
513 if (ctb_addr_ts == s->ps.pps->ctb_addr_rs_to_ts[s->sh.slice_ctb_addr_rs]) {
514 int ret = cabac_init_decoder(s);
517 if (s->sh.dependent_slice_segment_flag == 0 ||
518 (s->ps.pps->tiles_enabled_flag &&
519 s->ps.pps->tile_id[ctb_addr_ts] != s->ps.pps->tile_id[ctb_addr_ts - 1]))
522 if (!s->sh.first_slice_in_pic_flag &&
523 s->ps.pps->entropy_coding_sync_enabled_flag) {
524 if (ctb_addr_ts % s->ps.sps->ctb_width == 0) {
525 if (s->ps.sps->ctb_width == 1)
527 else if (s->sh.dependent_slice_segment_flag == 1)
528 load_states(s, thread);
532 if (s->ps.pps->tiles_enabled_flag &&
533 s->ps.pps->tile_id[ctb_addr_ts] != s->ps.pps->tile_id[ctb_addr_ts - 1]) {
535 if (s->threads_number == 1)
536 ret = cabac_reinit(s->HEVClc);
538 ret = cabac_init_decoder(s);
544 if (s->ps.pps->entropy_coding_sync_enabled_flag) {
545 if (ctb_addr_ts % s->ps.sps->ctb_width == 0) {
547 get_cabac_terminate(&s->HEVClc->cc);
548 if (s->threads_number == 1)
549 ret = cabac_reinit(s->HEVClc);
551 ret = cabac_init_decoder(s);
556 if (s->ps.sps->ctb_width == 1)
559 load_states(s, thread);
566 #define GET_CABAC(ctx) get_cabac(&s->HEVClc->cc, &s->HEVClc->cabac_state[ctx])
568 int ff_hevc_sao_merge_flag_decode(HEVCContext *s)
570 return GET_CABAC(elem_offset[SAO_MERGE_FLAG]);
573 int ff_hevc_sao_type_idx_decode(HEVCContext *s)
575 if (!GET_CABAC(elem_offset[SAO_TYPE_IDX]))
578 if (!get_cabac_bypass(&s->HEVClc->cc))
583 int ff_hevc_sao_band_position_decode(HEVCContext *s)
586 int value = get_cabac_bypass(&s->HEVClc->cc);
588 for (i = 0; i < 4; i++)
589 value = (value << 1) | get_cabac_bypass(&s->HEVClc->cc);
593 int ff_hevc_sao_offset_abs_decode(HEVCContext *s)
596 int length = (1 << (FFMIN(s->ps.sps->bit_depth, 10) - 5)) - 1;
598 while (i < length && get_cabac_bypass(&s->HEVClc->cc))
603 int ff_hevc_sao_offset_sign_decode(HEVCContext *s)
605 return get_cabac_bypass(&s->HEVClc->cc);
608 int ff_hevc_sao_eo_class_decode(HEVCContext *s)
610 int ret = get_cabac_bypass(&s->HEVClc->cc) << 1;
611 ret |= get_cabac_bypass(&s->HEVClc->cc);
615 int ff_hevc_end_of_slice_flag_decode(HEVCContext *s)
617 return get_cabac_terminate(&s->HEVClc->cc);
620 int ff_hevc_cu_transquant_bypass_flag_decode(HEVCContext *s)
622 return GET_CABAC(elem_offset[CU_TRANSQUANT_BYPASS_FLAG]);
625 int ff_hevc_skip_flag_decode(HEVCContext *s, int x0, int y0, int x_cb, int y_cb)
627 int min_cb_width = s->ps.sps->min_cb_width;
629 int x0b = av_mod_uintp2(x0, s->ps.sps->log2_ctb_size);
630 int y0b = av_mod_uintp2(y0, s->ps.sps->log2_ctb_size);
632 if (s->HEVClc->ctb_left_flag || x0b)
633 inc = !!SAMPLE_CTB(s->skip_flag, x_cb - 1, y_cb);
634 if (s->HEVClc->ctb_up_flag || y0b)
635 inc += !!SAMPLE_CTB(s->skip_flag, x_cb, y_cb - 1);
637 return GET_CABAC(elem_offset[SKIP_FLAG] + inc);
640 int ff_hevc_cu_qp_delta_abs(HEVCContext *s)
646 while (prefix_val < 5 && GET_CABAC(elem_offset[CU_QP_DELTA] + inc)) {
650 if (prefix_val >= 5) {
652 while (k < 7 && get_cabac_bypass(&s->HEVClc->cc)) {
653 suffix_val += 1 << k;
657 av_log(s->avctx, AV_LOG_ERROR, "CABAC_MAX_BIN : %d\n", k);
658 return AVERROR_INVALIDDATA;
662 suffix_val += get_cabac_bypass(&s->HEVClc->cc) << k;
664 return prefix_val + suffix_val;
667 int ff_hevc_cu_qp_delta_sign_flag(HEVCContext *s)
669 return get_cabac_bypass(&s->HEVClc->cc);
672 int ff_hevc_cu_chroma_qp_offset_flag(HEVCContext *s)
674 return GET_CABAC(elem_offset[CU_CHROMA_QP_OFFSET_FLAG]);
677 int ff_hevc_cu_chroma_qp_offset_idx(HEVCContext *s)
679 int c_max= FFMAX(5, s->ps.pps->chroma_qp_offset_list_len_minus1);
682 while (i < c_max && GET_CABAC(elem_offset[CU_CHROMA_QP_OFFSET_IDX]))
688 int ff_hevc_pred_mode_decode(HEVCContext *s)
690 return GET_CABAC(elem_offset[PRED_MODE_FLAG]);
693 int ff_hevc_split_coding_unit_flag_decode(HEVCContext *s, int ct_depth, int x0, int y0)
695 int inc = 0, depth_left = 0, depth_top = 0;
696 int x0b = av_mod_uintp2(x0, s->ps.sps->log2_ctb_size);
697 int y0b = av_mod_uintp2(y0, s->ps.sps->log2_ctb_size);
698 int x_cb = x0 >> s->ps.sps->log2_min_cb_size;
699 int y_cb = y0 >> s->ps.sps->log2_min_cb_size;
701 if (s->HEVClc->ctb_left_flag || x0b)
702 depth_left = s->tab_ct_depth[(y_cb) * s->ps.sps->min_cb_width + x_cb - 1];
703 if (s->HEVClc->ctb_up_flag || y0b)
704 depth_top = s->tab_ct_depth[(y_cb - 1) * s->ps.sps->min_cb_width + x_cb];
706 inc += (depth_left > ct_depth);
707 inc += (depth_top > ct_depth);
709 return GET_CABAC(elem_offset[SPLIT_CODING_UNIT_FLAG] + inc);
712 int ff_hevc_part_mode_decode(HEVCContext *s, int log2_cb_size)
714 if (GET_CABAC(elem_offset[PART_MODE])) // 1
716 if (log2_cb_size == s->ps.sps->log2_min_cb_size) {
717 if (s->HEVClc->cu.pred_mode == MODE_INTRA) // 0
719 if (GET_CABAC(elem_offset[PART_MODE] + 1)) // 01
721 if (log2_cb_size == 3) // 00
723 if (GET_CABAC(elem_offset[PART_MODE] + 2)) // 001
725 return PART_NxN; // 000
728 if (!s->ps.sps->amp_enabled_flag) {
729 if (GET_CABAC(elem_offset[PART_MODE] + 1)) // 01
734 if (GET_CABAC(elem_offset[PART_MODE] + 1)) { // 01X, 01XX
735 if (GET_CABAC(elem_offset[PART_MODE] + 3)) // 011
737 if (get_cabac_bypass(&s->HEVClc->cc)) // 0101
739 return PART_2NxnU; // 0100
742 if (GET_CABAC(elem_offset[PART_MODE] + 3)) // 001
744 if (get_cabac_bypass(&s->HEVClc->cc)) // 0001
746 return PART_nLx2N; // 0000
749 int ff_hevc_pcm_flag_decode(HEVCContext *s)
751 return get_cabac_terminate(&s->HEVClc->cc);
754 int ff_hevc_prev_intra_luma_pred_flag_decode(HEVCContext *s)
756 return GET_CABAC(elem_offset[PREV_INTRA_LUMA_PRED_FLAG]);
759 int ff_hevc_mpm_idx_decode(HEVCContext *s)
762 while (i < 2 && get_cabac_bypass(&s->HEVClc->cc))
767 int ff_hevc_rem_intra_luma_pred_mode_decode(HEVCContext *s)
770 int value = get_cabac_bypass(&s->HEVClc->cc);
772 for (i = 0; i < 4; i++)
773 value = (value << 1) | get_cabac_bypass(&s->HEVClc->cc);
777 int ff_hevc_intra_chroma_pred_mode_decode(HEVCContext *s)
780 if (!GET_CABAC(elem_offset[INTRA_CHROMA_PRED_MODE]))
783 ret = get_cabac_bypass(&s->HEVClc->cc) << 1;
784 ret |= get_cabac_bypass(&s->HEVClc->cc);
788 int ff_hevc_merge_idx_decode(HEVCContext *s)
790 int i = GET_CABAC(elem_offset[MERGE_IDX]);
793 while (i < s->sh.max_num_merge_cand-1 && get_cabac_bypass(&s->HEVClc->cc))
799 int ff_hevc_merge_flag_decode(HEVCContext *s)
801 return GET_CABAC(elem_offset[MERGE_FLAG]);
804 int ff_hevc_inter_pred_idc_decode(HEVCContext *s, int nPbW, int nPbH)
806 if (nPbW + nPbH == 12)
807 return GET_CABAC(elem_offset[INTER_PRED_IDC] + 4);
808 if (GET_CABAC(elem_offset[INTER_PRED_IDC] + s->HEVClc->ct_depth))
811 return GET_CABAC(elem_offset[INTER_PRED_IDC] + 4);
814 int ff_hevc_ref_idx_lx_decode(HEVCContext *s, int num_ref_idx_lx)
817 int max = num_ref_idx_lx - 1;
818 int max_ctx = FFMIN(max, 2);
820 while (i < max_ctx && GET_CABAC(elem_offset[REF_IDX_L0] + i))
823 while (i < max && get_cabac_bypass(&s->HEVClc->cc))
830 int ff_hevc_mvp_lx_flag_decode(HEVCContext *s)
832 return GET_CABAC(elem_offset[MVP_LX_FLAG]);
835 int ff_hevc_no_residual_syntax_flag_decode(HEVCContext *s)
837 return GET_CABAC(elem_offset[NO_RESIDUAL_DATA_FLAG]);
840 static av_always_inline int abs_mvd_greater0_flag_decode(HEVCContext *s)
842 return GET_CABAC(elem_offset[ABS_MVD_GREATER0_FLAG]);
845 static av_always_inline int abs_mvd_greater1_flag_decode(HEVCContext *s)
847 return GET_CABAC(elem_offset[ABS_MVD_GREATER1_FLAG] + 1);
850 static av_always_inline int mvd_decode(HEVCContext *s)
855 while (k < CABAC_MAX_BIN && get_cabac_bypass(&s->HEVClc->cc)) {
859 if (k == CABAC_MAX_BIN) {
860 av_log(s->avctx, AV_LOG_ERROR, "CABAC_MAX_BIN : %d\n", k);
864 ret += get_cabac_bypass(&s->HEVClc->cc) << k;
865 return get_cabac_bypass_sign(&s->HEVClc->cc, -ret);
868 static av_always_inline int mvd_sign_flag_decode(HEVCContext *s)
870 return get_cabac_bypass_sign(&s->HEVClc->cc, -1);
873 int ff_hevc_split_transform_flag_decode(HEVCContext *s, int log2_trafo_size)
875 return GET_CABAC(elem_offset[SPLIT_TRANSFORM_FLAG] + 5 - log2_trafo_size);
878 int ff_hevc_cbf_cb_cr_decode(HEVCContext *s, int trafo_depth)
880 return GET_CABAC(elem_offset[CBF_CB_CR] + trafo_depth);
883 int ff_hevc_cbf_luma_decode(HEVCContext *s, int trafo_depth)
885 return GET_CABAC(elem_offset[CBF_LUMA] + !trafo_depth);
888 static int hevc_transform_skip_flag_decode(HEVCContext *s, int c_idx)
890 return GET_CABAC(elem_offset[TRANSFORM_SKIP_FLAG] + !!c_idx);
893 static int explicit_rdpcm_flag_decode(HEVCContext *s, int c_idx)
895 return GET_CABAC(elem_offset[EXPLICIT_RDPCM_FLAG] + !!c_idx);
898 static int explicit_rdpcm_dir_flag_decode(HEVCContext *s, int c_idx)
900 return GET_CABAC(elem_offset[EXPLICIT_RDPCM_DIR_FLAG] + !!c_idx);
903 int ff_hevc_log2_res_scale_abs(HEVCContext *s, int idx) {
906 while (i < 4 && GET_CABAC(elem_offset[LOG2_RES_SCALE_ABS] + 4 * idx + i))
912 int ff_hevc_res_scale_sign_flag(HEVCContext *s, int idx) {
913 return GET_CABAC(elem_offset[RES_SCALE_SIGN_FLAG] + idx);
916 static av_always_inline void last_significant_coeff_xy_prefix_decode(HEVCContext *s, int c_idx,
917 int log2_size, int *last_scx_prefix, int *last_scy_prefix)
920 int max = (log2_size << 1) - 1;
921 int ctx_offset, ctx_shift;
924 ctx_offset = 3 * (log2_size - 2) + ((log2_size - 1) >> 2);
925 ctx_shift = (log2_size + 1) >> 2;
928 ctx_shift = log2_size - 2;
931 GET_CABAC(elem_offset[LAST_SIGNIFICANT_COEFF_X_PREFIX] + (i >> ctx_shift) + ctx_offset))
933 *last_scx_prefix = i;
937 GET_CABAC(elem_offset[LAST_SIGNIFICANT_COEFF_Y_PREFIX] + (i >> ctx_shift) + ctx_offset))
939 *last_scy_prefix = i;
942 static av_always_inline int last_significant_coeff_suffix_decode(HEVCContext *s,
943 int last_significant_coeff_prefix)
946 int length = (last_significant_coeff_prefix >> 1) - 1;
947 int value = get_cabac_bypass(&s->HEVClc->cc);
949 for (i = 1; i < length; i++)
950 value = (value << 1) | get_cabac_bypass(&s->HEVClc->cc);
954 static av_always_inline int significant_coeff_group_flag_decode(HEVCContext *s, int c_idx, int ctx_cg)
958 inc = FFMIN(ctx_cg, 1) + (c_idx>0 ? 2 : 0);
960 return GET_CABAC(elem_offset[SIGNIFICANT_COEFF_GROUP_FLAG] + inc);
962 static av_always_inline int significant_coeff_flag_decode(HEVCContext *s, int x_c, int y_c,
963 int offset, const uint8_t *ctx_idx_map)
965 int inc = ctx_idx_map[(y_c << 2) + x_c] + offset;
966 return GET_CABAC(elem_offset[SIGNIFICANT_COEFF_FLAG] + inc);
969 static av_always_inline int significant_coeff_flag_decode_0(HEVCContext *s, int c_idx, int offset)
971 return GET_CABAC(elem_offset[SIGNIFICANT_COEFF_FLAG] + offset);
974 static av_always_inline int coeff_abs_level_greater1_flag_decode(HEVCContext *s, int c_idx, int inc)
980 return GET_CABAC(elem_offset[COEFF_ABS_LEVEL_GREATER1_FLAG] + inc);
983 static av_always_inline int coeff_abs_level_greater2_flag_decode(HEVCContext *s, int c_idx, int inc)
988 return GET_CABAC(elem_offset[COEFF_ABS_LEVEL_GREATER2_FLAG] + inc);
991 static av_always_inline int coeff_abs_level_remaining_decode(HEVCContext *s, int rc_rice_param)
995 int last_coeff_abs_level_remaining;
998 while (prefix < CABAC_MAX_BIN && get_cabac_bypass(&s->HEVClc->cc))
1002 for (i = 0; i < rc_rice_param; i++)
1003 suffix = (suffix << 1) | get_cabac_bypass(&s->HEVClc->cc);
1004 last_coeff_abs_level_remaining = (prefix << rc_rice_param) + suffix;
1006 int prefix_minus3 = prefix - 3;
1008 if (prefix == CABAC_MAX_BIN || prefix_minus3 + rc_rice_param > 16 + 6) {
1009 av_log(s->avctx, AV_LOG_ERROR, "CABAC_MAX_BIN : %d\n", prefix);
1013 for (i = 0; i < prefix_minus3 + rc_rice_param; i++)
1014 suffix = (suffix << 1) | get_cabac_bypass(&s->HEVClc->cc);
1015 last_coeff_abs_level_remaining = (((1 << prefix_minus3) + 3 - 1)
1016 << rc_rice_param) + suffix;
1018 return last_coeff_abs_level_remaining;
1021 static av_always_inline int coeff_sign_flag_decode(HEVCContext *s, uint8_t nb)
1026 for (i = 0; i < nb; i++)
1027 ret = (ret << 1) | get_cabac_bypass(&s->HEVClc->cc);
1031 void ff_hevc_hls_residual_coding(HEVCContext *s, int x0, int y0,
1032 int log2_trafo_size, enum ScanType scan_idx,
1035 #define GET_COORD(offset, n) \
1037 x_c = (x_cg << 2) + scan_x_off[n]; \
1038 y_c = (y_cg << 2) + scan_y_off[n]; \
1040 HEVCLocalContext *lc = s->HEVClc;
1041 int transform_skip_flag = 0;
1043 int last_significant_coeff_x, last_significant_coeff_y;
1047 int greater1_ctx = 1;
1049 int num_last_subset;
1050 int x_cg_last_sig, y_cg_last_sig;
1052 const uint8_t *scan_x_cg, *scan_y_cg, *scan_x_off, *scan_y_off;
1054 ptrdiff_t stride = s->frame->linesize[c_idx];
1055 int hshift = s->ps.sps->hshift[c_idx];
1056 int vshift = s->ps.sps->vshift[c_idx];
1057 uint8_t *dst = &s->frame->data[c_idx][(y0 >> vshift) * stride +
1058 ((x0 >> hshift) << s->ps.sps->pixel_shift)];
1059 int16_t *coeffs = (int16_t*)(c_idx ? lc->edge_emu_buffer2 : lc->edge_emu_buffer);
1060 uint8_t significant_coeff_group_flag[8][8] = {{0}};
1061 int explicit_rdpcm_flag = 0;
1062 int explicit_rdpcm_dir_flag;
1064 int trafo_size = 1 << log2_trafo_size;
1066 int qp,shift,add,scale,scale_m;
1067 static const uint8_t level_scale[] = { 40, 45, 51, 57, 64, 72 };
1068 const uint8_t *scale_matrix = NULL;
1070 int pred_mode_intra = (c_idx == 0) ? lc->tu.intra_pred_mode :
1071 lc->tu.intra_pred_mode_c;
1073 memset(coeffs, 0, trafo_size * trafo_size * sizeof(int16_t));
1075 // Derive QP for dequant
1076 if (!lc->cu.cu_transquant_bypass_flag) {
1077 static const int qp_c[] = { 29, 30, 31, 32, 33, 33, 34, 34, 35, 35, 36, 36, 37, 37 };
1078 static const uint8_t rem6[51 + 4 * 6 + 1] = {
1079 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2,
1080 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5,
1081 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3,
1082 4, 5, 0, 1, 2, 3, 4, 5, 0, 1
1085 static const uint8_t div6[51 + 4 * 6 + 1] = {
1086 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 3, 3, 3,
1087 3, 3, 3, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6,
1088 7, 7, 7, 7, 7, 7, 8, 8, 8, 8, 8, 8, 9, 9, 9, 9, 9, 9, 10, 10, 10, 10,
1089 10, 10, 11, 11, 11, 11, 11, 11, 12, 12
1091 int qp_y = lc->qp_y;
1093 if (s->ps.pps->transform_skip_enabled_flag &&
1094 log2_trafo_size <= s->ps.pps->log2_max_transform_skip_block_size) {
1095 transform_skip_flag = hevc_transform_skip_flag_decode(s, c_idx);
1099 qp = qp_y + s->ps.sps->qp_bd_offset;
1104 offset = s->ps.pps->cb_qp_offset + s->sh.slice_cb_qp_offset +
1105 lc->tu.cu_qp_offset_cb;
1107 offset = s->ps.pps->cr_qp_offset + s->sh.slice_cr_qp_offset +
1108 lc->tu.cu_qp_offset_cr;
1110 qp_i = av_clip(qp_y + offset, - s->ps.sps->qp_bd_offset, 57);
1111 if (s->ps.sps->chroma_format_idc == 1) {
1117 qp = qp_c[qp_i - 30];
1125 qp += s->ps.sps->qp_bd_offset;
1128 shift = s->ps.sps->bit_depth + log2_trafo_size - 5;
1129 add = 1 << (shift-1);
1130 scale = level_scale[rem6[qp]] << (div6[qp]);
1131 scale_m = 16; // default when no custom scaling lists.
1134 if (s->ps.sps->scaling_list_enable_flag && !(transform_skip_flag && log2_trafo_size > 2)) {
1135 const ScalingList *sl = s->ps.pps->scaling_list_data_present_flag ?
1136 &s->ps.pps->scaling_list : &s->ps.sps->scaling_list;
1137 int matrix_id = lc->cu.pred_mode != MODE_INTRA;
1139 matrix_id = 3 * matrix_id + c_idx;
1141 scale_matrix = sl->sl[log2_trafo_size - 2][matrix_id];
1142 if (log2_trafo_size >= 4)
1143 dc_scale = sl->sl_dc[log2_trafo_size - 4][matrix_id];
1152 if (lc->cu.pred_mode == MODE_INTER && s->ps.sps->explicit_rdpcm_enabled_flag &&
1153 (transform_skip_flag || lc->cu.cu_transquant_bypass_flag)) {
1154 explicit_rdpcm_flag = explicit_rdpcm_flag_decode(s, c_idx);
1155 if (explicit_rdpcm_flag) {
1156 explicit_rdpcm_dir_flag = explicit_rdpcm_dir_flag_decode(s, c_idx);
1160 last_significant_coeff_xy_prefix_decode(s, c_idx, log2_trafo_size,
1161 &last_significant_coeff_x, &last_significant_coeff_y);
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;
1236 uint8_t significant_coeff_flag_idx[16];
1237 uint8_t nb_significant_coeff_flag = 0;
1239 x_cg = scan_x_cg[i];
1240 y_cg = scan_y_cg[i];
1242 if ((i < num_last_subset) && (i > 0)) {
1244 if (x_cg < (1 << (log2_trafo_size - 2)) - 1)
1245 ctx_cg += significant_coeff_group_flag[x_cg + 1][y_cg];
1246 if (y_cg < (1 << (log2_trafo_size - 2)) - 1)
1247 ctx_cg += significant_coeff_group_flag[x_cg][y_cg + 1];
1249 significant_coeff_group_flag[x_cg][y_cg] =
1250 significant_coeff_group_flag_decode(s, c_idx, ctx_cg);
1251 implicit_non_zero_coeff = 1;
1253 significant_coeff_group_flag[x_cg][y_cg] =
1254 ((x_cg == x_cg_last_sig && y_cg == y_cg_last_sig) ||
1255 (x_cg == 0 && y_cg == 0));
1258 last_scan_pos = num_coeff - offset - 1;
1260 if (i == num_last_subset) {
1261 n_end = last_scan_pos - 1;
1262 significant_coeff_flag_idx[0] = last_scan_pos;
1263 nb_significant_coeff_flag = 1;
1268 if (x_cg < ((1 << log2_trafo_size) - 1) >> 2)
1269 prev_sig = !!significant_coeff_group_flag[x_cg + 1][y_cg];
1270 if (y_cg < ((1 << log2_trafo_size) - 1) >> 2)
1271 prev_sig += (!!significant_coeff_group_flag[x_cg][y_cg + 1] << 1);
1273 if (significant_coeff_group_flag[x_cg][y_cg] && n_end >= 0) {
1274 static const uint8_t ctx_idx_map[] = {
1275 0, 1, 4, 5, 2, 3, 4, 5, 6, 6, 8, 8, 7, 7, 8, 8, // log2_trafo_size == 2
1276 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, // prev_sig == 0
1277 2, 2, 2, 2, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, // prev_sig == 1
1278 2, 1, 0, 0, 2, 1, 0, 0, 2, 1, 0, 0, 2, 1, 0, 0, // prev_sig == 2
1279 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2 // default
1281 const uint8_t *ctx_idx_map_p;
1283 if (s->ps.sps->transform_skip_context_enabled_flag &&
1284 (transform_skip_flag || lc->cu.cu_transquant_bypass_flag)) {
1285 ctx_idx_map_p = (uint8_t*) &ctx_idx_map[4 * 16];
1289 scf_offset = 14 + 27;
1294 if (log2_trafo_size == 2) {
1295 ctx_idx_map_p = (uint8_t*) &ctx_idx_map[0];
1297 ctx_idx_map_p = (uint8_t*) &ctx_idx_map[(prev_sig + 1) << 4];
1299 if ((x_cg > 0 || y_cg > 0))
1301 if (log2_trafo_size == 3) {
1302 scf_offset += (scan_idx == SCAN_DIAG) ? 9 : 15;
1307 if (log2_trafo_size == 3)
1314 for (n = n_end; n > 0; n--) {
1315 x_c = scan_x_off[n];
1316 y_c = scan_y_off[n];
1317 if (significant_coeff_flag_decode(s, x_c, y_c, scf_offset, ctx_idx_map_p)) {
1318 significant_coeff_flag_idx[nb_significant_coeff_flag] = n;
1319 nb_significant_coeff_flag++;
1320 implicit_non_zero_coeff = 0;
1323 if (implicit_non_zero_coeff == 0) {
1324 if (s->ps.sps->transform_skip_context_enabled_flag &&
1325 (transform_skip_flag || lc->cu.cu_transquant_bypass_flag)) {
1329 scf_offset = 16 + 27;
1338 scf_offset = 2 + scf_offset;
1341 if (significant_coeff_flag_decode_0(s, c_idx, scf_offset) == 1) {
1342 significant_coeff_flag_idx[nb_significant_coeff_flag] = 0;
1343 nb_significant_coeff_flag++;
1346 significant_coeff_flag_idx[nb_significant_coeff_flag] = 0;
1347 nb_significant_coeff_flag++;
1351 n_end = nb_significant_coeff_flag;
1355 int first_nz_pos_in_cg;
1356 int last_nz_pos_in_cg;
1357 int c_rice_param = 0;
1358 int first_greater1_coeff_idx = -1;
1359 uint8_t coeff_abs_level_greater1_flag[8];
1360 uint16_t coeff_sign_flag;
1366 // initialize first elem of coeff_bas_level_greater1_flag
1367 int ctx_set = (i > 0 && c_idx == 0) ? 2 : 0;
1369 if (s->ps.sps->persistent_rice_adaptation_enabled_flag) {
1370 if (!transform_skip_flag && !lc->cu.cu_transquant_bypass_flag)
1371 sb_type = 2 * (c_idx == 0 ? 1 : 0);
1373 sb_type = 2 * (c_idx == 0 ? 1 : 0) + 1;
1374 c_rice_param = lc->stat_coeff[sb_type] / 4;
1377 if (!(i == num_last_subset) && greater1_ctx == 0)
1380 last_nz_pos_in_cg = significant_coeff_flag_idx[0];
1382 for (m = 0; m < (n_end > 8 ? 8 : n_end); m++) {
1383 int inc = (ctx_set << 2) + greater1_ctx;
1384 coeff_abs_level_greater1_flag[m] =
1385 coeff_abs_level_greater1_flag_decode(s, c_idx, inc);
1386 if (coeff_abs_level_greater1_flag[m]) {
1388 if (first_greater1_coeff_idx == -1)
1389 first_greater1_coeff_idx = m;
1390 } else if (greater1_ctx > 0 && greater1_ctx < 3) {
1394 first_nz_pos_in_cg = significant_coeff_flag_idx[n_end - 1];
1396 if (lc->cu.cu_transquant_bypass_flag ||
1397 (lc->cu.pred_mode == MODE_INTRA &&
1398 s->ps.sps->implicit_rdpcm_enabled_flag && transform_skip_flag &&
1399 (pred_mode_intra == 10 || pred_mode_intra == 26 )) ||
1400 explicit_rdpcm_flag)
1403 sign_hidden = (last_nz_pos_in_cg - first_nz_pos_in_cg >= 4);
1405 if (first_greater1_coeff_idx != -1) {
1406 coeff_abs_level_greater1_flag[first_greater1_coeff_idx] += coeff_abs_level_greater2_flag_decode(s, c_idx, ctx_set);
1408 if (!s->ps.pps->sign_data_hiding_flag || !sign_hidden ) {
1409 coeff_sign_flag = coeff_sign_flag_decode(s, nb_significant_coeff_flag) << (16 - nb_significant_coeff_flag);
1411 coeff_sign_flag = coeff_sign_flag_decode(s, nb_significant_coeff_flag - 1) << (16 - (nb_significant_coeff_flag - 1));
1414 for (m = 0; m < n_end; m++) {
1415 n = significant_coeff_flag_idx[m];
1416 GET_COORD(offset, n);
1418 trans_coeff_level = 1 + coeff_abs_level_greater1_flag[m];
1419 if (trans_coeff_level == ((m == first_greater1_coeff_idx) ? 3 : 2)) {
1420 int last_coeff_abs_level_remaining = coeff_abs_level_remaining_decode(s, c_rice_param);
1422 trans_coeff_level += last_coeff_abs_level_remaining;
1423 if (trans_coeff_level > (3 << c_rice_param))
1424 c_rice_param = s->ps.sps->persistent_rice_adaptation_enabled_flag ? c_rice_param + 1 : FFMIN(c_rice_param + 1, 4);
1425 if (s->ps.sps->persistent_rice_adaptation_enabled_flag && !rice_init) {
1426 int c_rice_p_init = lc->stat_coeff[sb_type] / 4;
1427 if (last_coeff_abs_level_remaining >= (3 << c_rice_p_init))
1428 lc->stat_coeff[sb_type]++;
1429 else if (2 * last_coeff_abs_level_remaining < (1 << c_rice_p_init))
1430 if (lc->stat_coeff[sb_type] > 0)
1431 lc->stat_coeff[sb_type]--;
1436 int last_coeff_abs_level_remaining = coeff_abs_level_remaining_decode(s, c_rice_param);
1438 trans_coeff_level = 1 + last_coeff_abs_level_remaining;
1439 if (trans_coeff_level > (3 << c_rice_param))
1440 c_rice_param = s->ps.sps->persistent_rice_adaptation_enabled_flag ? c_rice_param + 1 : FFMIN(c_rice_param + 1, 4);
1441 if (s->ps.sps->persistent_rice_adaptation_enabled_flag && !rice_init) {
1442 int c_rice_p_init = lc->stat_coeff[sb_type] / 4;
1443 if (last_coeff_abs_level_remaining >= (3 << c_rice_p_init))
1444 lc->stat_coeff[sb_type]++;
1445 else if (2 * last_coeff_abs_level_remaining < (1 << c_rice_p_init))
1446 if (lc->stat_coeff[sb_type] > 0)
1447 lc->stat_coeff[sb_type]--;
1451 if (s->ps.pps->sign_data_hiding_flag && sign_hidden) {
1452 sum_abs += trans_coeff_level;
1453 if (n == first_nz_pos_in_cg && (sum_abs&1))
1454 trans_coeff_level = -trans_coeff_level;
1456 if (coeff_sign_flag >> 15)
1457 trans_coeff_level = -trans_coeff_level;
1458 coeff_sign_flag <<= 1;
1459 if(!lc->cu.cu_transquant_bypass_flag) {
1460 if (s->ps.sps->scaling_list_enable_flag && !(transform_skip_flag && log2_trafo_size > 2)) {
1461 if(y_c || x_c || log2_trafo_size < 4) {
1462 switch(log2_trafo_size) {
1463 case 3: pos = (y_c << 3) + x_c; break;
1464 case 4: pos = ((y_c >> 1) << 3) + (x_c >> 1); break;
1465 case 5: pos = ((y_c >> 2) << 3) + (x_c >> 2); break;
1466 default: pos = (y_c << 2) + x_c; break;
1468 scale_m = scale_matrix[pos];
1473 trans_coeff_level = (trans_coeff_level * (int64_t)scale * (int64_t)scale_m + add) >> shift;
1474 if(trans_coeff_level < 0) {
1475 if((~trans_coeff_level) & 0xFffffffffff8000)
1476 trans_coeff_level = -32768;
1478 if(trans_coeff_level & 0xffffffffffff8000)
1479 trans_coeff_level = 32767;
1482 coeffs[y_c * trafo_size + x_c] = trans_coeff_level;
1487 if (lc->cu.cu_transquant_bypass_flag) {
1488 if (explicit_rdpcm_flag || (s->ps.sps->implicit_rdpcm_enabled_flag &&
1489 (pred_mode_intra == 10 || pred_mode_intra == 26))) {
1490 int mode = s->ps.sps->implicit_rdpcm_enabled_flag ? (pred_mode_intra == 26) : explicit_rdpcm_dir_flag;
1492 s->hevcdsp.transform_rdpcm(coeffs, log2_trafo_size, mode);
1495 if (transform_skip_flag) {
1496 int rot = s->ps.sps->transform_skip_rotation_enabled_flag &&
1497 log2_trafo_size == 2 &&
1498 lc->cu.pred_mode == MODE_INTRA;
1500 for (i = 0; i < 8; i++)
1501 FFSWAP(int16_t, coeffs[i], coeffs[16 - i - 1]);
1504 s->hevcdsp.dequant(coeffs, log2_trafo_size);
1506 if (explicit_rdpcm_flag || (s->ps.sps->implicit_rdpcm_enabled_flag &&
1507 lc->cu.pred_mode == MODE_INTRA &&
1508 (pred_mode_intra == 10 || pred_mode_intra == 26))) {
1509 int mode = explicit_rdpcm_flag ? explicit_rdpcm_dir_flag : (pred_mode_intra == 26);
1511 s->hevcdsp.transform_rdpcm(coeffs, log2_trafo_size, mode);
1513 } else if (lc->cu.pred_mode == MODE_INTRA && c_idx == 0 && log2_trafo_size == 2) {
1514 s->hevcdsp.transform_4x4_luma(coeffs);
1516 int max_xy = FFMAX(last_significant_coeff_x, last_significant_coeff_y);
1518 s->hevcdsp.idct_dc[log2_trafo_size - 2](coeffs);
1520 int col_limit = last_significant_coeff_x + last_significant_coeff_y + 4;
1522 col_limit = FFMIN(4, col_limit);
1523 else if (max_xy < 8)
1524 col_limit = FFMIN(8, col_limit);
1525 else if (max_xy < 12)
1526 col_limit = FFMIN(24, col_limit);
1527 s->hevcdsp.idct[log2_trafo_size - 2](coeffs, col_limit);
1531 if (lc->tu.cross_pf) {
1532 int16_t *coeffs_y = (int16_t*)lc->edge_emu_buffer;
1534 for (i = 0; i < (trafo_size * trafo_size); i++) {
1535 coeffs[i] = coeffs[i] + ((lc->tu.res_scale_val * coeffs_y[i]) >> 3);
1538 s->hevcdsp.add_residual[log2_trafo_size-2](dst, coeffs, stride);
1541 void ff_hevc_hls_mvd_coding(HEVCContext *s, int x0, int y0, int log2_cb_size)
1543 HEVCLocalContext *lc = s->HEVClc;
1544 int x = abs_mvd_greater0_flag_decode(s);
1545 int y = abs_mvd_greater0_flag_decode(s);
1548 x += abs_mvd_greater1_flag_decode(s);
1550 y += abs_mvd_greater1_flag_decode(s);
1553 case 2: lc->pu.mvd.x = mvd_decode(s); break;
1554 case 1: lc->pu.mvd.x = mvd_sign_flag_decode(s); break;
1555 case 0: lc->pu.mvd.x = 0; break;
1559 case 2: lc->pu.mvd.y = mvd_decode(s); break;
1560 case 1: lc->pu.mvd.y = mvd_sign_flag_decode(s); break;
1561 case 0: lc->pu.mvd.y = 0; break;