1 /****************************************************************************** 2 * 3 * Copyright (C) 2012 Ittiam Systems Pvt Ltd, Bangalore 4 * 5 * Licensed under the Apache License, Version 2.0 (the "License"); 6 * you may not use this file except in compliance with the License. 7 * You may obtain a copy of the License at: 8 * 9 * http://www.apache.org/licenses/LICENSE-2.0 10 * 11 * Unless required by applicable law or agreed to in writing, software 12 * distributed under the License is distributed on an "AS IS" BASIS, 13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14 * See the License for the specific language governing permissions and 15 * limitations under the License. 16 * 17 ******************************************************************************/ 18 /** 19 ******************************************************************************* 20 * @file 21 * ihevcd_iquant_itrans_recon_ctb.c 22 * 23 * @brief 24 * Contains functions for inverse quantization, inverse transform and recon 25 * 26 * @author 27 * Ittiam 28 * 29 * @par List of Functions: 30 * - ihevcd_iquant_itrans_recon_ctb() 31 * 32 * @remarks 33 * None 34 * 35 ******************************************************************************* 36 */ 37 /*****************************************************************************/ 38 /* File Includes */ 39 /*****************************************************************************/ 40 #include <stdio.h> 41 #include <stddef.h> 42 #include <stdlib.h> 43 #include <string.h> 44 45 #include "ihevc_typedefs.h" 46 #include "iv.h" 47 #include "ivd.h" 48 #include "ihevcd_cxa.h" 49 50 #include "ihevc_defs.h" 51 #include "ihevc_debug.h" 52 #include "ihevc_structs.h" 53 #include "ihevc_cabac_tables.h" 54 #include "ihevc_macros.h" 55 #include "ihevc_platform_macros.h" 56 57 #include "ihevcd_defs.h" 58 #include "ihevcd_function_selector.h" 59 #include "ihevcd_structs.h" 60 #include "ihevcd_error.h" 61 #include "ihevcd_bitstream.h" 62 #include "ihevc_common_tables.h" 63 64 /* Intra pred includes */ 65 #include "ihevc_intra_pred.h" 66 67 /* Inverse transform common module includes */ 68 #include "ihevc_trans_tables.h" 69 #include "ihevc_trans_macros.h" 70 #include "ihevc_itrans_recon.h" 71 #include "ihevc_recon.h" 72 #include "ihevc_chroma_itrans_recon.h" 73 #include "ihevc_chroma_recon.h" 74 75 /* Decoder includes */ 76 #include "ihevcd_common_tables.h" 77 #include "ihevcd_iquant_itrans_recon_ctb.h" 78 #include "ihevcd_debug.h" 79 #include "ihevcd_profile.h" 80 #include "ihevcd_statistics.h" 81 #include "ihevcd_itrans_recon_dc.h" 82 83 static const UWORD32 gau4_ihevcd_4_bit_reverse[] = { 0, 8, 4, 12, 2, 10, 6, 14, 1, 9, 5, 13, 3, 11, 7, 15 }; 84 85 86 /* Globals */ 87 static const WORD32 g_i4_ip_funcs[MAX_NUM_IP_MODES] = 88 { IP_FUNC_MODE_0, /* Mode 0 */ 89 IP_FUNC_MODE_1, /* Mode 1 */ 90 IP_FUNC_MODE_2, /* Mode 2 */ 91 IP_FUNC_MODE_3TO9, /* Mode 3 */ 92 IP_FUNC_MODE_3TO9, /* Mode 4 */ 93 IP_FUNC_MODE_3TO9, /* Mode 5 */ 94 IP_FUNC_MODE_3TO9, /* Mode 6 */ 95 IP_FUNC_MODE_3TO9, /* Mode 7 */ 96 IP_FUNC_MODE_3TO9, /* Mode 8 */ 97 IP_FUNC_MODE_3TO9, /* Mode 9 */ 98 IP_FUNC_MODE_10, /* Mode 10 */ 99 IP_FUNC_MODE_11TO17, /* Mode 11 */ 100 IP_FUNC_MODE_11TO17, /* Mode 12 */ 101 IP_FUNC_MODE_11TO17, /* Mode 13 */ 102 IP_FUNC_MODE_11TO17, /* Mode 14 */ 103 IP_FUNC_MODE_11TO17, /* Mode 15 */ 104 IP_FUNC_MODE_11TO17, /* Mode 16 */ 105 IP_FUNC_MODE_11TO17, /* Mode 17 */ 106 IP_FUNC_MODE_18_34, /* Mode 18 */ 107 IP_FUNC_MODE_19TO25, /* Mode 19 */ 108 IP_FUNC_MODE_19TO25, /* Mode 20 */ 109 IP_FUNC_MODE_19TO25, /* Mode 21 */ 110 IP_FUNC_MODE_19TO25, /* Mode 22 */ 111 IP_FUNC_MODE_19TO25, /* Mode 23 */ 112 IP_FUNC_MODE_19TO25, /* Mode 24 */ 113 IP_FUNC_MODE_19TO25, /* Mode 25 */ 114 IP_FUNC_MODE_26, /* Mode 26 */ 115 IP_FUNC_MODE_27TO33, /* Mode 27 */ 116 IP_FUNC_MODE_27TO33, /* Mode 26 */ 117 IP_FUNC_MODE_27TO33, /* Mode 29 */ 118 IP_FUNC_MODE_27TO33, /* Mode 30 */ 119 IP_FUNC_MODE_27TO33, /* Mode 31 */ 120 IP_FUNC_MODE_27TO33, /* Mode 32 */ 121 IP_FUNC_MODE_27TO33, /* Mode 33 */ 122 IP_FUNC_MODE_18_34, /* Mode 34 */ 123 }; 124 125 126 const WORD16 *g_ai2_ihevc_trans_tables[] = 127 { &g_ai2_ihevc_trans_dst_4[0][0], 128 &g_ai2_ihevc_trans_4[0][0], 129 &g_ai2_ihevc_trans_8[0][0], 130 &g_ai2_ihevc_trans_16[0][0], 131 &g_ai2_ihevc_trans_32[0][0] 132 }; 133 134 135 /*****************************************************************************/ 136 /* Function Prototypes */ 137 /*****************************************************************************/ 138 /* Returns number of ai2_level read from ps_sblk_coeff */ 139 UWORD8* ihevcd_unpack_coeffs(WORD16 *pi2_tu_coeff, 140 WORD32 log2_trans_size, 141 UWORD8 *pu1_tu_coeff_data, 142 WORD16 *pi2_dequant_matrix, 143 WORD32 qp_rem, 144 WORD32 qp_div, 145 TRANSFORM_TYPE e_trans_type, 146 WORD32 trans_quant_bypass, 147 UWORD32 *pu4_zero_cols, 148 UWORD32 *pu4_zero_rows, 149 UWORD32 *pu4_coeff_type, 150 WORD16 *pi2_coeff_value) 151 { 152 /* Generating coeffs from coeff-map */ 153 WORD32 i; 154 WORD16 *pi2_sblk_ptr; 155 WORD32 subblk_pos_x, subblk_pos_y; 156 WORD32 sblk_scan_idx, coeff_raster_idx; 157 WORD32 sblk_non_zero_coeff_idx; 158 tu_sblk_coeff_data_t *ps_tu_sblk_coeff_data; 159 UWORD8 u1_num_coded_sblks, u1_scan_type; 160 UWORD8 *pu1_new_tu_coeff_data; 161 WORD32 trans_size; 162 WORD32 xs, ys; 163 WORD32 trans_skip; 164 WORD16 iquant_out; 165 WORD32 shift_iq; 166 { 167 WORD32 bit_depth; 168 169 bit_depth = 8 + 0; 170 shift_iq = bit_depth + log2_trans_size - 5; 171 } 172 trans_size = (1 << log2_trans_size); 173 174 /* First byte points to number of coded blocks */ 175 u1_num_coded_sblks = *pu1_tu_coeff_data++; 176 177 /* Next byte points to scan type */ 178 u1_scan_type = *pu1_tu_coeff_data++; 179 /* 0th bit has trans_skip */ 180 trans_skip = u1_scan_type & 1; 181 u1_scan_type >>= 1; 182 183 pi2_sblk_ptr = pi2_tu_coeff; 184 185 /* Initially all columns are assumed to be zero */ 186 *pu4_zero_cols = 0xFFFFFFFF; 187 /* Initially all rows are assumed to be zero */ 188 *pu4_zero_rows = 0xFFFFFFFF; 189 190 ps_tu_sblk_coeff_data = (tu_sblk_coeff_data_t *)(pu1_tu_coeff_data); 191 192 if(trans_skip) 193 memset(pi2_tu_coeff, 0, trans_size * trans_size * sizeof(WORD16)); 194 195 STATS_INIT_SBLK_AND_COEFF_POS(); 196 197 /* DC only case */ 198 if((e_trans_type != DST_4x4) && (1 == u1_num_coded_sblks) 199 && (0 == ps_tu_sblk_coeff_data->u2_subblk_pos) 200 && (1 == ps_tu_sblk_coeff_data->u2_sig_coeff_map)) 201 { 202 *pu4_coeff_type = 1; 203 204 if(!trans_quant_bypass) 205 { 206 if(4 == trans_size) 207 { 208 IQUANT_4x4(iquant_out, 209 ps_tu_sblk_coeff_data->ai2_level[0], 210 pi2_dequant_matrix[0] 211 * g_ihevc_iquant_scales[qp_rem], 212 shift_iq, qp_div); 213 } 214 else 215 { 216 IQUANT(iquant_out, ps_tu_sblk_coeff_data->ai2_level[0], 217 pi2_dequant_matrix[0] * g_ihevc_iquant_scales[qp_rem], 218 shift_iq, qp_div); 219 } 220 if(trans_skip) 221 iquant_out = (iquant_out + 16) >> 5; 222 } 223 else 224 { 225 /* setting the column to zero */ 226 for(i = 0; i < trans_size; i++) 227 *(pi2_tu_coeff + i * trans_size) = 0; 228 229 iquant_out = ps_tu_sblk_coeff_data->ai2_level[0]; 230 } 231 *pi2_coeff_value = iquant_out; 232 *pi2_tu_coeff = iquant_out; 233 *pu4_zero_cols &= ~0x1; 234 *pu4_zero_rows &= ~0x1; 235 ps_tu_sblk_coeff_data = 236 (void *)&ps_tu_sblk_coeff_data->ai2_level[1]; 237 238 STATS_UPDATE_COEFF_COUNT(); 239 STATS_LAST_SBLK_POS_UPDATE(e_trans_type, (trans_skip || trans_quant_bypass), 0, 0); 240 STATS_UPDATE_SBLK_AND_COEFF_HISTOGRAM(e_trans_type, (trans_quant_bypass || trans_skip)); 241 return ((UWORD8 *)ps_tu_sblk_coeff_data); 242 } 243 else 244 { 245 *pu4_coeff_type = 0; 246 /* In case of trans skip, memset has already happened */ 247 if(!trans_skip) 248 memset(pi2_tu_coeff, 0, trans_size * trans_size * sizeof(WORD16)); 249 } 250 251 for(i = 0; i < u1_num_coded_sblks; i++) 252 { 253 UWORD32 u4_sig_coeff_map; 254 subblk_pos_x = ps_tu_sblk_coeff_data->u2_subblk_pos & 0x00FF; 255 subblk_pos_y = (ps_tu_sblk_coeff_data->u2_subblk_pos & 0xFF00) >> 8; 256 257 STATS_LAST_SBLK_POS_UPDATE(e_trans_type, (trans_skip || trans_quant_bypass), subblk_pos_x, subblk_pos_y); 258 259 subblk_pos_x = subblk_pos_x * MIN_TU_SIZE; 260 subblk_pos_y = subblk_pos_y * MIN_TU_SIZE; 261 262 pi2_sblk_ptr = pi2_tu_coeff + subblk_pos_y * trans_size 263 + subblk_pos_x; 264 265 //*pu4_zero_cols &= ~(0xF << subblk_pos_x); 266 267 sblk_non_zero_coeff_idx = 0; 268 u4_sig_coeff_map = ps_tu_sblk_coeff_data->u2_sig_coeff_map; 269 //for(sblk_scan_idx = (31 - CLZ(u4_sig_coeff_map)); sblk_scan_idx >= 0; sblk_scan_idx--) 270 sblk_scan_idx = 31; 271 do 272 { 273 WORD32 clz = CLZ(u4_sig_coeff_map); 274 275 sblk_scan_idx -= clz; 276 /* when clz is 31, u4_sig_coeff_map << (clz+1) might result in unknown behaviour in some cases */ 277 /* Hence either use SHL which takes care of handling these issues based on platform or shift in two stages */ 278 u4_sig_coeff_map = u4_sig_coeff_map << clz; 279 /* Copying coeffs and storing in reverse order */ 280 { 281 STATS_UPDATE_COEFF_COUNT(); 282 coeff_raster_idx = 283 gau1_ihevc_invscan4x4[u1_scan_type][sblk_scan_idx]; 284 285 xs = coeff_raster_idx & 0x3; 286 ys = coeff_raster_idx >> 2; 287 288 if(!trans_quant_bypass) 289 { 290 if(4 == trans_size) 291 { 292 IQUANT_4x4(iquant_out, 293 ps_tu_sblk_coeff_data->ai2_level[sblk_non_zero_coeff_idx], 294 pi2_dequant_matrix[(subblk_pos_x + xs) 295 + (subblk_pos_y + ys) 296 * trans_size] 297 * g_ihevc_iquant_scales[qp_rem], 298 shift_iq, qp_div); 299 sblk_non_zero_coeff_idx++; 300 } 301 else 302 { 303 IQUANT(iquant_out, 304 ps_tu_sblk_coeff_data->ai2_level[sblk_non_zero_coeff_idx], 305 pi2_dequant_matrix[(subblk_pos_x + xs) 306 + (subblk_pos_y + ys) 307 * trans_size] 308 * g_ihevc_iquant_scales[qp_rem], 309 shift_iq, qp_div); 310 sblk_non_zero_coeff_idx++; 311 } 312 313 if(trans_skip) 314 iquant_out = (iquant_out + 16) >> 5; 315 } 316 else 317 { 318 iquant_out = ps_tu_sblk_coeff_data->ai2_level[sblk_non_zero_coeff_idx++]; 319 } 320 *pu4_zero_cols &= ~(0x1 << (subblk_pos_x + xs)); 321 *pu4_zero_rows &= ~(0x1 << (subblk_pos_y + ys)); 322 *(pi2_sblk_ptr + xs + ys * trans_size) = iquant_out; 323 } 324 sblk_scan_idx--; 325 u4_sig_coeff_map <<= 1; 326 327 }while(u4_sig_coeff_map); 328 /* Updating the sblk pointer */ 329 ps_tu_sblk_coeff_data = 330 (void *)&ps_tu_sblk_coeff_data->ai2_level[sblk_non_zero_coeff_idx]; 331 } 332 333 STATS_UPDATE_SBLK_AND_COEFF_HISTOGRAM(e_trans_type, (trans_quant_bypass || trans_skip)); 334 335 pu1_new_tu_coeff_data = (UWORD8 *)ps_tu_sblk_coeff_data; 336 337 return pu1_new_tu_coeff_data; 338 } 339 340 WORD32 ihevcd_get_intra_nbr_flag(process_ctxt_t *ps_proc, 341 tu_t *ps_tu, 342 UWORD32 *pu4_intra_nbr_avail, 343 WORD16 i2_pic_width_in_luma_samples, 344 UWORD8 i1_constrained_intra_pred_flag, 345 WORD32 trans_size, 346 WORD32 ctb_size) 347 { 348 sps_t *ps_sps; 349 UWORD8 u1_bot_lt_avail, u1_left_avail, u1_top_avail, u1_top_rt_avail, 350 u1_top_lt_avail; 351 WORD32 x_cur, y_cur, x_nbr, y_nbr; 352 UWORD8 *pu1_nbr_intra_flag; 353 UWORD8 *pu1_pic_intra_flag; 354 UWORD8 top_right, top, top_left, left, bot_left; 355 WORD32 intra_pos; 356 WORD32 num_8_blks, num_8_blks_in_bits; 357 WORD32 numbytes_row = (i2_pic_width_in_luma_samples + 63) / 64; 358 WORD32 cur_x, cur_y; 359 WORD32 i; 360 WORD32 nbr_flags; 361 362 ps_sps = ps_proc->ps_sps; 363 cur_x = ps_tu->b4_pos_x; 364 cur_y = ps_tu->b4_pos_y; 365 366 u1_bot_lt_avail = (pu4_intra_nbr_avail[1 + cur_y + trans_size / MIN_TU_SIZE] 367 >> (31 - (1 + cur_x - 1))) & 1; 368 u1_left_avail = (pu4_intra_nbr_avail[1 + cur_y] >> (31 - (1 + cur_x - 1))) 369 & 1; 370 u1_top_avail = (pu4_intra_nbr_avail[1 + cur_y - 1] >> (31 - (1 + cur_x))) 371 & 1; 372 u1_top_rt_avail = (pu4_intra_nbr_avail[1 + cur_y - 1] 373 >> (31 - (1 + cur_x + trans_size / MIN_TU_SIZE))) & 1; 374 u1_top_lt_avail = (pu4_intra_nbr_avail[1 + cur_y - 1] 375 >> (31 - (1 + cur_x - 1))) & 1; 376 377 x_cur = ps_proc->i4_ctb_x * ctb_size + cur_x * MIN_TU_SIZE; 378 y_cur = ps_proc->i4_ctb_y * ctb_size + cur_y * MIN_TU_SIZE; 379 380 pu1_pic_intra_flag = ps_proc->pu1_pic_intra_flag; 381 382 /* WORD32 nbr_flags as below MSB --> LSB */ 383 /* Top-Left | Top-Right | Top | Left | Bottom-Left 384 * 1 4 4 4 4 385 */ 386 bot_left = 0; 387 left = 0; 388 top_right = 0; 389 top = 0; 390 top_left = 0; 391 392 num_8_blks = trans_size > 4 ? trans_size / 8 : 1; 393 num_8_blks_in_bits = ((1 << num_8_blks) - 1); 394 395 if(i1_constrained_intra_pred_flag) 396 { 397 /* TODO: constrained intra pred not tested */ 398 if(u1_bot_lt_avail) 399 { 400 x_nbr = x_cur - 1; 401 y_nbr = y_cur + trans_size; 402 403 pu1_nbr_intra_flag = pu1_pic_intra_flag + y_nbr / 8 * numbytes_row 404 + x_nbr / 64; 405 intra_pos = ((x_nbr / 8) % 8); 406 for(i = 0; i < num_8_blks; i++) 407 { 408 bot_left |= ((*(pu1_nbr_intra_flag + i * numbytes_row) 409 >> intra_pos) & 1) << i; 410 } 411 bot_left &= num_8_blks_in_bits; 412 } 413 if(u1_left_avail) 414 { 415 x_nbr = x_cur - 1; 416 y_nbr = y_cur; 417 418 pu1_nbr_intra_flag = pu1_pic_intra_flag + y_nbr / 8 * numbytes_row 419 + x_nbr / 64; 420 intra_pos = ((x_nbr / 8) % 8); 421 422 for(i = 0; i < num_8_blks; i++) 423 { 424 left |= ((*(pu1_nbr_intra_flag + i * numbytes_row) >> intra_pos) 425 & 1) << i; 426 } 427 left &= num_8_blks_in_bits; 428 } 429 if(u1_top_avail) 430 { 431 x_nbr = x_cur; 432 y_nbr = y_cur - 1; 433 434 pu1_nbr_intra_flag = pu1_pic_intra_flag + y_nbr / 8 * numbytes_row 435 + x_nbr / 64; 436 intra_pos = ((x_nbr / 8) % 8); 437 438 top = (*pu1_nbr_intra_flag >> intra_pos); 439 top &= num_8_blks_in_bits; 440 /* 441 for(i=0;i<num_8_blks;i++) 442 { 443 top |= ( (*pu1_nbr_intra_flag >> (intra_pos+i)) & 1) << i; 444 } 445 */ 446 } 447 if(u1_top_rt_avail) 448 { 449 x_nbr = x_cur + trans_size; 450 y_nbr = y_cur - 1; 451 452 pu1_nbr_intra_flag = pu1_pic_intra_flag + y_nbr / 8 * numbytes_row 453 + x_nbr / 64; 454 intra_pos = ((x_nbr / 8) % 8); 455 456 top_right = (*pu1_nbr_intra_flag >> intra_pos); 457 top_right &= num_8_blks_in_bits; 458 /* 459 for(i=0;i<num_8_blks;i++) 460 { 461 top_right |= ( (*pu1_nbr_intra_flag >> (intra_pos+i)) & 1) << i; 462 } 463 */ 464 } 465 if(u1_top_lt_avail) 466 { 467 x_nbr = x_cur - 1; 468 y_nbr = y_cur - 1; 469 470 pu1_nbr_intra_flag = pu1_pic_intra_flag + y_nbr / 8 * numbytes_row 471 + x_nbr / 64; 472 intra_pos = ((x_nbr / 8) % 8); 473 474 top_left = (*pu1_nbr_intra_flag >> intra_pos) & 1; 475 } 476 } 477 else 478 { 479 if(u1_top_avail) 480 top = 0xF; 481 if(u1_top_rt_avail) 482 top_right = 0xF; 483 if(u1_bot_lt_avail) 484 bot_left = 0xF; 485 if(u1_left_avail) 486 left = 0xF; 487 if(u1_top_lt_avail) 488 top_left = 0x1; 489 } 490 491 /* Handling incomplete CTBs */ 492 { 493 WORD32 pu_size_limit = MIN(trans_size, 8); 494 WORD32 cols_remaining = ps_sps->i2_pic_width_in_luma_samples 495 - (ps_proc->i4_ctb_x << ps_sps->i1_log2_ctb_size) 496 - (ps_tu->b4_pos_x * MIN_TU_SIZE) 497 - (1 << (ps_tu->b3_size + 2)); 498 /* ctb_size_top gives number of valid pixels remaining in the current row */ 499 WORD32 ctb_size_top = MIN(ctb_size, cols_remaining); 500 WORD32 ctb_size_top_bits = (1 << (ctb_size_top / pu_size_limit)) - 1; 501 502 WORD32 rows_remaining = ps_sps->i2_pic_height_in_luma_samples 503 - (ps_proc->i4_ctb_y << ps_sps->i1_log2_ctb_size) 504 - (ps_tu->b4_pos_y * MIN_TU_SIZE) 505 - (1 << (ps_tu->b3_size + 2)); 506 /* ctb_size_bot gives number of valid pixels remaining in the current column */ 507 WORD32 ctb_size_bot = MIN(ctb_size, rows_remaining); 508 WORD32 ctb_size_bot_bits = (1 << (ctb_size_bot / pu_size_limit)) - 1; 509 510 top_right &= ctb_size_top_bits; 511 bot_left &= ctb_size_bot_bits; 512 } 513 514 /* Top-Left | Top-Right | Top | Left | Bottom-Left 515 * 1 4 4 4 4 516 */ 517 518 /* 519 nbr_flags = (top_left << 16) | (gau4_ihevcd_4_bit_reverse[top_right] << 12) | (gau4_ihevcd_4_bit_reverse[top] << 8) | (gau4_ihevcd_4_bit_reverse[left] << 4) 520 | gau4_ihevcd_4_bit_reverse[bot_left]; 521 */ 522 nbr_flags = (top_left << 16) | (top_right << 12) | (top << 8) | (gau4_ihevcd_4_bit_reverse[left] << 4) 523 | gau4_ihevcd_4_bit_reverse[bot_left]; 524 525 526 return nbr_flags; 527 528 } 529 530 WORD32 ihevcd_iquant_itrans_recon_ctb(process_ctxt_t *ps_proc) 531 { 532 WORD16 *pi2_scaling_mat; 533 UWORD8 *pu1_y_dst_ctb; 534 UWORD8 *pu1_uv_dst_ctb; 535 WORD32 ctb_size; 536 codec_t *ps_codec; 537 slice_header_t *ps_slice_hdr; 538 tu_t *ps_tu; 539 WORD16 *pi2_ctb_coeff; 540 WORD32 tu_cnt; 541 WORD16 *pi2_tu_coeff; 542 WORD16 *pi2_tmp; 543 WORD32 pic_strd; 544 WORD32 luma_nbr_flags; 545 WORD32 chroma_nbr_flags = 0; 546 UWORD8 u1_luma_pred_mode_first_tu = 0; 547 /* Pointers for generating 2d coeffs from coeff-map */ 548 UWORD8 *pu1_tu_coeff_data; 549 /* nbr avail map for CTB */ 550 /* 1st bit points to neighbor (left/top_left/bot_left) */ 551 /* 1Tb starts at 2nd bit from msb of 2nd value in array, followed by number of min_tu's in that ctb */ 552 UWORD32 au4_intra_nbr_avail[MAX_CTB_SIZE / MIN_TU_SIZE 553 + 2 /* Top nbr + bot nbr */]; UWORD32 554 top_avail_bits; 555 sps_t *ps_sps; 556 pps_t *ps_pps; 557 WORD32 intra_flag; 558 UWORD8 *pu1_pic_intra_flag; 559 /*************************************************************************/ 560 /* Contanis scaling matrix offset in the following order in a 1D buffer */ 561 /* Intra 4 x 4 Y, 4 x 4 U, 4 x 4 V */ 562 /* Inter 4 x 4 Y, 4 x 4 U, 4 x 4 V */ 563 /* Intra 8 x 8 Y, 8 x 8 U, 8 x 8 V */ 564 /* Inter 8 x 8 Y, 8 x 8 U, 8 x 8 V */ 565 /* Intra 16x16 Y, 16x16 U, 16x16 V */ 566 /* Inter 16x16 Y, 16x16 U, 16x16 V */ 567 /* Intra 32x32 Y */ 568 /* Inter 32x32 Y */ 569 /*************************************************************************/ 570 WORD32 scaling_mat_offset[] = 571 { 0, 16, 32, 48, 64, 80, 96, 160, 224, 288, 352, 416, 480, 736, 992, 572 1248, 1504, 1760, 2016, 3040 }; 573 574 PROFILE_DISABLE_IQ_IT_RECON_INTRA_PRED(); 575 576 ps_sps = ps_proc->ps_sps; 577 ps_pps = ps_proc->ps_pps; 578 ps_slice_hdr = ps_proc->ps_slice_hdr; 579 ps_codec = ps_proc->ps_codec; 580 581 pu1_y_dst_ctb = ps_proc->pu1_cur_ctb_luma; 582 pu1_uv_dst_ctb = ps_proc->pu1_cur_ctb_chroma; 583 584 pi2_ctb_coeff = ps_proc->pi2_invscan_out; 585 586 ctb_size = (1 << ps_sps->i1_log2_ctb_size); 587 pu1_tu_coeff_data = (UWORD8 *)ps_proc->pv_tu_coeff_data; 588 589 pic_strd = ps_codec->i4_strd; 590 591 pi2_tmp = ps_proc->pi2_itrans_intrmd_buf; 592 593 pi2_tu_coeff = pi2_ctb_coeff; 594 595 ps_tu = ps_proc->ps_tu; 596 597 if((1 == ps_sps->i1_scaling_list_enable_flag) && (1 == ps_pps->i1_pps_scaling_list_data_present_flag)) 598 { 599 pi2_scaling_mat = ps_pps->pi2_scaling_mat; 600 } 601 else 602 { 603 pi2_scaling_mat = ps_sps->pi2_scaling_mat; 604 } 605 606 { 607 /* Updating the initial availability map */ 608 WORD32 i; 609 UWORD8 u1_left_ctb_avail, u1_top_lt_ctb_avail, u1_top_rt_ctb_avail, 610 u1_top_ctb_avail; 611 612 u1_left_ctb_avail = ps_proc->u1_left_ctb_avail; 613 u1_top_lt_ctb_avail = ps_proc->u1_top_lt_ctb_avail; 614 u1_top_ctb_avail = ps_proc->u1_top_ctb_avail; 615 u1_top_rt_ctb_avail = ps_proc->u1_top_rt_ctb_avail; 616 617 /* Initializing the availability array */ 618 memset(au4_intra_nbr_avail, 0, 619 (MAX_CTB_SIZE / MIN_TU_SIZE + 2) * sizeof(UWORD32)); 620 /* Initializing the availability array with CTB level availability flags */ 621 { 622 WORD32 rows_remaining = ps_sps->i2_pic_height_in_luma_samples - (ps_proc->i4_ctb_y << ps_sps->i1_log2_ctb_size); 623 WORD32 ctb_size_left = MIN(ctb_size, rows_remaining); 624 for(i = 0; i < ctb_size_left / MIN_TU_SIZE; i++) 625 { 626 au4_intra_nbr_avail[i + 1] = ((UWORD32)u1_left_ctb_avail << 31); 627 } 628 } 629 au4_intra_nbr_avail[0] |= (((UWORD32)u1_top_rt_ctb_avail << 31) 630 >> (1 + ctb_size / MIN_TU_SIZE)); /* 1+ctb_size/4 position bit pos from msb */ 631 632 au4_intra_nbr_avail[0] |= ((UWORD32)u1_top_lt_ctb_avail << 31); 633 634 { 635 WORD32 cols_remaining = ps_sps->i2_pic_width_in_luma_samples - (ps_proc->i4_ctb_x << ps_sps->i1_log2_ctb_size); 636 WORD32 ctb_size_top = MIN(ctb_size, cols_remaining); 637 WORD32 shift = (31 - (ctb_size / MIN_TU_SIZE)); 638 639 /* ctb_size_top gives number of valid pixels remaining in the current row */ 640 /* Since we need pattern of 1's starting from the MSB, an additional shift */ 641 /* is needed */ 642 shift += ((ctb_size - ctb_size_top) / MIN_TU_SIZE); 643 644 top_avail_bits = ((1 << (ctb_size_top / MIN_TU_SIZE)) - 1) 645 << shift; 646 } 647 au4_intra_nbr_avail[0] |= ( 648 (u1_top_ctb_avail == 1) ? top_avail_bits : 0x0); 649 /* Starting from msb 2nd bit to (1+ctb_size/4) bit, set 1 if top avail,or 0 */ 650 651 } 652 653 /* Applying Inverse transform on all the TU's in CTB */ 654 for(tu_cnt = 0; tu_cnt < ps_proc->i4_ctb_tu_cnt; tu_cnt++, ps_tu++) 655 { 656 WORD32 transform_skip_flag = 0; 657 WORD32 transform_skip_flag_v = 0; 658 WORD32 num_comp, c_idx, func_idx; 659 WORD32 src_strd, pred_strd, dst_strd; 660 WORD32 qp_div = 0, qp_rem = 0; 661 WORD32 qp_div_v = 0, qp_rem_v = 0; 662 UWORD32 zero_cols = 0, zero_cols_v = 0; 663 UWORD32 zero_rows = 0, zero_rows_v = 0; 664 UWORD32 coeff_type = 0, coeff_type_v = 0; 665 WORD16 i2_coeff_value, i2_coeff_value_v; 666 WORD32 trans_size = 0; 667 TRANSFORM_TYPE e_trans_type; 668 WORD32 log2_y_trans_size_minus_2, log2_uv_trans_size_minus_2; 669 WORD32 log2_trans_size; 670 WORD32 chroma_qp_idx; 671 WORD16 *pi2_src = NULL, *pi2_src_v = NULL; 672 UWORD8 *pu1_pred = NULL, *pu1_pred_v = NULL; 673 UWORD8 *pu1_dst = NULL, *pu1_dst_v = NULL; 674 WORD16 *pi2_dequant_matrix = NULL, *pi2_dequant_matrix_v = NULL; 675 WORD32 tu_x, tu_y; 676 WORD32 tu_y_offset, tu_uv_offset; 677 WORD8 i1_chroma_pic_qp_offset, i1_chroma_slice_qp_offset; 678 UWORD8 u1_cbf = 0, u1_cbf_v = 0, u1_luma_pred_mode, u1_chroma_pred_mode; 679 WORD32 luma_nbr_flags_4x4[4]; 680 WORD32 offset; 681 WORD32 pcm_flag; 682 WORD32 chroma_yuv420sp_vu = (ps_codec->e_ref_chroma_fmt == IV_YUV_420SP_VU); 683 /* If 420SP_VU is chroma format, pred and dst pointer */ 684 /* will be added +1 to point to U */ 685 WORD32 chroma_yuv420sp_vu_u_offset = 1 * chroma_yuv420sp_vu; 686 /* If 420SP_VU is chroma format, pred and dst pointer */ 687 /* will be added U offset of +1 and subtracted 2 */ 688 /* to point to V */ 689 WORD32 chroma_yuv420sp_vu_v_offset = -2 * chroma_yuv420sp_vu; 690 691 tu_x = ps_tu->b4_pos_x * 4; /* Converting minTU unit to pixel unit */ 692 tu_y = ps_tu->b4_pos_y * 4; /* Converting minTU unit to pixel unit */ 693 { 694 WORD32 tu_abs_x = (ps_proc->i4_ctb_x << ps_sps->i1_log2_ctb_size) + (tu_x); 695 WORD32 tu_abs_y = (ps_proc->i4_ctb_y << ps_sps->i1_log2_ctb_size) + (tu_y); 696 697 WORD32 numbytes_row = (ps_sps->i2_pic_width_in_luma_samples + 63) / 64; 698 699 pu1_pic_intra_flag = ps_proc->pu1_pic_intra_flag; 700 pu1_pic_intra_flag += (tu_abs_y >> 3) * numbytes_row; 701 pu1_pic_intra_flag += (tu_abs_x >> 6); 702 703 intra_flag = *pu1_pic_intra_flag; 704 intra_flag &= (1 << ((tu_abs_x >> 3) % 8)); 705 } 706 707 u1_luma_pred_mode = ps_tu->b6_luma_intra_mode; 708 u1_chroma_pred_mode = ps_tu->b3_chroma_intra_mode_idx; 709 710 if(u1_chroma_pred_mode != 7) 711 num_comp = 2; /* Y and UV */ 712 else 713 num_comp = 1; /* Y */ 714 715 716 pcm_flag = 0; 717 718 if((intra_flag) && (u1_luma_pred_mode == INTRA_PRED_NONE)) 719 { 720 UWORD8 *pu1_buf; 721 UWORD8 *pu1_y_dst = pu1_y_dst_ctb; 722 UWORD8 *pu1_uv_dst = pu1_uv_dst_ctb; 723 WORD32 i, j; 724 tu_sblk_coeff_data_t *ps_tu_sblk_coeff_data; 725 WORD32 cb_size = 1 << (ps_tu->b3_size + 2); 726 727 /* trans_size is used to update availability after reconstruction */ 728 trans_size = cb_size; 729 730 pcm_flag = 1; 731 732 tu_y_offset = tu_x + tu_y * pic_strd; 733 pu1_y_dst += tu_x + tu_y * pic_strd; 734 pu1_uv_dst += tu_x + (tu_y >> 1) * pic_strd; 735 736 /* First byte points to number of coded blocks */ 737 pu1_tu_coeff_data++; 738 739 /* Next byte points to scan type */ 740 pu1_tu_coeff_data++; 741 742 ps_tu_sblk_coeff_data = (tu_sblk_coeff_data_t *)pu1_tu_coeff_data; 743 744 pu1_buf = (UWORD8 *)&ps_tu_sblk_coeff_data->ai2_level[0]; 745 { 746 747 for(i = 0; i < cb_size; i++) 748 { 749 //pu1_y_dst[i * pic_strd + j] = *pu1_buf++; 750 memcpy(&pu1_y_dst[i * pic_strd], pu1_buf, cb_size); 751 pu1_buf += cb_size; 752 } 753 754 pu1_uv_dst = pu1_uv_dst + chroma_yuv420sp_vu_u_offset; 755 756 /* U */ 757 for(i = 0; i < cb_size / 2; i++) 758 { 759 for(j = 0; j < cb_size / 2; j++) 760 { 761 pu1_uv_dst[i * pic_strd + 2 * j] = *pu1_buf++; 762 } 763 } 764 765 pu1_uv_dst = pu1_uv_dst + 1 + chroma_yuv420sp_vu_v_offset; 766 767 /* V */ 768 for(i = 0; i < cb_size / 2; i++) 769 { 770 for(j = 0; j < cb_size / 2; j++) 771 { 772 pu1_uv_dst[i * pic_strd + 2 * j] = *pu1_buf++; 773 } 774 } 775 } 776 777 pu1_tu_coeff_data = pu1_buf; 778 779 } 780 781 782 783 784 785 for(c_idx = 0; c_idx < num_comp; c_idx++) 786 { 787 if(0 == pcm_flag) 788 { 789 /* Initializing variables */ 790 pred_strd = pic_strd; 791 dst_strd = pic_strd; 792 793 if(c_idx == 0) /* Y */ 794 { 795 log2_y_trans_size_minus_2 = ps_tu->b3_size; 796 trans_size = 1 << (log2_y_trans_size_minus_2 + 2); 797 log2_trans_size = log2_y_trans_size_minus_2 + 2; 798 799 tu_y_offset = tu_x + tu_y * pic_strd; 800 801 pi2_src = pi2_tu_coeff; 802 pu1_pred = pu1_y_dst_ctb + tu_y_offset; 803 pu1_dst = pu1_y_dst_ctb + tu_y_offset; 804 805 /* Calculating scaling matrix offset */ 806 offset = log2_y_trans_size_minus_2 * 6 807 + (!intra_flag) 808 * ((log2_y_trans_size_minus_2 809 == 3) ? 1 : 3) 810 + c_idx; 811 pi2_dequant_matrix = pi2_scaling_mat 812 + scaling_mat_offset[offset]; 813 814 src_strd = trans_size; 815 816 /* 4x4 transform Luma in INTRA mode is DST */ 817 if(log2_y_trans_size_minus_2 == 0 && intra_flag) 818 { 819 func_idx = log2_y_trans_size_minus_2; 820 e_trans_type = DST_4x4; 821 } 822 else 823 { 824 func_idx = log2_y_trans_size_minus_2 + 1; 825 e_trans_type = (TRANSFORM_TYPE)(log2_y_trans_size_minus_2 + 1); 826 } 827 828 qp_div = ps_tu->b7_qp / 6; 829 qp_rem = ps_tu->b7_qp % 6; 830 831 u1_cbf = ps_tu->b1_y_cbf; 832 833 transform_skip_flag = pu1_tu_coeff_data[1] & 1; 834 /* Unpacking coeffs */ 835 if(1 == u1_cbf) 836 { 837 pu1_tu_coeff_data = ihevcd_unpack_coeffs( 838 pi2_src, log2_y_trans_size_minus_2 + 2, 839 pu1_tu_coeff_data, pi2_dequant_matrix, 840 qp_rem, qp_div, e_trans_type, 841 ps_tu->b1_transquant_bypass, &zero_cols, 842 &zero_rows, &coeff_type, 843 &i2_coeff_value); 844 } 845 } 846 else /* UV interleaved */ 847 { 848 /* Chroma :If Transform size is 4x4, keep 4x4 else do transform on (trans_size/2 x trans_size/2) */ 849 if(ps_tu->b3_size == 0) 850 { 851 /* Chroma 4x4 is present with 4th luma 4x4 block. For this case chroma postion has to be (luma pos x- 4,luma pos y- 4) */ 852 log2_uv_trans_size_minus_2 = ps_tu->b3_size; 853 tu_uv_offset = (tu_x - 4) + ((tu_y - 4) / 2) * pic_strd; 854 } 855 else 856 { 857 log2_uv_trans_size_minus_2 = ps_tu->b3_size - 1; 858 tu_uv_offset = tu_x + (tu_y >> 1) * pic_strd; 859 } 860 trans_size = 1 << (log2_uv_trans_size_minus_2 + 2); 861 log2_trans_size = log2_uv_trans_size_minus_2 + 2; 862 863 pi2_src = pi2_tu_coeff; 864 pi2_src_v = pi2_tu_coeff + trans_size * trans_size; 865 pu1_pred = pu1_uv_dst_ctb + tu_uv_offset + chroma_yuv420sp_vu_u_offset; /* Pointing to start byte of U*/ 866 pu1_pred_v = pu1_pred + 1 + chroma_yuv420sp_vu_v_offset; /* Pointing to start byte of V*/ 867 pu1_dst = pu1_uv_dst_ctb + tu_uv_offset + chroma_yuv420sp_vu_u_offset; /* Pointing to start byte of U*/ 868 pu1_dst_v = pu1_dst + 1 + chroma_yuv420sp_vu_v_offset; /* Pointing to start byte of V*/ 869 870 /*TODO: Add support for choosing different tables for U and V, 871 * change this to a single array to handle flat/default/custom, intra/inter, luma/chroma and various sizes 872 */ 873 /* Calculating scaling matrix offset */ 874 /* ((log2_uv_trans_size_minus_2 == 3) ? 1:3) condition check is not needed, since 875 * max uv trans size is 16x16 876 */ 877 offset = log2_uv_trans_size_minus_2 * 6 878 + (!intra_flag) * 3 + c_idx; 879 pi2_dequant_matrix = pi2_scaling_mat 880 + scaling_mat_offset[offset]; 881 pi2_dequant_matrix_v = pi2_scaling_mat 882 + scaling_mat_offset[offset + 1]; 883 884 src_strd = trans_size; 885 886 func_idx = 1 + 4 + log2_uv_trans_size_minus_2; /* DST func + Y funcs + cur func index*/ 887 e_trans_type = (TRANSFORM_TYPE)(log2_uv_trans_size_minus_2 + 1); 888 /* QP for U */ 889 i1_chroma_pic_qp_offset = ps_pps->i1_pic_cb_qp_offset; 890 i1_chroma_slice_qp_offset = ps_slice_hdr->i1_slice_cb_qp_offset; 891 u1_cbf = ps_tu->b1_cb_cbf; 892 893 chroma_qp_idx = ps_tu->b7_qp + i1_chroma_pic_qp_offset 894 + i1_chroma_slice_qp_offset; 895 chroma_qp_idx = CLIP3(chroma_qp_idx, 0, 57); 896 qp_div = gai2_ihevcd_chroma_qp[chroma_qp_idx] / 6; 897 qp_rem = gai2_ihevcd_chroma_qp[chroma_qp_idx] % 6; 898 899 /* QP for V */ 900 i1_chroma_pic_qp_offset = ps_pps->i1_pic_cr_qp_offset; 901 i1_chroma_slice_qp_offset = ps_slice_hdr->i1_slice_cr_qp_offset; 902 u1_cbf_v = ps_tu->b1_cr_cbf; 903 904 chroma_qp_idx = ps_tu->b7_qp + i1_chroma_pic_qp_offset 905 + i1_chroma_slice_qp_offset; 906 chroma_qp_idx = CLIP3(chroma_qp_idx, 0, 57); 907 qp_div_v = gai2_ihevcd_chroma_qp[chroma_qp_idx] / 6; 908 qp_rem_v = gai2_ihevcd_chroma_qp[chroma_qp_idx] % 6; 909 910 /* Unpacking coeffs */ 911 transform_skip_flag = pu1_tu_coeff_data[1] & 1; 912 if(1 == u1_cbf) 913 { 914 pu1_tu_coeff_data = ihevcd_unpack_coeffs( 915 pi2_src, log2_uv_trans_size_minus_2 + 2, 916 pu1_tu_coeff_data, pi2_dequant_matrix, 917 qp_rem, qp_div, e_trans_type, 918 ps_tu->b1_transquant_bypass, &zero_cols, 919 &zero_rows, &coeff_type, 920 &i2_coeff_value); 921 } 922 923 transform_skip_flag_v = pu1_tu_coeff_data[1] & 1; 924 if(1 == u1_cbf_v) 925 { 926 pu1_tu_coeff_data = ihevcd_unpack_coeffs( 927 pi2_src_v, log2_uv_trans_size_minus_2 + 2, 928 pu1_tu_coeff_data, pi2_dequant_matrix_v, 929 qp_rem_v, qp_div_v, e_trans_type, 930 ps_tu->b1_transquant_bypass, &zero_cols_v, 931 &zero_rows_v, &coeff_type_v, &i2_coeff_value_v); 932 } 933 } 934 /***************************************************************/ 935 /****************** Intra Prediction **************************/ 936 /***************************************************************/ 937 if(intra_flag) /* Intra */ 938 { 939 UWORD8 au1_ref_sub_out[(MAX_TU_SIZE * 2 * 2) + 4]; 940 UWORD8 *pu1_top_left, *pu1_top, *pu1_left; 941 WORD32 luma_pred_func_idx, chroma_pred_func_idx; 942 943 /* Get the neighbour availability flags */ 944 /* Done for only Y */ 945 if(c_idx == 0) 946 { 947 /* Get neighbor availability for Y only */ 948 luma_nbr_flags = ihevcd_get_intra_nbr_flag(ps_proc, 949 ps_tu, 950 au4_intra_nbr_avail, 951 ps_sps->i2_pic_width_in_luma_samples, 952 ps_pps->i1_constrained_intra_pred_flag, 953 trans_size, 954 ctb_size); 955 956 if(trans_size == 4) 957 luma_nbr_flags_4x4[(ps_tu->b4_pos_x % 2) + (ps_tu->b4_pos_y % 2) * 2] = luma_nbr_flags; 958 959 if((ps_tu->b4_pos_x % 2 == 0) && (ps_tu->b4_pos_y % 2 == 0)) 960 { 961 chroma_nbr_flags = luma_nbr_flags; 962 } 963 964 /* Initializing nbr pointers */ 965 pu1_top = pu1_pred - pic_strd; 966 pu1_left = pu1_pred - 1; 967 pu1_top_left = pu1_pred - pic_strd - 1; 968 969 /* call reference array substitution */ 970 if(luma_nbr_flags == 0x1ffff) 971 ps_codec->s_func_selector.ihevc_intra_pred_luma_ref_subst_all_avlble_fptr( 972 pu1_top_left, 973 pu1_top, pu1_left, pred_strd, trans_size, luma_nbr_flags, au1_ref_sub_out, 1); 974 else 975 ps_codec->s_func_selector.ihevc_intra_pred_luma_ref_substitution_fptr( 976 pu1_top_left, 977 pu1_top, pu1_left, pred_strd, trans_size, luma_nbr_flags, au1_ref_sub_out, 1); 978 979 /* call reference filtering */ 980 ps_codec->s_func_selector.ihevc_intra_pred_ref_filtering_fptr( 981 au1_ref_sub_out, trans_size, 982 au1_ref_sub_out, 983 u1_luma_pred_mode, ps_sps->i1_strong_intra_smoothing_enable_flag); 984 985 /* use the look up to get the function idx */ 986 luma_pred_func_idx = g_i4_ip_funcs[u1_luma_pred_mode]; 987 988 /* call the intra prediction function */ 989 ps_codec->apf_intra_pred_luma[luma_pred_func_idx](au1_ref_sub_out, 1, pu1_pred, pred_strd, trans_size, u1_luma_pred_mode); 990 } 991 else 992 { 993 /* In case of yuv420sp_vu, prediction happens as usual. */ 994 /* So point the pu1_pred pointer to original prediction pointer */ 995 UWORD8 *pu1_pred_orig = pu1_pred - chroma_yuv420sp_vu_u_offset; 996 997 /* Top-Left | Top-Right | Top | Left | Bottom-Left 998 * 1 4 4 4 4 999 * 1000 * Generating chroma_nbr_flags depending upon the transform size */ 1001 if(ps_tu->b3_size == 0) 1002 { 1003 /* Take TL,T,L flags of First luma 4x4 block */ 1004 chroma_nbr_flags = (luma_nbr_flags_4x4[0] & 0x10FF0); 1005 /* Take TR flags of Second luma 4x4 block */ 1006 chroma_nbr_flags |= (luma_nbr_flags_4x4[1] & 0x0F000); 1007 /* Take BL flags of Third luma 4x4 block */ 1008 chroma_nbr_flags |= (luma_nbr_flags_4x4[2] & 0x0000F); 1009 } 1010 1011 /* Initializing nbr pointers */ 1012 pu1_top = pu1_pred_orig - pic_strd; 1013 pu1_left = pu1_pred_orig - 2; 1014 pu1_top_left = pu1_pred_orig - pic_strd - 2; 1015 1016 /* Chroma pred mode derivation from luma pred mode */ 1017 { 1018 tu_t *ps_tu_tmp = ps_tu; 1019 while(!ps_tu_tmp->b1_first_tu_in_cu) 1020 { 1021 ps_tu_tmp--; 1022 } 1023 u1_luma_pred_mode_first_tu = ps_tu_tmp->b6_luma_intra_mode; 1024 } 1025 if(4 == u1_chroma_pred_mode) 1026 u1_chroma_pred_mode = u1_luma_pred_mode_first_tu; 1027 else 1028 { 1029 u1_chroma_pred_mode = gau1_intra_pred_chroma_modes[u1_chroma_pred_mode]; 1030 1031 if(u1_chroma_pred_mode == 1032 u1_luma_pred_mode_first_tu) 1033 { 1034 u1_chroma_pred_mode = INTRA_ANGULAR(34); 1035 } 1036 } 1037 1038 /* call the chroma reference array substitution */ 1039 ps_codec->s_func_selector.ihevc_intra_pred_chroma_ref_substitution_fptr( 1040 pu1_top_left, 1041 pu1_top, pu1_left, pic_strd, trans_size, chroma_nbr_flags, au1_ref_sub_out, 1); 1042 1043 /* use the look up to get the function idx */ 1044 chroma_pred_func_idx = 1045 g_i4_ip_funcs[u1_chroma_pred_mode]; 1046 1047 /* call the intra prediction function */ 1048 ps_codec->apf_intra_pred_chroma[chroma_pred_func_idx](au1_ref_sub_out, 1, pu1_pred_orig, pred_strd, trans_size, u1_chroma_pred_mode); 1049 } 1050 } 1051 1052 /* Updating number of transform types */ 1053 STATS_UPDATE_ALL_TRANS(e_trans_type, c_idx); 1054 1055 /* IQ, IT and Recon for Y if c_idx == 0, and U if c_idx !=0 */ 1056 if(1 == u1_cbf) 1057 { 1058 if(ps_tu->b1_transquant_bypass || transform_skip_flag) 1059 { 1060 /* Recon */ 1061 ps_codec->apf_recon[func_idx](pi2_src, pu1_pred, pu1_dst, 1062 src_strd, pred_strd, dst_strd, 1063 zero_cols); 1064 } 1065 else 1066 { 1067 1068 /* Updating coded number of transform types(excluding trans skip and trans quant skip) */ 1069 STATS_UPDATE_CODED_TRANS(e_trans_type, c_idx, 0); 1070 1071 /* iQuant , iTrans and Recon */ 1072 if((0 == coeff_type)) 1073 { 1074 ps_codec->apf_itrans_recon[func_idx](pi2_src, pi2_tmp, 1075 pu1_pred, pu1_dst, 1076 src_strd, pred_strd, 1077 dst_strd, zero_cols, 1078 zero_rows); 1079 } 1080 else /* DC only */ 1081 { 1082 STATS_UPDATE_CODED_TRANS(e_trans_type, c_idx, 1); 1083 ps_codec->apf_itrans_recon_dc[c_idx](pu1_pred, pu1_dst, 1084 pred_strd, dst_strd, 1085 log2_trans_size, 1086 i2_coeff_value); 1087 } 1088 } 1089 } 1090 /* IQ, IT and Recon for V */ 1091 if(c_idx != 0) 1092 { 1093 if(1 == u1_cbf_v) 1094 { 1095 if(ps_tu->b1_transquant_bypass || transform_skip_flag_v) 1096 { 1097 /* Recon */ 1098 ps_codec->apf_recon[func_idx](pi2_src_v, pu1_pred_v, 1099 pu1_dst_v, src_strd, 1100 pred_strd, dst_strd, 1101 zero_cols_v); 1102 } 1103 else 1104 { 1105 /* Updating number of transform types */ 1106 STATS_UPDATE_CODED_TRANS(e_trans_type, c_idx, 0); 1107 1108 /* iQuant , iTrans and Recon */ 1109 if((0 == coeff_type_v)) 1110 { 1111 ps_codec->apf_itrans_recon[func_idx](pi2_src_v, 1112 pi2_tmp, 1113 pu1_pred_v, 1114 pu1_dst_v, 1115 src_strd, 1116 pred_strd, 1117 dst_strd, 1118 zero_cols_v, 1119 zero_rows_v); 1120 } 1121 else /* DC only */ 1122 { 1123 STATS_UPDATE_CODED_TRANS(e_trans_type, c_idx, 1); 1124 ps_codec->apf_itrans_recon_dc[c_idx](pu1_pred_v, pu1_dst_v, 1125 pred_strd, dst_strd, 1126 log2_trans_size, 1127 i2_coeff_value_v); 1128 } 1129 } 1130 } 1131 } 1132 } 1133 1134 /* Neighbor availability inside CTB */ 1135 /* 1bit per 4x4. Indicates whether that 4x4 block has been reconstructed(avialable) */ 1136 /* Used for neighbor availability in intra pred */ 1137 if(c_idx == 0) 1138 { 1139 WORD32 i; 1140 WORD32 trans_in_min_tu; 1141 UWORD32 cur_tu_in_bits; 1142 UWORD32 cur_tu_avail_flag; 1143 1144 trans_in_min_tu = trans_size / MIN_TU_SIZE; 1145 cur_tu_in_bits = (1 << trans_in_min_tu) - 1; 1146 cur_tu_in_bits = cur_tu_in_bits << (32 - trans_in_min_tu); 1147 1148 cur_tu_avail_flag = cur_tu_in_bits >> (ps_tu->b4_pos_x + 1); 1149 1150 for(i = 0; i < trans_in_min_tu; i++) 1151 au4_intra_nbr_avail[1 + ps_tu->b4_pos_y + i] |= 1152 cur_tu_avail_flag; 1153 } 1154 } 1155 } 1156 ps_proc->pv_tu_coeff_data = pu1_tu_coeff_data; 1157 1158 return ps_proc->i4_ctb_tu_cnt; 1159 } 1160 1161
