1/* 2 * HEVC CABAC decoding 3 * 4 * Copyright (C) 2012 - 2013 Guillaume Martres 5 * Copyright (C) 2012 - 2013 Gildas Cocherel 6 * 7 * This file is part of FFmpeg. 8 * 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. 13 * 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. 18 * 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 22 */ 23 24#include "libavutil/attributes.h" 25#include "libavutil/common.h" 26 27#include "cabac_functions.h" 28#include "hevc_data.h" 29#include "hevc.h" 30#include "hevcdec.h" 31 32#define CABAC_MAX_BIN 31 33 34/** 35 * number of bin by SyntaxElement. 36 */ 37static const int8_t num_bins_in_se[] = { 38 1, // sao_merge_flag 39 1, // sao_type_idx 40 0, // sao_eo_class 41 0, // sao_band_position 42 0, // sao_offset_abs 43 0, // sao_offset_sign 44 0, // end_of_slice_flag 45 3, // split_coding_unit_flag 46 1, // cu_transquant_bypass_flag 47 3, // skip_flag 48 3, // cu_qp_delta 49 1, // pred_mode 50 4, // part_mode 51 0, // pcm_flag 52 1, // prev_intra_luma_pred_mode 53 0, // mpm_idx 54 0, // rem_intra_luma_pred_mode 55 2, // intra_chroma_pred_mode 56 1, // merge_flag 57 1, // merge_idx 58 5, // inter_pred_idc 59 2, // ref_idx_l0 60 2, // ref_idx_l1 61 2, // abs_mvd_greater0_flag 62 2, // abs_mvd_greater1_flag 63 0, // abs_mvd_minus2 64 0, // mvd_sign_flag 65 1, // mvp_lx_flag 66 1, // no_residual_data_flag 67 3, // split_transform_flag 68 2, // cbf_luma 69 5, // cbf_cb, cbf_cr 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 82 0, // coeff_sign_flag 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 87}; 88 89/** 90 * Offset to ctxIdx 0 in init_values and states, indexed by SyntaxElement. 91 */ 92static const int elem_offset[sizeof(num_bins_in_se)] = { 93 0, // sao_merge_flag 94 1, // sao_type_idx 95 2, // sao_eo_class 96 2, // sao_band_position 97 2, // sao_offset_abs 98 2, // sao_offset_sign 99 2, // end_of_slice_flag 100 2, // split_coding_unit_flag 101 5, // cu_transquant_bypass_flag 102 6, // skip_flag 103 9, // cu_qp_delta 104 12, // pred_mode 105 13, // part_mode 106 17, // pcm_flag 107 17, // prev_intra_luma_pred_mode 108 18, // mpm_idx 109 18, // rem_intra_luma_pred_mode 110 18, // intra_chroma_pred_mode 111 20, // merge_flag 112 21, // merge_idx 113 22, // inter_pred_idc 114 27, // ref_idx_l0 115 29, // ref_idx_l1 116 31, // abs_mvd_greater0_flag 117 33, // abs_mvd_greater1_flag 118 35, // abs_mvd_minus2 119 35, // mvd_sign_flag 120 35, // mvp_lx_flag 121 36, // no_residual_data_flag 122 37, // split_transform_flag 123 40, // cbf_luma 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 142}; 143 144#define CNU 154 145/** 146 * Indexed by init_type 147 */ 148static const uint8_t init_values[3][HEVC_CONTEXTS] = { 149 { // sao_merge_flag 150 153, 151 // sao_type_idx 152 200, 153 // split_coding_unit_flag 154 139, 141, 157, 155 // cu_transquant_bypass_flag 156 154, 157 // skip_flag 158 CNU, CNU, CNU, 159 // cu_qp_delta 160 154, 154, 154, 161 // pred_mode 162 CNU, 163 // part_mode 164 184, CNU, CNU, CNU, 165 // prev_intra_luma_pred_mode 166 184, 167 // intra_chroma_pred_mode 168 63, 139, 169 // merge_flag 170 CNU, 171 // merge_idx 172 CNU, 173 // inter_pred_idc 174 CNU, CNU, CNU, CNU, CNU, 175 // ref_idx_l0 176 CNU, CNU, 177 // ref_idx_l1 178 CNU, CNU, 179 // abs_mvd_greater1_flag 180 CNU, CNU, 181 // abs_mvd_greater1_flag 182 CNU, CNU, 183 // mvp_lx_flag 184 CNU, 185 // no_residual_data_flag 186 CNU, 187 // split_transform_flag 188 153, 138, 138, 189 // cbf_luma 190 111, 141, 191 // cbf_cb, cbf_cr 192 94, 138, 182, 154, 154, 193 // transform_skip_flag 194 139, 139, 195 // explicit_rdpcm_flag 196 139, 139, 197 // explicit_rdpcm_dir_flag 198 139, 139, 199 // last_significant_coeff_x_prefix 200 110, 110, 124, 125, 140, 153, 125, 127, 140, 109, 111, 143, 127, 111, 201 79, 108, 123, 63, 202 // last_significant_coeff_y_prefix 203 110, 110, 124, 125, 140, 153, 125, 127, 140, 109, 111, 143, 127, 111, 204 79, 108, 123, 63, 205 // significant_coeff_group_flag 206 91, 171, 134, 141, 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, 211 141, 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 220 154, 154, 221 // cu_chroma_qp_offset_flag 222 154, 223 // cu_chroma_qp_offset_idx 224 154, 225 }, 226 { // sao_merge_flag 227 153, 228 // sao_type_idx 229 185, 230 // split_coding_unit_flag 231 107, 139, 126, 232 // cu_transquant_bypass_flag 233 154, 234 // skip_flag 235 197, 185, 201, 236 // cu_qp_delta 237 154, 154, 154, 238 // pred_mode 239 149, 240 // part_mode 241 154, 139, 154, 154, 242 // prev_intra_luma_pred_mode 243 154, 244 // intra_chroma_pred_mode 245 152, 139, 246 // merge_flag 247 110, 248 // merge_idx 249 122, 250 // inter_pred_idc 251 95, 79, 63, 31, 31, 252 // ref_idx_l0 253 153, 153, 254 // ref_idx_l1 255 153, 153, 256 // abs_mvd_greater1_flag 257 140, 198, 258 // abs_mvd_greater1_flag 259 140, 198, 260 // mvp_lx_flag 261 168, 262 // no_residual_data_flag 263 79, 264 // split_transform_flag 265 124, 138, 94, 266 // cbf_luma 267 153, 111, 268 // cbf_cb, cbf_cr 269 149, 107, 167, 154, 154, 270 // transform_skip_flag 271 139, 139, 272 // explicit_rdpcm_flag 273 139, 139, 274 // explicit_rdpcm_dir_flag 275 139, 139, 276 // last_significant_coeff_x_prefix 277 125, 110, 94, 110, 95, 79, 125, 111, 110, 78, 110, 111, 111, 95, 278 94, 108, 123, 108, 279 // last_significant_coeff_y_prefix 280 125, 110, 94, 110, 95, 79, 125, 111, 110, 78, 110, 111, 111, 95, 281 94, 108, 123, 108, 282 // significant_coeff_group_flag 283 121, 140, 61, 154, 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, 288 140, 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 297 154, 154, 298 // cu_chroma_qp_offset_flag 299 154, 300 // cu_chroma_qp_offset_idx 301 154, 302 }, 303 { // sao_merge_flag 304 153, 305 // sao_type_idx 306 160, 307 // split_coding_unit_flag 308 107, 139, 126, 309 // cu_transquant_bypass_flag 310 154, 311 // skip_flag 312 197, 185, 201, 313 // cu_qp_delta 314 154, 154, 154, 315 // pred_mode 316 134, 317 // part_mode 318 154, 139, 154, 154, 319 // prev_intra_luma_pred_mode 320 183, 321 // intra_chroma_pred_mode 322 152, 139, 323 // merge_flag 324 154, 325 // merge_idx 326 137, 327 // inter_pred_idc 328 95, 79, 63, 31, 31, 329 // ref_idx_l0 330 153, 153, 331 // ref_idx_l1 332 153, 153, 333 // abs_mvd_greater1_flag 334 169, 198, 335 // abs_mvd_greater1_flag 336 169, 198, 337 // mvp_lx_flag 338 168, 339 // no_residual_data_flag 340 79, 341 // split_transform_flag 342 224, 167, 122, 343 // cbf_luma 344 153, 111, 345 // cbf_cb, cbf_cr 346 149, 92, 167, 154, 154, 347 // transform_skip_flag 348 139, 139, 349 // explicit_rdpcm_flag 350 139, 139, 351 // explicit_rdpcm_dir_flag 352 139, 139, 353 // last_significant_coeff_x_prefix 354 125, 110, 124, 110, 95, 94, 125, 111, 111, 79, 125, 126, 111, 111, 355 79, 108, 123, 93, 356 // last_significant_coeff_y_prefix 357 125, 110, 124, 110, 95, 94, 125, 111, 111, 79, 125, 126, 111, 111, 358 79, 108, 123, 93, 359 // significant_coeff_group_flag 360 121, 140, 61, 154, 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, 365 140, 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 374 154, 154, 375 // cu_chroma_qp_offset_flag 376 154, 377 // cu_chroma_qp_offset_idx 378 154, 379 }, 380}; 381 382static const uint8_t scan_1x1[1] = { 383 0, 384}; 385 386static const uint8_t horiz_scan2x2_x[4] = { 387 0, 1, 0, 1, 388}; 389 390static const uint8_t horiz_scan2x2_y[4] = { 391 0, 0, 1, 1 392}; 393 394static const uint8_t horiz_scan4x4_x[16] = { 395 0, 1, 2, 3, 396 0, 1, 2, 3, 397 0, 1, 2, 3, 398 0, 1, 2, 3, 399}; 400 401static const uint8_t horiz_scan4x4_y[16] = { 402 0, 0, 0, 0, 403 1, 1, 1, 1, 404 2, 2, 2, 2, 405 3, 3, 3, 3, 406}; 407 408static 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, }, 417}; 418 419static const uint8_t diag_scan2x2_x[4] = { 420 0, 0, 1, 1, 421}; 422 423static const uint8_t diag_scan2x2_y[4] = { 424 0, 1, 0, 1, 425}; 426 427static const uint8_t diag_scan2x2_inv[2][2] = { 428 { 0, 2, }, 429 { 1, 3, }, 430}; 431 432static const uint8_t diag_scan4x4_inv[4][4] = { 433 { 0, 2, 5, 9, }, 434 { 1, 4, 8, 12, }, 435 { 3, 7, 11, 14, }, 436 { 6, 10, 13, 15, }, 437}; 438 439static 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, }, 448}; 449 450void ff_hevc_save_states(HEVCContext *s, int ctb_addr_ts) 451{ 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); 459 } 460 } 461} 462 463static void load_states(HEVCContext *s, int thread) 464{ 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); 469 } 470} 471 472static int cabac_reinit(HEVCLocalContext *lc) 473{ 474 return skip_bytes(&lc->cc, 0) == NULL ? AVERROR_INVALIDDATA : 0; 475} 476 477static int cabac_init_decoder(HEVCContext *s) 478{ 479 GetBitContext *gb = &s->HEVClc->gb; 480 skip_bits(gb, 1); 481 align_get_bits(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); 485} 486 487static void cabac_init_state(HEVCContext *s) 488{ 489 int init_type = 2 - s->sh.slice_type; 490 int i; 491 492 if (s->sh.cabac_init_flag && s->sh.slice_type != HEVC_SLICE_I) 493 init_type ^= 3; 494 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; 500 501 pre ^= pre >> 31; 502 if (pre > 124) 503 pre = 124 + (pre & 1); 504 s->HEVClc->cabac_state[i] = pre; 505 } 506 507 for (i = 0; i < 4; i++) 508 s->HEVClc->stat_coeff[i] = 0; 509} 510 511int ff_hevc_cabac_init(HEVCContext *s, int ctb_addr_ts, int thread) 512{ 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); 515 if (ret < 0) 516 return ret; 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])) 520 cabac_init_state(s); 521 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) 526 cabac_init_state(s); 527 else if (s->sh.dependent_slice_segment_flag == 1) 528 load_states(s, thread); 529 } 530 } 531 } else { 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]) { 534 int ret; 535 if (s->threads_number == 1) 536 ret = cabac_reinit(s->HEVClc); 537 else { 538 ret = cabac_init_decoder(s); 539 } 540 if (ret < 0) 541 return ret; 542 cabac_init_state(s); 543 } 544 if (s->ps.pps->entropy_coding_sync_enabled_flag) { 545 if (ctb_addr_ts % s->ps.sps->ctb_width == 0) { 546 int ret; 547 get_cabac_terminate(&s->HEVClc->cc); 548 if (s->threads_number == 1) 549 ret = cabac_reinit(s->HEVClc); 550 else { 551 ret = cabac_init_decoder(s); 552 } 553 if (ret < 0) 554 return ret; 555 556 if (s->ps.sps->ctb_width == 1) 557 cabac_init_state(s); 558 else 559 load_states(s, thread); 560 } 561 } 562 } 563 return 0; 564} 565 566#define GET_CABAC(ctx) get_cabac(&s->HEVClc->cc, &s->HEVClc->cabac_state[ctx]) 567 568int ff_hevc_sao_merge_flag_decode(HEVCContext *s) 569{ 570 return GET_CABAC(elem_offset[SAO_MERGE_FLAG]); 571} 572 573int ff_hevc_sao_type_idx_decode(HEVCContext *s) 574{ 575 if (!GET_CABAC(elem_offset[SAO_TYPE_IDX])) 576 return 0; 577 578 if (!get_cabac_bypass(&s->HEVClc->cc)) 579 return SAO_BAND; 580 return SAO_EDGE; 581} 582 583int ff_hevc_sao_band_position_decode(HEVCContext *s) 584{ 585 int i; 586 int value = get_cabac_bypass(&s->HEVClc->cc); 587 588 for (i = 0; i < 4; i++) 589 value = (value << 1) | get_cabac_bypass(&s->HEVClc->cc); 590 return value; 591} 592 593int ff_hevc_sao_offset_abs_decode(HEVCContext *s) 594{ 595 int i = 0; 596 int length = (1 << (FFMIN(s->ps.sps->bit_depth, 10) - 5)) - 1; 597 598 while (i < length && get_cabac_bypass(&s->HEVClc->cc)) 599 i++; 600 return i; 601} 602 603int ff_hevc_sao_offset_sign_decode(HEVCContext *s) 604{ 605 return get_cabac_bypass(&s->HEVClc->cc); 606} 607 608int ff_hevc_sao_eo_class_decode(HEVCContext *s) 609{ 610 int ret = get_cabac_bypass(&s->HEVClc->cc) << 1; 611 ret |= get_cabac_bypass(&s->HEVClc->cc); 612 return ret; 613} 614 615int ff_hevc_end_of_slice_flag_decode(HEVCContext *s) 616{ 617 return get_cabac_terminate(&s->HEVClc->cc); 618} 619 620int ff_hevc_cu_transquant_bypass_flag_decode(HEVCContext *s) 621{ 622 return GET_CABAC(elem_offset[CU_TRANSQUANT_BYPASS_FLAG]); 623} 624 625int ff_hevc_skip_flag_decode(HEVCContext *s, int x0, int y0, int x_cb, int y_cb) 626{ 627 int min_cb_width = s->ps.sps->min_cb_width; 628 int inc = 0; 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); 631 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); 636 637 return GET_CABAC(elem_offset[SKIP_FLAG] + inc); 638} 639 640int ff_hevc_cu_qp_delta_abs(HEVCContext *s) 641{ 642 int prefix_val = 0; 643 int suffix_val = 0; 644 int inc = 0; 645 646 while (prefix_val < 5 && GET_CABAC(elem_offset[CU_QP_DELTA] + inc)) { 647 prefix_val++; 648 inc = 1; 649 } 650 if (prefix_val >= 5) { 651 int k = 0; 652 while (k < 7 && get_cabac_bypass(&s->HEVClc->cc)) { 653 suffix_val += 1 << k; 654 k++; 655 } 656 if (k == 7) { 657 av_log(s->avctx, AV_LOG_ERROR, "CABAC_MAX_BIN : %d\n", k); 658 return AVERROR_INVALIDDATA; 659 } 660 661 while (k--) 662 suffix_val += get_cabac_bypass(&s->HEVClc->cc) << k; 663 } 664 return prefix_val + suffix_val; 665} 666 667int ff_hevc_cu_qp_delta_sign_flag(HEVCContext *s) 668{ 669 return get_cabac_bypass(&s->HEVClc->cc); 670} 671 672int ff_hevc_cu_chroma_qp_offset_flag(HEVCContext *s) 673{ 674 return GET_CABAC(elem_offset[CU_CHROMA_QP_OFFSET_FLAG]); 675} 676 677int ff_hevc_cu_chroma_qp_offset_idx(HEVCContext *s) 678{ 679 int c_max= FFMAX(5, s->ps.pps->chroma_qp_offset_list_len_minus1); 680 int i = 0; 681 682 while (i < c_max && GET_CABAC(elem_offset[CU_CHROMA_QP_OFFSET_IDX])) 683 i++; 684 685 return i; 686} 687 688int ff_hevc_pred_mode_decode(HEVCContext *s) 689{ 690 return GET_CABAC(elem_offset[PRED_MODE_FLAG]); 691} 692 693int ff_hevc_split_coding_unit_flag_decode(HEVCContext *s, int ct_depth, int x0, int y0) 694{ 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; 700 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]; 705 706 inc += (depth_left > ct_depth); 707 inc += (depth_top > ct_depth); 708 709 return GET_CABAC(elem_offset[SPLIT_CODING_UNIT_FLAG] + inc); 710} 711 712int ff_hevc_part_mode_decode(HEVCContext *s, int log2_cb_size) 713{ 714 if (GET_CABAC(elem_offset[PART_MODE])) // 1 715 return PART_2Nx2N; 716 if (log2_cb_size == s->ps.sps->log2_min_cb_size) { 717 if (s->HEVClc->cu.pred_mode == MODE_INTRA) // 0 718 return PART_NxN; 719 if (GET_CABAC(elem_offset[PART_MODE] + 1)) // 01 720 return PART_2NxN; 721 if (log2_cb_size == 3) // 00 722 return PART_Nx2N; 723 if (GET_CABAC(elem_offset[PART_MODE] + 2)) // 001 724 return PART_Nx2N; 725 return PART_NxN; // 000 726 } 727 728 if (!s->ps.sps->amp_enabled_flag) { 729 if (GET_CABAC(elem_offset[PART_MODE] + 1)) // 01 730 return PART_2NxN; 731 return PART_Nx2N; 732 } 733 734 if (GET_CABAC(elem_offset[PART_MODE] + 1)) { // 01X, 01XX 735 if (GET_CABAC(elem_offset[PART_MODE] + 3)) // 011 736 return PART_2NxN; 737 if (get_cabac_bypass(&s->HEVClc->cc)) // 0101 738 return PART_2NxnD; 739 return PART_2NxnU; // 0100 740 } 741 742 if (GET_CABAC(elem_offset[PART_MODE] + 3)) // 001 743 return PART_Nx2N; 744 if (get_cabac_bypass(&s->HEVClc->cc)) // 0001 745 return PART_nRx2N; 746 return PART_nLx2N; // 0000 747} 748 749int ff_hevc_pcm_flag_decode(HEVCContext *s) 750{ 751 return get_cabac_terminate(&s->HEVClc->cc); 752} 753 754int ff_hevc_prev_intra_luma_pred_flag_decode(HEVCContext *s) 755{ 756 return GET_CABAC(elem_offset[PREV_INTRA_LUMA_PRED_FLAG]); 757} 758 759int ff_hevc_mpm_idx_decode(HEVCContext *s) 760{ 761 int i = 0; 762 while (i < 2 && get_cabac_bypass(&s->HEVClc->cc)) 763 i++; 764 return i; 765} 766 767int ff_hevc_rem_intra_luma_pred_mode_decode(HEVCContext *s) 768{ 769 int i; 770 int value = get_cabac_bypass(&s->HEVClc->cc); 771 772 for (i = 0; i < 4; i++) 773 value = (value << 1) | get_cabac_bypass(&s->HEVClc->cc); 774 return value; 775} 776 777int ff_hevc_intra_chroma_pred_mode_decode(HEVCContext *s) 778{ 779 int ret; 780 if (!GET_CABAC(elem_offset[INTRA_CHROMA_PRED_MODE])) 781 return 4; 782 783 ret = get_cabac_bypass(&s->HEVClc->cc) << 1; 784 ret |= get_cabac_bypass(&s->HEVClc->cc); 785 return ret; 786} 787 788int ff_hevc_merge_idx_decode(HEVCContext *s) 789{ 790 int i = GET_CABAC(elem_offset[MERGE_IDX]); 791 792 if (i != 0) { 793 while (i < s->sh.max_num_merge_cand-1 && get_cabac_bypass(&s->HEVClc->cc)) 794 i++; 795 } 796 return i; 797} 798 799int ff_hevc_merge_flag_decode(HEVCContext *s) 800{ 801 return GET_CABAC(elem_offset[MERGE_FLAG]); 802} 803 804int ff_hevc_inter_pred_idc_decode(HEVCContext *s, int nPbW, int nPbH) 805{ 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)) 809 return PRED_BI; 810 811 return GET_CABAC(elem_offset[INTER_PRED_IDC] + 4); 812} 813 814int ff_hevc_ref_idx_lx_decode(HEVCContext *s, int num_ref_idx_lx) 815{ 816 int i = 0; 817 int max = num_ref_idx_lx - 1; 818 int max_ctx = FFMIN(max, 2); 819 820 while (i < max_ctx && GET_CABAC(elem_offset[REF_IDX_L0] + i)) 821 i++; 822 if (i == 2) { 823 while (i < max && get_cabac_bypass(&s->HEVClc->cc)) 824 i++; 825 } 826 827 return i; 828} 829 830int ff_hevc_mvp_lx_flag_decode(HEVCContext *s) 831{ 832 return GET_CABAC(elem_offset[MVP_LX_FLAG]); 833} 834 835int ff_hevc_no_residual_syntax_flag_decode(HEVCContext *s) 836{ 837 return GET_CABAC(elem_offset[NO_RESIDUAL_DATA_FLAG]); 838} 839 840static av_always_inline int abs_mvd_greater0_flag_decode(HEVCContext *s) 841{ 842 return GET_CABAC(elem_offset[ABS_MVD_GREATER0_FLAG]); 843} 844 845static av_always_inline int abs_mvd_greater1_flag_decode(HEVCContext *s) 846{ 847 return GET_CABAC(elem_offset[ABS_MVD_GREATER1_FLAG] + 1); 848} 849 850static av_always_inline int mvd_decode(HEVCContext *s) 851{ 852 int ret = 2; 853 int k = 1; 854 855 while (k < CABAC_MAX_BIN && get_cabac_bypass(&s->HEVClc->cc)) { 856 ret += 1U << k; 857 k++; 858 } 859 if (k == CABAC_MAX_BIN) { 860 av_log(s->avctx, AV_LOG_ERROR, "CABAC_MAX_BIN : %d\n", k); 861 return 0; 862 } 863 while (k--) 864 ret += get_cabac_bypass(&s->HEVClc->cc) << k; 865 return get_cabac_bypass_sign(&s->HEVClc->cc, -ret); 866} 867 868static av_always_inline int mvd_sign_flag_decode(HEVCContext *s) 869{ 870 return get_cabac_bypass_sign(&s->HEVClc->cc, -1); 871} 872 873int ff_hevc_split_transform_flag_decode(HEVCContext *s, int log2_trafo_size) 874{ 875 return GET_CABAC(elem_offset[SPLIT_TRANSFORM_FLAG] + 5 - log2_trafo_size); 876} 877 878int ff_hevc_cbf_cb_cr_decode(HEVCContext *s, int trafo_depth) 879{ 880 return GET_CABAC(elem_offset[CBF_CB_CR] + trafo_depth); 881} 882 883int ff_hevc_cbf_luma_decode(HEVCContext *s, int trafo_depth) 884{ 885 return GET_CABAC(elem_offset[CBF_LUMA] + !trafo_depth); 886} 887 888static int hevc_transform_skip_flag_decode(HEVCContext *s, int c_idx) 889{ 890 return GET_CABAC(elem_offset[TRANSFORM_SKIP_FLAG] + !!c_idx); 891} 892 893static int explicit_rdpcm_flag_decode(HEVCContext *s, int c_idx) 894{ 895 return GET_CABAC(elem_offset[EXPLICIT_RDPCM_FLAG] + !!c_idx); 896} 897 898static int explicit_rdpcm_dir_flag_decode(HEVCContext *s, int c_idx) 899{ 900 return GET_CABAC(elem_offset[EXPLICIT_RDPCM_DIR_FLAG] + !!c_idx); 901} 902 903int ff_hevc_log2_res_scale_abs(HEVCContext *s, int idx) { 904 int i =0; 905 906 while (i < 4 && GET_CABAC(elem_offset[LOG2_RES_SCALE_ABS] + 4 * idx + i)) 907 i++; 908 909 return i; 910} 911 912int ff_hevc_res_scale_sign_flag(HEVCContext *s, int idx) { 913 return GET_CABAC(elem_offset[RES_SCALE_SIGN_FLAG] + idx); 914} 915 916static 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) 918{ 919 int i = 0; 920 int max = (log2_size << 1) - 1; 921 int ctx_offset, ctx_shift; 922 923 if (!c_idx) { 924 ctx_offset = 3 * (log2_size - 2) + ((log2_size - 1) >> 2); 925 ctx_shift = (log2_size + 1) >> 2; 926 } else { 927 ctx_offset = 15; 928 ctx_shift = log2_size - 2; 929 } 930 while (i < max && 931 GET_CABAC(elem_offset[LAST_SIGNIFICANT_COEFF_X_PREFIX] + (i >> ctx_shift) + ctx_offset)) 932 i++; 933 *last_scx_prefix = i; 934 935 i = 0; 936 while (i < max && 937 GET_CABAC(elem_offset[LAST_SIGNIFICANT_COEFF_Y_PREFIX] + (i >> ctx_shift) + ctx_offset)) 938 i++; 939 *last_scy_prefix = i; 940} 941 942static av_always_inline int last_significant_coeff_suffix_decode(HEVCContext *s, 943 int last_significant_coeff_prefix) 944{ 945 int i; 946 int length = (last_significant_coeff_prefix >> 1) - 1; 947 int value = get_cabac_bypass(&s->HEVClc->cc); 948 949 for (i = 1; i < length; i++) 950 value = (value << 1) | get_cabac_bypass(&s->HEVClc->cc); 951 return value; 952} 953 954static av_always_inline int significant_coeff_group_flag_decode(HEVCContext *s, int c_idx, int ctx_cg) 955{ 956 int inc; 957 958 inc = FFMIN(ctx_cg, 1) + (c_idx>0 ? 2 : 0); 959 960 return GET_CABAC(elem_offset[SIGNIFICANT_COEFF_GROUP_FLAG] + inc); 961} 962static 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) 964{ 965 int inc = ctx_idx_map[(y_c << 2) + x_c] + offset; 966 return GET_CABAC(elem_offset[SIGNIFICANT_COEFF_FLAG] + inc); 967} 968 969static av_always_inline int significant_coeff_flag_decode_0(HEVCContext *s, int c_idx, int offset) 970{ 971 return GET_CABAC(elem_offset[SIGNIFICANT_COEFF_FLAG] + offset); 972} 973 974static av_always_inline int coeff_abs_level_greater1_flag_decode(HEVCContext *s, int c_idx, int inc) 975{ 976 977 if (c_idx > 0) 978 inc += 16; 979 980 return GET_CABAC(elem_offset[COEFF_ABS_LEVEL_GREATER1_FLAG] + inc); 981} 982 983static av_always_inline int coeff_abs_level_greater2_flag_decode(HEVCContext *s, int c_idx, int inc) 984{ 985 if (c_idx > 0) 986 inc += 4; 987 988 return GET_CABAC(elem_offset[COEFF_ABS_LEVEL_GREATER2_FLAG] + inc); 989} 990 991static av_always_inline int coeff_abs_level_remaining_decode(HEVCContext *s, int rc_rice_param) 992{ 993 int prefix = 0; 994 int suffix = 0; 995 int last_coeff_abs_level_remaining; 996 int i; 997 998 while (prefix < CABAC_MAX_BIN && get_cabac_bypass(&s->HEVClc->cc)) 999 prefix++; 1000 1001 if (prefix < 3) { 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; 1005 } else { 1006 int prefix_minus3 = prefix - 3; 1007 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); 1010 return 0; 1011 } 1012 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; 1017 } 1018 return last_coeff_abs_level_remaining; 1019} 1020 1021static av_always_inline int coeff_sign_flag_decode(HEVCContext *s, uint8_t nb) 1022{ 1023 int i; 1024 int ret = 0; 1025 1026 for (i = 0; i < nb; i++) 1027 ret = (ret << 1) | get_cabac_bypass(&s->HEVClc->cc); 1028 return ret; 1029} 1030 1031void ff_hevc_hls_residual_coding(HEVCContext *s, int x0, int y0, 1032 int log2_trafo_size, enum ScanType scan_idx, 1033 int c_idx) 1034{ 1035#define GET_COORD(offset, n) \ 1036 do { \ 1037 x_c = (x_cg << 2) + scan_x_off[n]; \ 1038 y_c = (y_cg << 2) + scan_y_off[n]; \ 1039 } while (0) 1040 HEVCLocalContext *lc = s->HEVClc; 1041 int transform_skip_flag = 0; 1042 1043 int last_significant_coeff_x, last_significant_coeff_y; 1044 int last_scan_pos; 1045 int n_end; 1046 int num_coeff = 0; 1047 int greater1_ctx = 1; 1048 1049 int num_last_subset; 1050 int x_cg_last_sig, y_cg_last_sig; 1051 1052 const uint8_t *scan_x_cg, *scan_y_cg, *scan_x_off, *scan_y_off; 1053 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; 1063 1064 int trafo_size = 1 << log2_trafo_size; 1065 int i; 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; 1069 uint8_t dc_scale; 1070 int pred_mode_intra = (c_idx == 0) ? lc->tu.intra_pred_mode : 1071 lc->tu.intra_pred_mode_c; 1072 1073 memset(coeffs, 0, trafo_size * trafo_size * sizeof(int16_t)); 1074 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 1083 }; 1084 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 1090 }; 1091 int qp_y = lc->qp_y; 1092 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); 1096 } 1097 1098 if (c_idx == 0) { 1099 qp = qp_y + s->ps.sps->qp_bd_offset; 1100 } else { 1101 int qp_i, offset; 1102 1103 if (c_idx == 1) 1104 offset = s->ps.pps->cb_qp_offset + s->sh.slice_cb_qp_offset + 1105 lc->tu.cu_qp_offset_cb; 1106 else 1107 offset = s->ps.pps->cr_qp_offset + s->sh.slice_cr_qp_offset + 1108 lc->tu.cu_qp_offset_cr; 1109 1110 qp_i = av_clip(qp_y + offset, - s->ps.sps->qp_bd_offset, 57); 1111 if (s->ps.sps->chroma_format_idc == 1) { 1112 if (qp_i < 30) 1113 qp = qp_i; 1114 else if (qp_i > 43) 1115 qp = qp_i - 6; 1116 else 1117 qp = qp_c[qp_i - 30]; 1118 } else { 1119 if (qp_i > 51) 1120 qp = 51; 1121 else 1122 qp = qp_i; 1123 } 1124 1125 qp += s->ps.sps->qp_bd_offset; 1126 } 1127 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. 1132 dc_scale = 16; 1133 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; 1138 1139 matrix_id = 3 * matrix_id + c_idx; 1140 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]; 1144 } 1145 } else { 1146 shift = 0; 1147 add = 0; 1148 scale = 0; 1149 dc_scale = 0; 1150 } 1151 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); 1157 } 1158 } 1159 1160 last_significant_coeff_xy_prefix_decode(s, c_idx, log2_trafo_size, 1161 &last_significant_coeff_x, &last_significant_coeff_y); 1162 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)) + 1167 suffix; 1168 } 1169 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)) + 1174 suffix; 1175 } 1176 1177 if (scan_idx == SCAN_VERT) 1178 FFSWAP(int, last_significant_coeff_x, last_significant_coeff_y); 1179 1180 x_cg_last_sig = last_significant_coeff_x >> 2; 1181 y_cg_last_sig = last_significant_coeff_y >> 2; 1182 1183 switch (scan_idx) { 1184 case SCAN_DIAG: { 1185 int last_x_c = last_significant_coeff_x & 3; 1186 int last_y_c = last_significant_coeff_y & 3; 1187 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; 1206 } 1207 break; 1208 } 1209 case SCAN_HORIZ: 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]; 1215 break; 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]; 1222 break; 1223 } 1224 num_coeff++; 1225 num_last_subset = (num_coeff - 1) >> 4; 1226 1227 for (i = num_last_subset; i >= 0; i--) { 1228 int n, m; 1229 int x_cg, y_cg, x_c, y_c, pos; 1230 int implicit_non_zero_coeff = 0; 1231 int64_t trans_coeff_level; 1232 int prev_sig = 0; 1233 int offset = i << 4; 1234 int rice_init = 0; 1235 1236 uint8_t significant_coeff_flag_idx[16]; 1237 uint8_t nb_significant_coeff_flag = 0; 1238 1239 x_cg = scan_x_cg[i]; 1240 y_cg = scan_y_cg[i]; 1241 1242 if ((i < num_last_subset) && (i > 0)) { 1243 int ctx_cg = 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]; 1248 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; 1252 } else { 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)); 1256 } 1257 1258 last_scan_pos = num_coeff - offset - 1; 1259 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; 1264 } else { 1265 n_end = 15; 1266 } 1267 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); 1272 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 1280 }; 1281 const uint8_t *ctx_idx_map_p; 1282 int scf_offset = 0; 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 = &ctx_idx_map[4 * 16]; 1286 if (c_idx == 0) { 1287 scf_offset = 40; 1288 } else { 1289 scf_offset = 14 + 27; 1290 } 1291 } else { 1292 if (c_idx != 0) 1293 scf_offset = 27; 1294 if (log2_trafo_size == 2) { 1295 ctx_idx_map_p = &ctx_idx_map[0]; 1296 } else { 1297 ctx_idx_map_p = &ctx_idx_map[(prev_sig + 1) << 4]; 1298 if (c_idx == 0) { 1299 if ((x_cg > 0 || y_cg > 0)) 1300 scf_offset += 3; 1301 if (log2_trafo_size == 3) { 1302 scf_offset += (scan_idx == SCAN_DIAG) ? 9 : 15; 1303 } else { 1304 scf_offset += 21; 1305 } 1306 } else { 1307 if (log2_trafo_size == 3) 1308 scf_offset += 9; 1309 else 1310 scf_offset += 12; 1311 } 1312 } 1313 } 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; 1321 } 1322 } 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)) { 1326 if (c_idx == 0) { 1327 scf_offset = 42; 1328 } else { 1329 scf_offset = 16 + 27; 1330 } 1331 } else { 1332 if (i == 0) { 1333 if (c_idx == 0) 1334 scf_offset = 0; 1335 else 1336 scf_offset = 27; 1337 } else { 1338 scf_offset = 2 + scf_offset; 1339 } 1340 } 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++; 1344 } 1345 } else { 1346 significant_coeff_flag_idx[nb_significant_coeff_flag] = 0; 1347 nb_significant_coeff_flag++; 1348 } 1349 } 1350 1351 n_end = nb_significant_coeff_flag; 1352 1353 1354 if (n_end) { 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; 1361 int sum_abs = 0; 1362 int sign_hidden; 1363 int sb_type; 1364 1365 1366 // initialize first elem of coeff_bas_level_greater1_flag 1367 int ctx_set = (i > 0 && c_idx == 0) ? 2 : 0; 1368 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); 1372 else 1373 sb_type = 2 * (c_idx == 0 ? 1 : 0) + 1; 1374 c_rice_param = lc->stat_coeff[sb_type] / 4; 1375 } 1376 1377 if (!(i == num_last_subset) && greater1_ctx == 0) 1378 ctx_set++; 1379 greater1_ctx = 1; 1380 last_nz_pos_in_cg = significant_coeff_flag_idx[0]; 1381 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]) { 1387 greater1_ctx = 0; 1388 if (first_greater1_coeff_idx == -1) 1389 first_greater1_coeff_idx = m; 1390 } else if (greater1_ctx > 0 && greater1_ctx < 3) { 1391 greater1_ctx++; 1392 } 1393 } 1394 first_nz_pos_in_cg = significant_coeff_flag_idx[n_end - 1]; 1395 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) 1401 sign_hidden = 0; 1402 else 1403 sign_hidden = (last_nz_pos_in_cg - first_nz_pos_in_cg >= 4); 1404 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); 1407 } 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); 1410 } else { 1411 coeff_sign_flag = coeff_sign_flag_decode(s, nb_significant_coeff_flag - 1) << (16 - (nb_significant_coeff_flag - 1)); 1412 } 1413 1414 for (m = 0; m < n_end; m++) { 1415 n = significant_coeff_flag_idx[m]; 1416 GET_COORD(offset, n); 1417 if (m < 8) { 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); 1421 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]--; 1432 rice_init = 1; 1433 } 1434 } 1435 } else { 1436 int last_coeff_abs_level_remaining = coeff_abs_level_remaining_decode(s, c_rice_param); 1437 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]--; 1448 rice_init = 1; 1449 } 1450 } 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; 1455 } 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; 1467 } 1468 scale_m = scale_matrix[pos]; 1469 } else { 1470 scale_m = dc_scale; 1471 } 1472 } 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; 1477 } else { 1478 if(trans_coeff_level & 0xffffffffffff8000) 1479 trans_coeff_level = 32767; 1480 } 1481 } 1482 coeffs[y_c * trafo_size + x_c] = trans_coeff_level; 1483 } 1484 } 1485 } 1486 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; 1491 1492 s->hevcdsp.transform_rdpcm(coeffs, log2_trafo_size, mode); 1493 } 1494 } else { 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; 1499 if (rot) { 1500 for (i = 0; i < 8; i++) 1501 FFSWAP(int16_t, coeffs[i], coeffs[16 - i - 1]); 1502 } 1503 1504 s->hevcdsp.dequant(coeffs, log2_trafo_size); 1505 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); 1510 1511 s->hevcdsp.transform_rdpcm(coeffs, log2_trafo_size, mode); 1512 } 1513 } else if (lc->cu.pred_mode == MODE_INTRA && c_idx == 0 && log2_trafo_size == 2) { 1514 s->hevcdsp.transform_4x4_luma(coeffs); 1515 } else { 1516 int max_xy = FFMAX(last_significant_coeff_x, last_significant_coeff_y); 1517 if (max_xy == 0) 1518 s->hevcdsp.idct_dc[log2_trafo_size - 2](coeffs); 1519 else { 1520 int col_limit = last_significant_coeff_x + last_significant_coeff_y + 4; 1521 if (max_xy < 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); 1528 } 1529 } 1530 } 1531 if (lc->tu.cross_pf) { 1532 int16_t *coeffs_y = (int16_t*)lc->edge_emu_buffer; 1533 1534 for (i = 0; i < (trafo_size * trafo_size); i++) { 1535 coeffs[i] = coeffs[i] + ((lc->tu.res_scale_val * coeffs_y[i]) >> 3); 1536 } 1537 } 1538 s->hevcdsp.add_residual[log2_trafo_size-2](dst, coeffs, stride); 1539} 1540 1541void ff_hevc_hls_mvd_coding(HEVCContext *s, int x0, int y0, int log2_cb_size) 1542{ 1543 HEVCLocalContext *lc = s->HEVClc; 1544 int x = abs_mvd_greater0_flag_decode(s); 1545 int y = abs_mvd_greater0_flag_decode(s); 1546 1547 if (x) 1548 x += abs_mvd_greater1_flag_decode(s); 1549 if (y) 1550 y += abs_mvd_greater1_flag_decode(s); 1551 1552 switch (x) { 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; 1556 } 1557 1558 switch (y) { 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; 1562 } 1563} 1564 1565