1/****************************************************************************** 2 * 3 * Copyright (C) 2015 The Android Open Source Project 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 * Originally developed and contributed by Ittiam Systems Pvt. Ltd, Bangalore 19*/ 20/**************************************************************************** */ 21/* */ 22/* File Name : ih264_deblk_edge_filters.c */ 23/* */ 24/* Description : Contains function definitions for deblocking */ 25/* */ 26/* List of Functions : ih264_deblk_luma_vert_bs4() */ 27/* ih264_deblk_luma_horz_bs4() */ 28/* ih264_deblk_luma_vert_bslt4() */ 29/* ih264_deblk_luma_horz_bslt4() */ 30/* ih264_deblk_luma_vert_bs4_mbaff() */ 31/* ih264_deblk_luma_vert_bslt4_mbaff() */ 32/* ih264_deblk_chroma_vert_bs4_bp() */ 33/* ih264_deblk_chroma_horz_bs4_bp() */ 34/* ih264_deblk_chroma_vert_bslt4_bp() */ 35/* ih264_deblk_chroma_horz_bslt4_bp() */ 36/* ih264_deblk_chroma_vert_bs4_mbaff_bp() */ 37/* ih264_deblk_chroma_vert_bslt4_mbaff_bp() */ 38/* ih264_deblk_chroma_vert_bs4() */ 39/* ih264_deblk_chroma_horz_bs4() */ 40/* ih264_deblk_chroma_vert_bslt4() */ 41/* ih264_deblk_chroma_horz_bslt4() */ 42/* ih264_deblk_chroma_vert_bs4_mbaff() */ 43/* ih264_deblk_chroma_vert_bslt4_mbaff() */ 44/* */ 45/* Issues / Problems : None */ 46/* */ 47/* Revision History : */ 48/* */ 49/* DD MM YYYY Author(s) Changes (Describe the changes made) */ 50/* 28 11 2013 Ittiam Draft */ 51/* 29 12 2014 Kaushik Added double-call vertical */ 52/* Senthoor deblocking and high profile */ 53/* deblocking functions */ 54/* */ 55/******************************************************************************/ 56 57/*****************************************************************************/ 58/* File Includes */ 59/*****************************************************************************/ 60 61/* System include files */ 62#include <stdio.h> 63 64/* User include files */ 65#include "ih264_typedefs.h" 66#include "ih264_platform_macros.h" 67#include "ih264_deblk_edge_filters.h" 68#include "ih264_macros.h" 69 70/*****************************************************************************/ 71/* Function Definitions */ 72/*****************************************************************************/ 73 74/*****************************************************************************/ 75/* */ 76/* Function Name : ih264_deblk_luma_vert_bs4() */ 77/* */ 78/* Description : This function performs filtering of a luma block */ 79/* vertical edge when the boundary strength is set to 4. */ 80/* */ 81/* Inputs : pu1_src - pointer to the src sample q0 */ 82/* src_strd - source stride */ 83/* alpha - alpha value for the boundary */ 84/* beta - beta value for the boundary */ 85/* */ 86/* Globals : None */ 87/* */ 88/* Processing : This operation is described in Sec. 8.7.2.4 under the */ 89/* title "Filtering process for edges for bS equal to 4" in */ 90/* ITU T Rec H.264. */ 91/* */ 92/* Outputs : None */ 93/* */ 94/* Returns : None */ 95/* */ 96/* Issues : None */ 97/* */ 98/* Revision History: */ 99/* */ 100/* DD MM YYYY Author(s) Changes (Describe the changes made) */ 101/* 28 11 2013 Ittiam Draft */ 102/* */ 103/*****************************************************************************/ 104void ih264_deblk_luma_vert_bs4(UWORD8 *pu1_src, 105 WORD32 src_strd, 106 WORD32 alpha, 107 WORD32 beta) 108{ 109 UWORD8 p3, p2, p1, p0, q0, q1, q2, q3; 110 WORD32 pos_p3, pos_p2, pos_p1, pos_p0; 111 WORD32 pos_q0, pos_q1, pos_q2,pos_q3; 112 UWORD8 a_p, a_q; /* threshold variables */ 113 WORD32 blk_strd = src_strd << 2; /* block_increment = src_strd * 4 */ 114 UWORD8 *pu1_src_temp; 115 WORD8 i = 0, edge; 116 117 pos_q0 = 0; 118 pos_q1 = 1; 119 pos_q2 = 2; 120 pos_q3 = 3; 121 pos_p0 = -1; 122 pos_p1 = -2; 123 pos_p2 = -3; 124 pos_p3 = -4; 125 126 for(edge = 0; edge < 4; edge++, pu1_src += blk_strd) 127 { 128 pu1_src_temp = pu1_src; 129 for(i = 0; i < 4; ++i, pu1_src_temp += src_strd) 130 { 131 q0 = pu1_src_temp[pos_q0]; 132 q1 = pu1_src_temp[pos_q1]; 133 p0 = pu1_src_temp[pos_p0]; 134 p1 = pu1_src_temp[pos_p1]; 135 136 /* Filter Decision */ 137 if((ABS(p0 - q0) >= alpha) || 138 (ABS(q1 - q0) >= beta) || 139 (ABS(p1 - p0) >= beta)) 140 continue; 141 142 p2 = pu1_src_temp[pos_p2]; 143 p3 = pu1_src_temp[pos_p3]; 144 q2 = pu1_src_temp[pos_q2]; 145 q3 = pu1_src_temp[pos_q3]; 146 147 if(ABS(p0 - q0) < ((alpha >> 2) + 2)) 148 { 149 /* Threshold Variables */ 150 a_p = (UWORD8)ABS(p2 - p0); 151 a_q = (UWORD8)ABS(q2 - q0); 152 153 if(a_p < beta) 154 { 155 /* p0', p1', p2' */ 156 pu1_src_temp[pos_p0] = ((p2 + X2(p1) + X2(p0) + X2(q0) + q1 157 + 4) >> 3); 158 pu1_src_temp[pos_p1] = ((p2 + p1 + p0 + q0 + 2) >> 2); 159 pu1_src_temp[pos_p2] = 160 ((X2(p3) + X3(p2) + p1 + p0 + q0 161 + 4) >> 3); 162 } 163 else 164 { 165 /* p0'*/ 166 pu1_src_temp[pos_p0] = ((X2(p1) + p0 + q1 + 2) >> 2); 167 } 168 169 if(a_q < beta) 170 { 171 /* q0', q1', q2' */ 172 pu1_src_temp[pos_q0] = (p1 + X2(p0) + X2(q0) + X2(q1) + q2 173 + 4) >> 3; 174 pu1_src_temp[pos_q1] = (p0 + q0 + q1 + q2 + 2) >> 2; 175 pu1_src_temp[pos_q2] = (X2(q3) + X3(q2) + q1 + q0 + p0 + 4) 176 >> 3; 177 } 178 else 179 { 180 /* q0'*/ 181 pu1_src_temp[pos_q0] = (X2(q1) + q0 + p1 + 2) >> 2; 182 } 183 } 184 else 185 { 186 /* p0', q0'*/ 187 pu1_src_temp[pos_p0] = ((X2(p1) + p0 + q1 + 2) >> 2); 188 pu1_src_temp[pos_q0] = (X2(q1) + q0 + p1 + 2) >> 2; 189 } 190 } 191 } 192} 193 194/*****************************************************************************/ 195/* */ 196/* Function Name : ih264_deblk_luma_horz_bs4() */ 197/* */ 198/* Description : This function performs filtering of a luma block */ 199/* horizontal edge when the boundary strength is set to 4. */ 200/* */ 201/* Inputs : pu1_src - pointer to the src sample q0 */ 202/* src_strd - source stride */ 203/* alpha - alpha value for the boundary */ 204/* beta - beta value for the boundary */ 205/* */ 206/* Globals : None */ 207/* */ 208/* Processing : This operation is described in Sec. 8.7.2.4 under the */ 209/* title "Filtering process for edges for bS equal to 4" in */ 210/* ITU T Rec H.264. */ 211/* */ 212/* Outputs : None */ 213/* */ 214/* Returns : None */ 215/* */ 216/* Issues : None */ 217/* */ 218/* Revision History: */ 219/* */ 220/* DD MM YYYY Author(s) Changes (Describe the changes made) */ 221/* 28 11 2013 Ittiam Draft */ 222/* */ 223/*****************************************************************************/ 224void ih264_deblk_luma_horz_bs4(UWORD8 *pu1_src, 225 WORD32 src_strd, 226 WORD32 alpha, 227 WORD32 beta) 228{ 229 UWORD8 p3, p2, p1, p0, q0, q1, q2, q3; 230 WORD32 pos_p3, pos_p2, pos_p1, pos_p0, pos_q0, pos_q1, 231 pos_q2, pos_q3; 232 UWORD8 a_p, a_q; /* threshold variables */ 233 UWORD8 *pu1_p3; /* pointer to the src sample p3 */ 234 UWORD8 *pu1_p3_temp; 235 UWORD8 *pu1_src_temp; 236 WORD8 i = 0, edge; 237 238 pu1_p3 = pu1_src - (src_strd << 2); 239 pos_q0 = 0; 240 pos_q1 = src_strd; 241 pos_q2 = X2(src_strd); 242 pos_q3 = X3(src_strd); 243 pos_p0 = X3(src_strd); 244 pos_p1 = X2(src_strd); 245 pos_p2 = src_strd; 246 pos_p3 = 0; 247 248 for(edge = 0; edge < 4; edge++, pu1_src += 4, pu1_p3 += 4) 249 { 250 pu1_src_temp = pu1_src; 251 pu1_p3_temp = pu1_p3; 252 for(i = 0; i < 4; ++i, pu1_src_temp++, pu1_p3_temp++) 253 { 254 q0 = pu1_src_temp[pos_q0]; 255 q1 = pu1_src_temp[pos_q1]; 256 p0 = pu1_p3_temp[pos_p0]; 257 p1 = pu1_p3_temp[pos_p1]; 258 259 /* Filter Decision */ 260 if((ABS(p0 - q0) >= alpha) || 261 (ABS(q1 - q0) >= beta) || 262 (ABS(p1 - p0) >= beta)) 263 continue; 264 265 p2 = pu1_p3_temp[pos_p2]; 266 p3 = pu1_p3_temp[pos_p3]; 267 q2 = pu1_src_temp[pos_q2]; 268 q3 = pu1_src_temp[pos_q3]; 269 270 if(ABS(p0 - q0) < ((alpha >> 2) + 2)) 271 { 272 /* Threshold Variables */ 273 a_p = ABS(p2 - p0); 274 a_q = ABS(q2 - q0); 275 276 if((a_p < beta)) 277 { 278 /* p0', p1', p2' */ 279 pu1_p3_temp[pos_p0] = (p2 + X2(p1) + X2(p0) + X2(q0) + q1 280 + 4) >> 3; 281 pu1_p3_temp[pos_p1] = (p2 + p1 + p0 + q0 + 2) >> 2; 282 pu1_p3_temp[pos_p2] = 283 (X2(p3) + X3(p2) + p1 + p0 + q0 284 + 4) >> 3; 285 } 286 else 287 { 288 /* p0'*/ 289 pu1_p3_temp[pos_p0] = (X2(p1) + p0 + q1 + 2) >> 2; 290 } 291 292 if(a_q < beta) 293 { 294 /* q0', q1', q2' */ 295 pu1_src_temp[pos_q0] = (p1 + X2(p0) + X2(q0) + X2(q1) 296 + q2 + 4) >> 3; 297 pu1_src_temp[pos_q1] = (p0 + q0 + q1 + q2 + 2) >> 2; 298 pu1_src_temp[pos_q2] = (X2(q3) + X3(q2) + q1 + q0 + p0 299 + 4) >> 3; 300 } 301 else 302 { 303 /* q0'*/ 304 pu1_src_temp[pos_q0] = (X2(q1) + q0 + p1 + 2) >> 2; 305 } 306 } 307 else 308 { 309 /* p0', q0'*/ 310 pu1_p3_temp[pos_p0] = (X2(p1) + p0 + q1 + 2) >> 2; 311 pu1_src_temp[pos_q0] = (X2(q1) + q0 + p1 + 2) >> 2; 312 } 313 } 314 } 315} 316 317/*****************************************************************************/ 318/* */ 319/* Function Name : ih264_deblk_chroma_vert_bs4_bp() */ 320/* */ 321/* Description : This function performs filtering of a chroma block */ 322/* vertical edge when the boundary strength is set to 4. */ 323/* */ 324/* Inputs : pu1_src - pointer to the src sample q0 of U */ 325/* src_strd - source stride */ 326/* alpha - alpha value for the boundary */ 327/* beta - beta value for the boundary */ 328/* */ 329/* Globals : None */ 330/* */ 331/* Processing : This operation is described in Sec. 8.7.2.4 under the */ 332/* title "Filtering process for edges for bS equal to 4" in */ 333/* ITU T Rec H.264. */ 334/* */ 335/* Outputs : None */ 336/* */ 337/* Returns : None */ 338/* */ 339/* Issues : None */ 340/* */ 341/* Revision History: */ 342/* */ 343/* DD MM YYYY Author(s) Changes (Describe the changes made) */ 344/* 28 11 2013 Ittiam Draft */ 345/* */ 346/*****************************************************************************/ 347void ih264_deblk_chroma_vert_bs4_bp(UWORD8 *pu1_src, 348 WORD32 src_strd, 349 WORD32 alpha, 350 WORD32 beta) 351{ 352 UWORD8 *pu1_src_u = pu1_src; /* pointer to the src sample q0 of U */ 353 UWORD8 *pu1_src_v = pu1_src + 1; /* pointer to the src sample q0 of V */ 354 UWORD8 p1_u, p0_u, q0_u, q1_u, p1_v, p0_v, q0_v, q1_v; 355 WORD32 blk_strd = src_strd << 1; /* block_increment = src_strd * 2 */ 356 WORD32 pos_p1, pos_p0, pos_q0, pos_q1; 357 UWORD8 *pu1_src_temp_u, *pu1_src_temp_v; 358 WORD8 i = 0, edge; 359 360 pos_q0 = 0; 361 pos_q1 = 2; 362 pos_p0 = -2; 363 pos_p1 = -4; 364 365 for(edge = 0; edge < 4; 366 edge++, pu1_src_u += blk_strd, pu1_src_v += blk_strd) 367 { 368 pu1_src_temp_u = pu1_src_u; 369 pu1_src_temp_v = pu1_src_v; 370 for(i = 0; i < 2; ++i, pu1_src_temp_u += src_strd, pu1_src_temp_v += 371 src_strd) 372 { 373 q0_u = pu1_src_temp_u[pos_q0]; 374 q1_u = pu1_src_temp_u[pos_q1]; 375 p0_u = pu1_src_temp_u[pos_p0]; 376 p1_u = pu1_src_temp_u[pos_p1]; 377 q0_v = pu1_src_temp_v[pos_q0]; 378 q1_v = pu1_src_temp_v[pos_q1]; 379 p0_v = pu1_src_temp_v[pos_p0]; 380 p1_v = pu1_src_temp_v[pos_p1]; 381 382 /* Filter Decision */ 383 if((ABS(p0_u - q0_u) < alpha) && 384 (ABS(q1_u - q0_u) < beta) && 385 (ABS(p1_u - p0_u) < beta)) 386 { 387 /* p0' */ 388 pu1_src_temp_u[pos_p0] = ((X2(p1_u) + p0_u + q1_u + 2) >> 2); 389 /* q0' */ 390 pu1_src_temp_u[pos_q0] = (X2(q1_u) + q0_u + p1_u + 2) >> 2; 391 } 392 393 /* Filter Decision */ 394 if((ABS(p0_v - q0_v) < alpha) && 395 (ABS(q1_v - q0_v) < beta) && 396 (ABS(p1_v - p0_v) < beta)) 397 { 398 /* p0' */ 399 pu1_src_temp_v[pos_p0] = ((X2(p1_v) + p0_v + q1_v + 2) >> 2); 400 /* q0' */ 401 pu1_src_temp_v[pos_q0] = (X2(q1_v) + q0_v + p1_v + 2) >> 2; 402 } 403 } 404 } 405} 406 407/*****************************************************************************/ 408/* */ 409/* Function Name : ih264_deblk_chroma_horz_bs4_bp() */ 410/* */ 411/* Description : This function performs filtering of a chroma block */ 412/* horizontal edge when the boundary strength is set to 4. */ 413/* */ 414/* Inputs : pu1_src - pointer to the src sample q0 of U */ 415/* src_strd - source stride */ 416/* alpha - alpha value for the boundary */ 417/* beta - beta value for the boundary */ 418/* */ 419/* Globals : None */ 420/* */ 421/* Processing : This operation is described in Sec. 8.7.2.4 under the */ 422/* title "Filtering process for edges for bS equal to 4" in */ 423/* ITU T Rec H.264. */ 424/* */ 425/* Outputs : None */ 426/* */ 427/* Returns : None */ 428/* */ 429/* Issues : None */ 430/* */ 431/* Revision History: */ 432/* */ 433/* DD MM YYYY Author(s) Changes (Describe the changes made) */ 434/* 28 11 2013 Ittiam Draft */ 435/* */ 436/*****************************************************************************/ 437void ih264_deblk_chroma_horz_bs4_bp(UWORD8 *pu1_src, 438 WORD32 src_strd, 439 WORD32 alpha, 440 WORD32 beta) 441{ 442 UWORD8 *pu1_src_u = pu1_src; /* pointer to the src sample q0 of U */ 443 UWORD8 *pu1_src_v = pu1_src + 1; /* pointer to the src sample q0 of V */ 444 UWORD8 p1_u, p0_u, q0_u, q1_u, p1_v, p0_v, q0_v, q1_v; 445 WORD32 pos_p1, pos_p0, pos_q0, pos_q1; 446 UWORD8 *pu1_src_temp_u, *pu1_src_temp_v; 447 UWORD8 *pu1_p1_u; /* pointer to the src sample p1 of U */ 448 UWORD8 *pu1_p1_v; /* pointer to the src sample p1 of U */ 449 UWORD8 *pu1_p1_temp_u, *pu1_p1_temp_v; 450 WORD8 i = 0, edge; 451 452 pu1_p1_u = pu1_src_u - (src_strd << 1); 453 pu1_p1_v = pu1_src_v - (src_strd << 1); 454 pos_q0 = 0; 455 pos_q1 = src_strd; 456 pos_p0 = src_strd; 457 pos_p1 = 0; 458 459 for(edge = 0; edge < 4; edge++, pu1_src_u += 4, pu1_p1_u += 4, 460 pu1_src_v += 4, pu1_p1_v += 4) 461 { 462 pu1_src_temp_u = pu1_src_u; 463 pu1_p1_temp_u = pu1_p1_u; 464 pu1_src_temp_v = pu1_src_v; 465 pu1_p1_temp_v = pu1_p1_v; 466 for(i = 0; i < 2; ++i, pu1_src_temp_u += 2, pu1_p1_temp_u += 2, 467 pu1_src_temp_v += 2, pu1_p1_temp_v += 2) 468 { 469 q0_u = pu1_src_temp_u[pos_q0]; 470 q1_u = pu1_src_temp_u[pos_q1]; 471 p0_u = pu1_p1_temp_u[pos_p0]; 472 p1_u = pu1_p1_temp_u[pos_p1]; 473 474 q0_v = pu1_src_temp_v[pos_q0]; 475 q1_v = pu1_src_temp_v[pos_q1]; 476 p0_v = pu1_p1_temp_v[pos_p0]; 477 p1_v = pu1_p1_temp_v[pos_p1]; 478 479 /* Filter Decision */ 480 if((ABS(p0_u - q0_u) < alpha) && 481 (ABS(q1_u - q0_u) < beta) && 482 (ABS(p1_u - p0_u) < beta)) 483 { 484 /* p0' */ 485 pu1_p1_temp_u[pos_p0] = (X2(p1_u) + p0_u + q1_u + 2) >> 2; 486 /* q0' */ 487 pu1_src_temp_u[pos_q0] = (X2(q1_u) + q0_u + p1_u + 2) >> 2; 488 } 489 490 /* Filter Decision */ 491 if((ABS(p0_v - q0_v) < alpha) && 492 (ABS(q1_v - q0_v) < beta) && 493 (ABS(p1_v - p0_v) < beta)) 494 { 495 /* p0' */ 496 pu1_p1_temp_v[pos_p0] = (X2(p1_v) + p0_v + q1_v + 2) >> 2; 497 /* q0' */ 498 pu1_src_temp_v[pos_q0] = (X2(q1_v) + q0_v + p1_v + 2) >> 2; 499 } 500 } 501 } 502} 503 504/*****************************************************************************/ 505/* */ 506/* Function Name : ih264_deblk_luma_vert_bslt4() */ 507/* */ 508/* Description : This function performs filtering of a luma block */ 509/* vertical edge when the boundary strength is less than 4. */ 510/* */ 511/* Inputs : pu1_src - pointer to the src sample q0 */ 512/* src_strd - source stride */ 513/* alpha - alpha value for the boundary */ 514/* beta - beta value for the boundary */ 515/* u4_bs - packed Boundary strength array */ 516/* pu1_cliptab - tc0_table */ 517/* */ 518/* Globals : None */ 519/* */ 520/* Processing : This operation is described in Sec. 8.7.2.3 under the */ 521/* title "Filtering process for edges for bS less than 4" */ 522/* in ITU T Rec H.264. */ 523/* */ 524/* Outputs : None */ 525/* */ 526/* Returns : None */ 527/* */ 528/* Issues : None */ 529/* */ 530/* Revision History: */ 531/* */ 532/* DD MM YYYY Author(s) Changes (Describe the changes made) */ 533/* 28 11 2013 Ittiam Draft */ 534/* */ 535/*****************************************************************************/ 536void ih264_deblk_luma_vert_bslt4(UWORD8 *pu1_src, 537 WORD32 src_strd, 538 WORD32 alpha, 539 WORD32 beta, 540 UWORD32 u4_bs, 541 const UWORD8 *pu1_cliptab) 542{ 543 WORD8 i = 0, edge; 544 UWORD8 p2, p1, p0, q0, q1, q2; 545 WORD32 pos_p2, pos_p1, pos_p0, pos_q0, pos_q1, pos_q2; 546 UWORD8 a_p, a_q; /* threshold variables */ 547 WORD32 blk_strd = src_strd << 2; /* block_increment = src_strd * 4 */ 548 UWORD8 *pu1_src_temp; 549 WORD8 delta; 550 WORD8 tc; 551 WORD16 val; 552 UWORD8 tc0, u1_bs; 553 554 pos_q0 = 0; 555 pos_q1 = 1; 556 pos_q2 = 2; 557 pos_p0 = -1; 558 pos_p1 = -2; 559 pos_p2 = -3; 560 561 for(edge = 0; edge < 4; edge++, pu1_src += blk_strd) 562 { 563 pu1_src_temp = pu1_src; 564 /* Filter Decision */ 565 u1_bs = (UWORD8)((u4_bs >> ((3 - edge) << 3)) & 0x0ff); 566 if(!u1_bs) 567 continue; 568 /* tc0 */ 569 tc0 = pu1_cliptab[u1_bs]; 570 for(i = 0; i < 4; ++i, pu1_src_temp += src_strd) 571 { 572 q0 = pu1_src_temp[pos_q0]; 573 q1 = pu1_src_temp[pos_q1]; 574 p0 = pu1_src_temp[pos_p0]; 575 p1 = pu1_src_temp[pos_p1]; 576 577 /* Filter Decision */ 578 if((ABS(p0 - q0) >= alpha) || 579 (ABS(q1 - q0) >= beta) || 580 (ABS(p1 - p0) >= beta)) 581 continue; 582 583 q2 = pu1_src_temp[pos_q2]; 584 p2 = pu1_src_temp[pos_p2]; 585 586 a_p = ABS(p2 - p0); 587 a_q = ABS(q2 - q0); 588 589 /* tc */ 590 tc = tc0 + (a_p < beta) + (a_q < beta); 591 592 val = ((((q0 - p0) << 2) + (p1 - q1) + 4) >> 3); 593 delta = CLIP3(-tc, tc, val); 594 595 /* p0' */ 596 val = p0 + delta; 597 pu1_src_temp[pos_p0] = CLIP_U8(val); 598 /* q0' */ 599 val = q0 - delta; 600 pu1_src_temp[pos_q0] = CLIP_U8(val); 601 602 /* Luma only */ 603 if(a_p < beta) 604 { 605 /* p1' */ 606 val = ((p2 + ((p0 + q0 + 1) >> 1) - (p1 << 1)) >> 1); 607 pu1_src_temp[pos_p1] += CLIP3(-tc0, tc0, val); 608 } 609 610 if(a_q < beta) 611 { 612 /* q1' */ 613 val = ((q2 + ((p0 + q0 + 1) >> 1) - (q1 << 1)) >> 1); 614 pu1_src_temp[pos_q1] += CLIP3(-tc0, tc0, val); 615 } 616 } 617 } 618} 619 620/*****************************************************************************/ 621/* */ 622/* Function Name : ih264_deblk_chroma_vert_bslt4_bp() */ 623/* */ 624/* Description : This function performs filtering of a chroma block */ 625/* vertical edge when the boundary strength is less than 4. */ 626/* */ 627/* Inputs : pu1_src - pointer to the src sample q0 of U */ 628/* src_strd - source stride */ 629/* alpha - alpha value for the boundary */ 630/* beta - beta value for the boundary */ 631/* u4_bs - packed Boundary strength array */ 632/* pu1_cliptab - tc0_table */ 633/* */ 634/* Globals : None */ 635/* */ 636/* Processing : This operation is described in Sec. 8.7.2.3 under the */ 637/* title "Filtering process for edges for bS less than 4" */ 638/* in ITU T Rec H.264. */ 639/* */ 640/* Outputs : None */ 641/* */ 642/* Returns : None */ 643/* */ 644/* Issues : None */ 645/* */ 646/* Revision History: */ 647/* */ 648/* DD MM YYYY Author(s) Changes (Describe the changes made) */ 649/* 28 11 2013 Ittiam Draft */ 650/* */ 651/*****************************************************************************/ 652void ih264_deblk_chroma_vert_bslt4_bp(UWORD8 *pu1_src, 653 WORD32 src_strd, 654 WORD32 alpha, 655 WORD32 beta, 656 UWORD32 u4_bs, 657 const UWORD8 *pu1_cliptab) 658{ 659 UWORD8 *pu1_src_u = pu1_src; /* Pointer to the src sample q0 of plane U*/ 660 UWORD8 *pu1_src_v = pu1_src + 1; /* Pointer to the src sample q0 of plane V*/ 661 UWORD8 p1_u, p0_u, q0_u, q1_u, p1_v, p0_v, q0_v, q1_v; 662 WORD32 blk_strd = src_strd << 1; /* block_increment = src_strd * (4 >> 1)*/ 663 WORD32 pos_p1, pos_p0, pos_q0, pos_q1; 664 UWORD8 *pu1_src_temp_u, *pu1_src_temp_v; 665 WORD8 i = 0, edge; 666 WORD8 delta; 667 WORD8 tc; 668 WORD16 val; 669 UWORD8 tc0, u1_bs; 670 671 pos_q0 = 0; 672 pos_q1 = 2; 673 pos_p0 = -2; 674 pos_p1 = -4; 675 676 for(edge = 0; edge < 4; 677 edge++, pu1_src_u += blk_strd, pu1_src_v += blk_strd) 678 { 679 pu1_src_temp_u = pu1_src_u; 680 pu1_src_temp_v = pu1_src_v; 681 /* Filter Decision */ 682 u1_bs = (UWORD8)((u4_bs >> ((3 - edge) << 3)) & 0x0ff); 683 if(!u1_bs) 684 continue; 685 /* tc0 */ 686 tc0 = pu1_cliptab[u1_bs]; 687 tc = tc0 + 1; 688 for(i = 0; i < 2; ++i, pu1_src_temp_u += src_strd, pu1_src_temp_v += 689 src_strd) 690 { 691 q0_u = pu1_src_temp_u[pos_q0]; 692 q1_u = pu1_src_temp_u[pos_q1]; 693 p0_u = pu1_src_temp_u[pos_p0]; 694 p1_u = pu1_src_temp_u[pos_p1]; 695 696 q0_v = pu1_src_temp_v[pos_q0]; 697 q1_v = pu1_src_temp_v[pos_q1]; 698 p0_v = pu1_src_temp_v[pos_p0]; 699 p1_v = pu1_src_temp_v[pos_p1]; 700 701 /* Filter Decision */ 702 if((ABS(p0_u - q0_u) < alpha) && 703 (ABS(q1_u - q0_u) < beta) && 704 (ABS(p1_u - p0_u) < beta)) 705 { 706 val = ((((q0_u - p0_u) << 2) + (p1_u - q1_u) + 4) >> 3); 707 delta = CLIP3(-tc, tc, val); 708 /* p0' */ 709 val = p0_u + delta; 710 pu1_src_temp_u[pos_p0] = CLIP_U8(val); 711 /* q0' */ 712 val = q0_u - delta; 713 pu1_src_temp_u[pos_q0] = CLIP_U8(val); 714 } 715 716 /* Filter Decision */ 717 if((ABS(p0_v - q0_v) < alpha) && 718 (ABS(q1_v - q0_v) < beta) && 719 (ABS(p1_v - p0_v) < beta)) 720 { 721 val = ((((q0_v - p0_v) << 2) + (p1_v - q1_v) + 4) >> 3); 722 delta = CLIP3(-tc, tc, val); 723 /* p0' */ 724 val = p0_v + delta; 725 pu1_src_temp_v[pos_p0] = CLIP_U8(val); 726 /* q0' */ 727 val = q0_v - delta; 728 pu1_src_temp_v[pos_q0] = CLIP_U8(val); 729 } 730 } 731 } 732} 733 734/*****************************************************************************/ 735/* */ 736/* Function Name : ih264_deblk_luma_horz_bslt4() */ 737/* */ 738/* Description : This function performs filtering of a luma block */ 739/* horizontal edge when boundary strength is less than 4. */ 740/* */ 741/* Inputs : pu1_src - pointer to the src sample q0 */ 742/* src_strd - source stride */ 743/* alpha - alpha value for the boundary */ 744/* beta - beta value for the boundary */ 745/* u4_bs - packed Boundary strength array */ 746/* pu1_cliptab - tc0_table */ 747/* */ 748/* Globals : None */ 749/* */ 750/* Processing : This operation is described in Sec. 8.7.2.3 under the */ 751/* title "Filtering process for edges for bS less than 4" */ 752/* in ITU T Rec H.264. */ 753/* */ 754/* Outputs : None */ 755/* */ 756/* Returns : None */ 757/* */ 758/* Issues : None */ 759/* */ 760/* Revision History: */ 761/* */ 762/* DD MM YYYY Author(s) Changes (Describe the changes made) */ 763/* 28 11 2013 Ittiam Draft */ 764/* */ 765/*****************************************************************************/ 766void ih264_deblk_luma_horz_bslt4(UWORD8 *pu1_src, 767 WORD32 src_strd, 768 WORD32 alpha, 769 WORD32 beta, 770 UWORD32 u4_bs, 771 const UWORD8 *pu1_cliptab) 772{ 773 UWORD8 p2, p1, p0, q0, q1, q2; 774 WORD32 pos_p2, pos_p1, pos_p0, pos_q0, pos_q1, pos_q2; 775 UWORD8 a_p, a_q; /* Threshold variables */ 776 UWORD8 *pu1_p2; /* Pointer to the src sample p2 */ 777 UWORD8 *pu1_p2_temp; 778 UWORD8 *pu1_src_temp; 779 WORD8 i = 0, edge; 780 WORD8 delta; 781 WORD8 tc; 782 WORD16 val; 783 UWORD8 tc0, u1_bs; 784 785 pu1_p2 = pu1_src - (src_strd << 2); 786 pos_q0 = 0; 787 pos_q1 = src_strd; 788 pos_q2 = X2(src_strd); 789 pos_p0 = X3(src_strd); 790 pos_p1 = X2(src_strd); 791 pos_p2 = src_strd; 792 793 for(edge = 0; edge < 4; edge++, pu1_src += 4, pu1_p2 += 4) 794 { 795 pu1_src_temp = pu1_src; 796 pu1_p2_temp = pu1_p2; 797 798 /* Filter Decision */ 799 u1_bs = (UWORD8)((u4_bs >> ((3 - edge) << 3)) & 0x0ff); 800 if(!u1_bs) 801 continue; 802 /* tc0 */ 803 tc0 = pu1_cliptab[u1_bs]; 804 805 for(i = 0; i < 4; ++i, pu1_src_temp++, pu1_p2_temp++) 806 { 807 q0 = pu1_src_temp[pos_q0]; 808 q1 = pu1_src_temp[pos_q1]; 809 p0 = pu1_p2_temp[pos_p0]; 810 p1 = pu1_p2_temp[pos_p1]; 811 812 /* Filter Decision */ 813 if((ABS(p0 - q0) >= alpha) || 814 (ABS(q1 - q0) >= beta) || 815 (ABS(p1 - p0) >= beta)) 816 continue; 817 818 q2 = pu1_src_temp[pos_q2]; 819 p2 = pu1_p2_temp[pos_p2]; 820 821 a_p = ABS(p2 - p0); 822 a_q = ABS(q2 - q0); 823 824 /* tc */ 825 tc = tc0 + (a_p < beta) + (a_q < beta); 826 val = ((((q0 - p0) << 2) + (p1 - q1) + 4) >> 3); 827 delta = CLIP3(-tc, tc, val); 828 /* p0' */ 829 val = p0 + delta; 830 pu1_p2_temp[pos_p0] = CLIP_U8(val); 831 /* q0' */ 832 val = q0 - delta; 833 pu1_src_temp[pos_q0] = CLIP_U8(val); 834 835 /* Luma */ 836 if(a_p < beta) 837 { 838 /* p1' */ 839 val = ((p2 + ((p0 + q0 + 1) >> 1) - (p1 << 1)) >> 1); 840 pu1_p2_temp[pos_p1] += CLIP3(-tc0, tc0, val); 841 } 842 843 if(a_q < beta) 844 { 845 /* q1' */ 846 val = ((q2 + ((p0 + q0 + 1) >> 1) - (q1 << 1)) >> 1); 847 pu1_src_temp[pos_q1] += CLIP3(-tc0, tc0, val); 848 } 849 } 850 } 851} 852 853/*****************************************************************************/ 854/* */ 855/* Function Name : ih264_deblk_chroma_horz_bslt4_bp() */ 856/* */ 857/* Description : This function performs filtering of a chroma block */ 858/* horizontal edge when boundary strength is less than 4. */ 859/* */ 860/* Inputs : pu1_src - pointer to the src sample q0 of U */ 861/* src_strd - source stride */ 862/* alpha - alpha value for the boundary */ 863/* beta - beta value for the boundary */ 864/* u4_bs - packed Boundary strength array */ 865/* pu1_cliptab - tc0_table */ 866/* */ 867/* Globals : None */ 868/* */ 869/* Processing : This operation is described in Sec. 8.7.2.3 under the */ 870/* title "Filtering process for edges for bS less than 4" */ 871/* in ITU T Rec H.264. */ 872/* */ 873/* Outputs : None */ 874/* */ 875/* Returns : None */ 876/* */ 877/* Issues : None */ 878/* */ 879/* Revision History: */ 880/* */ 881/* DD MM YYYY Author(s) Changes (Describe the changes made) */ 882/* 28 11 2013 Ittiam Draft */ 883/* */ 884/*****************************************************************************/ 885void ih264_deblk_chroma_horz_bslt4_bp(UWORD8 *pu1_src, 886 WORD32 src_strd, 887 WORD32 alpha, 888 WORD32 beta, 889 UWORD32 u4_bs, 890 const UWORD8 *pu1_cliptab) 891{ 892 UWORD8 *pu1_src_u = pu1_src; /* Pointer to the src sample q0 of plane U*/ 893 UWORD8 *pu1_src_v = pu1_src + 1; /* Pointer to the src sample q0 of plane V*/ 894 UWORD8 p1_u, p0_u, q0_u, q1_u, p1_v, p0_v, q0_v, q1_v; 895 WORD32 pos_p1, pos_p0, pos_q0, pos_q1; 896 UWORD8 *pu1_src_temp_u, *pu1_src_temp_v; 897 UWORD8 *pu1_p1_u; /* Pointer to the src sample p1 of plane U*/ 898 UWORD8 *pu1_p1_v; /* Pointer to the src sample p1 of plane V*/ 899 UWORD8 *pu1_p1_temp_u, *pu1_p1_temp_v; 900 WORD8 i = 0, edge; 901 WORD8 delta; 902 WORD8 tc; 903 WORD16 val; 904 UWORD8 u1_bs; 905 UWORD8 tc0; 906 907 pu1_p1_u = pu1_src_u - (src_strd << 1); 908 pu1_p1_v = pu1_src_v - (src_strd << 1); 909 pos_q0 = 0; 910 pos_q1 = src_strd; 911 pos_p0 = src_strd; 912 pos_p1 = 0; 913 914 for(edge = 0; edge < 4; edge++, pu1_src_u += 4, pu1_p1_u += 4, 915 pu1_src_v += 4, pu1_p1_v += 4) 916 { 917 pu1_src_temp_u = pu1_src_u; 918 pu1_p1_temp_u = pu1_p1_u; 919 pu1_src_temp_v = pu1_src_v; 920 pu1_p1_temp_v = pu1_p1_v; 921 922 /* Filter Decision */ 923 u1_bs = (UWORD8)((u4_bs >> ((3 - edge) << 3)) & 0x0ff); 924 if(!u1_bs) 925 continue; 926 /* tc0 */ 927 tc0 = pu1_cliptab[u1_bs]; 928 929 for(i = 0; i < 2; ++i, pu1_src_temp_u += 2, pu1_p1_temp_u += 2, 930 pu1_src_temp_v += 2, pu1_p1_temp_v += 2) 931 { 932 q0_u = pu1_src_temp_u[pos_q0]; 933 q1_u = pu1_src_temp_u[pos_q1]; 934 p0_u = pu1_p1_temp_u[pos_p0]; 935 p1_u = pu1_p1_temp_u[pos_p1]; 936 937 q0_v = pu1_src_temp_v[pos_q0]; 938 q1_v = pu1_src_temp_v[pos_q1]; 939 p0_v = pu1_p1_temp_v[pos_p0]; 940 p1_v = pu1_p1_temp_v[pos_p1]; 941 942 /* tc */ 943 tc = tc0 + 1; 944 /* Filter Decision */ 945 if(ABS(p0_u - q0_u) < alpha && ABS(q1_u - q0_u) < beta 946 && ABS(p1_u - p0_u) < beta) 947 { 948 val = ((((q0_u - p0_u) << 2) + (p1_u - q1_u) + 4) >> 3); 949 delta = CLIP3(-tc, tc, val); 950 /* p0' */ 951 val = p0_u + delta; 952 pu1_p1_temp_u[pos_p0] = CLIP_U8(val); 953 /* q0' */ 954 val = q0_u - delta; 955 pu1_src_temp_u[pos_q0] = CLIP_U8(val); 956 } 957 /* Filter Decision */ 958 if(ABS(p0_v - q0_v) < alpha && ABS(q1_v - q0_v) < beta 959 && ABS(p1_v - p0_v) < beta) 960 { 961 val = ((((q0_v - p0_v) << 2) + (p1_v - q1_v) + 4) >> 3); 962 delta = CLIP3(-tc, tc, val); 963 /* p0' */ 964 val = p0_v + delta; 965 pu1_p1_temp_v[pos_p0] = CLIP_U8(val); 966 /* q0' */ 967 val = q0_v - delta; 968 pu1_src_temp_v[pos_q0] = CLIP_U8(val); 969 } 970 } 971 } 972} 973 974/*****************************************************************************/ 975/* Function Definitions for vertical edge deblocking for double-call */ 976/*****************************************************************************/ 977 978/*****************************************************************************/ 979/* */ 980/* Function Name : ih264_deblk_luma_vert_bs4_mbaff() */ 981/* */ 982/* Description : This function performs filtering of a luma block */ 983/* vertical edge when boundary strength is set to 4. */ 984/* */ 985/* Inputs : pu1_src - pointer to the src sample q0 */ 986/* src_strd - source stride */ 987/* alpha - alpha value for the boundary */ 988/* beta - beta value for the boundary */ 989/* */ 990/* Globals : None */ 991/* */ 992/* Processing : When the function is called twice, this operation is as */ 993/* described in Sec. 8.7.2.3 under the title "Filtering */ 994/* process for edges for bS equal to 4" in ITU T Rec H.264. */ 995/* */ 996/* Outputs : None */ 997/* */ 998/* Returns : None */ 999/* */ 1000/* Issues : None */ 1001/* */ 1002/* Revision History: */ 1003/* */ 1004/* DD MM YYYY Author(s) Changes (Describe the changes made) */ 1005/* 29 12 2014 Kaushik Draft */ 1006/* Senthoor */ 1007/* */ 1008/*****************************************************************************/ 1009void ih264_deblk_luma_vert_bs4_mbaff(UWORD8 *pu1_src, 1010 WORD32 src_strd, 1011 WORD32 alpha, 1012 WORD32 beta) 1013{ 1014 UWORD8 p3, p2, p1, p0, q0, q1, q2, q3; 1015 WORD32 pos_p3, pos_p2, pos_p1, pos_p0; 1016 WORD32 pos_q0, pos_q1, pos_q2, pos_q3; 1017 UWORD8 a_p, a_q; /* threshold variables */ 1018 WORD32 blk_strd = src_strd << 1; /* block_increment = src_strd * 2 */ 1019 UWORD8 *pu1_src_temp; 1020 WORD8 i = 0, edge; 1021 1022 pos_q0 = 0; 1023 pos_q1 = 1; 1024 pos_q2 = 2; 1025 pos_q3 = 3; 1026 pos_p0 = -1; 1027 pos_p1 = -2; 1028 pos_p2 = -3; 1029 pos_p3 = -4; 1030 1031 for(edge = 0; edge < 4; edge++, pu1_src += blk_strd) 1032 { 1033 pu1_src_temp = pu1_src; 1034 for(i = 0; i < 2; ++i, pu1_src_temp += src_strd) 1035 { 1036 q0 = pu1_src_temp[pos_q0]; 1037 q1 = pu1_src_temp[pos_q1]; 1038 p0 = pu1_src_temp[pos_p0]; 1039 p1 = pu1_src_temp[pos_p1]; 1040 1041 /* Filter Decision */ 1042 if((ABS(p0 - q0) >= alpha) || 1043 (ABS(q1 - q0) >= beta) || 1044 (ABS(p1 - p0) >= beta)) 1045 continue; 1046 1047 p2 = pu1_src_temp[pos_p2]; 1048 p3 = pu1_src_temp[pos_p3]; 1049 q2 = pu1_src_temp[pos_q2]; 1050 q3 = pu1_src_temp[pos_q3]; 1051 1052 if(ABS(p0 - q0) < ((alpha >> 2) + 2)) 1053 { 1054 /* Threshold Variables */ 1055 a_p = (UWORD8)ABS(p2 - p0); 1056 a_q = (UWORD8)ABS(q2 - q0); 1057 1058 if(a_p < beta) 1059 { 1060 /* p0', p1', p2' */ 1061 pu1_src_temp[pos_p0] = ((p2 + X2(p1) + X2(p0) + X2(q0) + q1 1062 + 4) >> 3); 1063 pu1_src_temp[pos_p1] = ((p2 + p1 + p0 + q0 + 2) >> 2); 1064 pu1_src_temp[pos_p2] = 1065 ((X2(p3) + X3(p2) + p1 + p0 + q0 1066 + 4) >> 3); 1067 } 1068 else 1069 { 1070 /* p0'*/ 1071 pu1_src_temp[pos_p0] = ((X2(p1) + p0 + q1 + 2) >> 2); 1072 } 1073 1074 if(a_q < beta) 1075 { 1076 /* q0', q1', q2' */ 1077 pu1_src_temp[pos_q0] = (p1 + X2(p0) + X2(q0) + X2(q1) + q2 1078 + 4) >> 3; 1079 pu1_src_temp[pos_q1] = (p0 + q0 + q1 + q2 + 2) >> 2; 1080 pu1_src_temp[pos_q2] = (X2(q3) + X3(q2) + q1 + q0 + p0 + 4) 1081 >> 3; 1082 } 1083 else 1084 { 1085 /* q0'*/ 1086 pu1_src_temp[pos_q0] = (X2(q1) + q0 + p1 + 2) >> 2; 1087 } 1088 } 1089 else 1090 { 1091 /* p0', q0'*/ 1092 pu1_src_temp[pos_p0] = ((X2(p1) + p0 + q1 + 2) >> 2); 1093 pu1_src_temp[pos_q0] = (X2(q1) + q0 + p1 + 2) >> 2; 1094 } 1095 } 1096 } 1097} 1098 1099/*****************************************************************************/ 1100/* */ 1101/* Function Name : ih264_deblk_chroma_vert_bs4_mbaff_bp() */ 1102/* */ 1103/* Description : This function performs filtering of a chroma block */ 1104/* vertical edge when boundary strength is set to 4. */ 1105/* */ 1106/* Inputs : pu1_src - pointer to the src sample q0 of U */ 1107/* src_strd - source stride */ 1108/* alpha - alpha value for the boundary */ 1109/* beta - beta value for the boundary */ 1110/* */ 1111/* Globals : None */ 1112/* */ 1113/* Processing : When the function is called twice, this operation is as */ 1114/* described in Sec. 8.7.2.3 under the title "Filtering */ 1115/* process for edges for bS equal to 4" in ITU T Rec H.264. */ 1116/* */ 1117/* Outputs : None */ 1118/* */ 1119/* Returns : None */ 1120/* */ 1121/* Issues : None */ 1122/* */ 1123/* Revision History: */ 1124/* */ 1125/* DD MM YYYY Author(s) Changes (Describe the changes made) */ 1126/* 29 12 2014 Kaushik Draft */ 1127/* Senthoor */ 1128/* */ 1129/*****************************************************************************/ 1130void ih264_deblk_chroma_vert_bs4_mbaff_bp(UWORD8 *pu1_src, 1131 WORD32 src_strd, 1132 WORD32 alpha, 1133 WORD32 beta) 1134{ 1135 UWORD8 *pu1_src_u = pu1_src; /* Pointer to the src sample q0 of U */ 1136 UWORD8 *pu1_src_v = pu1_src + 1; /* Pointer to the src sample q0 of V */ 1137 UWORD8 p1_u, p0_u, q0_u, q1_u, p1_v, p0_v, q0_v, q1_v; 1138 WORD32 blk_strd = src_strd; 1139 WORD32 pos_p1, pos_p0, pos_q0, pos_q1; 1140 UWORD8 *pu1_src_temp_u, *pu1_src_temp_v; 1141 WORD8 edge; 1142 1143 pos_q0 = 0; 1144 pos_q1 = 2; 1145 pos_p0 = -2; 1146 pos_p1 = -4; 1147 1148 for(edge = 0; edge < 4; 1149 edge++, pu1_src_u += blk_strd, pu1_src_v += blk_strd) 1150 { 1151 pu1_src_temp_u = pu1_src_u; 1152 pu1_src_temp_v = pu1_src_v; 1153 1154 q0_u = pu1_src_temp_u[pos_q0]; 1155 q1_u = pu1_src_temp_u[pos_q1]; 1156 p0_u = pu1_src_temp_u[pos_p0]; 1157 p1_u = pu1_src_temp_u[pos_p1]; 1158 q0_v = pu1_src_temp_v[pos_q0]; 1159 q1_v = pu1_src_temp_v[pos_q1]; 1160 p0_v = pu1_src_temp_v[pos_p0]; 1161 p1_v = pu1_src_temp_v[pos_p1]; 1162 1163 /* Filter Decision */ 1164 if((ABS(p0_u - q0_u) < alpha) && 1165 (ABS(q1_u - q0_u) < beta) && 1166 (ABS(p1_u - p0_u) < beta)) 1167 { 1168 /* p0' */ 1169 pu1_src_temp_u[pos_p0] = ((X2(p1_u) + p0_u + q1_u + 2) >> 2); 1170 /* q0' */ 1171 pu1_src_temp_u[pos_q0] = (X2(q1_u) + q0_u + p1_u + 2) >> 2; 1172 } 1173 1174 /* Filter Decision */ 1175 if(ABS(p0_v - q0_v) < alpha && ABS(q1_v - q0_v) < beta 1176 && ABS(p1_v - p0_v) < beta) 1177 { 1178 /* p0' */ 1179 pu1_src_temp_v[pos_p0] = ((X2(p1_v) + p0_v + q1_v + 2) >> 2); 1180 /* q0' */ 1181 pu1_src_temp_v[pos_q0] = (X2(q1_v) + q0_v + p1_v + 2) >> 2; 1182 } 1183 } 1184} 1185 1186/*****************************************************************************/ 1187/* */ 1188/* Function Name : ih264_deblk_luma_vert_bslt4_mbaff() */ 1189/* */ 1190/* Description : This function performs filtering of a luma block */ 1191/* vertical edge when boundary strength is less than 4. */ 1192/* */ 1193/* Inputs : pu1_src - pointer to the src sample q0 */ 1194/* src_strd - source stride */ 1195/* alpha - alpha value for the boundary */ 1196/* beta - beta value for the boundary */ 1197/* u4_bs - packed Boundary strength array */ 1198/* pu1_cliptab - tc0_table */ 1199/* */ 1200/* Globals : None */ 1201/* */ 1202/* Processing : When the function is called twice, this operation is as */ 1203/* described in Sec. 8.7.2.3 under the title "Filtering */ 1204/* process for edges for bS less than 4" in ITU T Rec H.264.*/ 1205/* */ 1206/* Outputs : None */ 1207/* */ 1208/* Returns : None */ 1209/* */ 1210/* Issues : None */ 1211/* */ 1212/* Revision History: */ 1213/* */ 1214/* DD MM YYYY Author(s) Changes (Describe the changes made) */ 1215/* 29 12 2014 Kaushik Draft */ 1216/* Senthoor */ 1217/* */ 1218/*****************************************************************************/ 1219void ih264_deblk_luma_vert_bslt4_mbaff(UWORD8 *pu1_src, 1220 WORD32 src_strd, 1221 WORD32 alpha, 1222 WORD32 beta, 1223 UWORD32 u4_bs, 1224 const UWORD8 *pu1_cliptab) 1225{ 1226 WORD8 i = 0, edge; 1227 UWORD8 p2, p1, p0, q0, q1, q2; 1228 WORD32 pos_p2, pos_p1, pos_p0, pos_q0, pos_q1, pos_q2; 1229 UWORD8 a_p, a_q; /* Threshold variables */ 1230 WORD32 blk_strd = src_strd << 1; /* block_increment = src_strd * 2 */ 1231 UWORD8 *pu1_src_temp; 1232 WORD8 delta; 1233 WORD8 tc; 1234 WORD16 val; 1235 UWORD8 tc0, u1_bs; 1236 1237 pos_q0 = 0; 1238 pos_q1 = 1; 1239 pos_q2 = 2; 1240 pos_p0 = -1; 1241 pos_p1 = -2; 1242 pos_p2 = -3; 1243 1244 for(edge = 0; edge < 4; edge++, pu1_src += blk_strd) 1245 { 1246 pu1_src_temp = pu1_src; 1247 /* Filter Decision */ 1248 u1_bs = (UWORD8)((u4_bs >> ((3 - edge) << 3)) & 0x0ff); 1249 if(!u1_bs) 1250 continue; 1251 /* tc0 */ 1252 tc0 = pu1_cliptab[u1_bs]; 1253 for(i = 0; i < 2; ++i, pu1_src_temp += src_strd) 1254 { 1255 q0 = pu1_src_temp[pos_q0]; 1256 q1 = pu1_src_temp[pos_q1]; 1257 p0 = pu1_src_temp[pos_p0]; 1258 p1 = pu1_src_temp[pos_p1]; 1259 1260 /* Filter Decision */ 1261 if((ABS(p0 - q0) >= alpha) || 1262 (ABS(q1 - q0) >= beta) || 1263 (ABS(p1 - p0) >= beta)) 1264 continue; 1265 1266 q2 = pu1_src_temp[pos_q2]; 1267 p2 = pu1_src_temp[pos_p2]; 1268 1269 a_p = ABS(p2 - p0); 1270 a_q = ABS(q2 - q0); 1271 1272 /* tc */ 1273 tc = tc0 + (a_p < beta) + (a_q < beta); 1274 1275 val = ((((q0 - p0) << 2) + (p1 - q1) + 4) >> 3); 1276 delta = CLIP3(-tc, tc, val); 1277 /* p0' */ 1278 val = p0 + delta; 1279 pu1_src_temp[pos_p0] = CLIP_U8(val); 1280 /* q0' */ 1281 val = q0 - delta; 1282 pu1_src_temp[pos_q0] = CLIP_U8(val); 1283 1284 /* Luma only */ 1285 if(a_p < beta) 1286 { 1287 /* p1' */ 1288 val = ((p2 + ((p0 + q0 + 1) >> 1) - (p1 << 1)) >> 1); 1289 pu1_src_temp[pos_p1] += CLIP3(-tc0, tc0, val); 1290 } 1291 1292 if(a_q < beta) 1293 { 1294 /* q1' */ 1295 val = ((q2 + ((p0 + q0 + 1) >> 1) - (q1 << 1)) >> 1); 1296 pu1_src_temp[pos_q1] += CLIP3(-tc0, tc0, val); 1297 } 1298 } 1299 } 1300} 1301 1302/*****************************************************************************/ 1303/* */ 1304/* Function Name : ih264_deblk_chroma_vert_bslt4_mbaff_bp() */ 1305/* */ 1306/* Description : This function performs filtering of a chroma block */ 1307/* vertical edge when boundary strength is less than 4. */ 1308/* */ 1309/* Inputs : pu1_src - pointer to the src sample q0 of U */ 1310/* src_strd - source stride */ 1311/* alpha - alpha value for the boundary */ 1312/* beta - beta value for the boundary */ 1313/* u4_bs - packed Boundary strength array */ 1314/* pu1_cliptab - tc0_table */ 1315/* */ 1316/* Globals : None */ 1317/* */ 1318/* Processing : When the function is called twice, this operation is as */ 1319/* described in Sec. 8.7.2.3 under the title "Filtering */ 1320/* process for edges for bS less than 4" in ITU T Rec H.264.*/ 1321/* */ 1322/* Outputs : None */ 1323/* */ 1324/* Returns : None */ 1325/* */ 1326/* Issues : None */ 1327/* */ 1328/* Revision History: */ 1329/* */ 1330/* DD MM YYYY Author(s) Changes (Describe the changes made) */ 1331/* 29 12 2014 Kaushik Draft */ 1332/* Senthoor */ 1333/* */ 1334/*****************************************************************************/ 1335void ih264_deblk_chroma_vert_bslt4_mbaff_bp(UWORD8 *pu1_src, 1336 WORD32 src_strd, 1337 WORD32 alpha, 1338 WORD32 beta, 1339 UWORD32 u4_bs, 1340 const UWORD8 *pu1_cliptab) 1341{ 1342 UWORD8 *pu1_src_u = pu1_src; /* Pointer to the src sample q0 of plane U*/ 1343 UWORD8 *pu1_src_v = pu1_src + 1; /* Pointer to the src sample q0 of plane V*/ 1344 UWORD8 p1_u, p0_u, q0_u, q1_u, p1_v, p0_v, q0_v, q1_v; 1345 WORD32 blk_strd = src_strd; 1346 WORD32 pos_p1, pos_p0, pos_q0, pos_q1; 1347 UWORD8 *pu1_src_temp_u, *pu1_src_temp_v; 1348 WORD8 edge; 1349 WORD8 delta; 1350 WORD8 tc; 1351 WORD16 val; 1352 UWORD8 tc0, u1_bs; 1353 1354 pos_q0 = 0; 1355 pos_q1 = 2; 1356 pos_p0 = -2; 1357 pos_p1 = -4; 1358 1359 for(edge = 0; edge < 4; 1360 edge++, pu1_src_u += blk_strd, pu1_src_v += blk_strd) 1361 { 1362 pu1_src_temp_u = pu1_src_u; 1363 pu1_src_temp_v = pu1_src_v; 1364 /* Filter Decision */ 1365 u1_bs = (UWORD8)((u4_bs >> ((3 - edge) << 3)) & 0x0ff); 1366 if(!u1_bs) 1367 continue; 1368 /* tc0 */ 1369 tc0 = pu1_cliptab[u1_bs]; 1370 tc = tc0 + 1; 1371 1372 q0_u = pu1_src_temp_u[pos_q0]; 1373 q1_u = pu1_src_temp_u[pos_q1]; 1374 p0_u = pu1_src_temp_u[pos_p0]; 1375 p1_u = pu1_src_temp_u[pos_p1]; 1376 1377 q0_v = pu1_src_temp_v[pos_q0]; 1378 q1_v = pu1_src_temp_v[pos_q1]; 1379 p0_v = pu1_src_temp_v[pos_p0]; 1380 p1_v = pu1_src_temp_v[pos_p1]; 1381 1382 /* Filter Decision */ 1383 if((ABS(p0_u - q0_u) < alpha) && 1384 (ABS(q1_u - q0_u) < beta) && 1385 (ABS(p1_u - p0_u) < beta)) 1386 { 1387 val = ((((q0_u - p0_u) << 2) + (p1_u - q1_u) + 4) >> 3); 1388 delta = CLIP3(-tc, tc, val); 1389 /* p0' */ 1390 val = p0_u + delta; 1391 pu1_src_temp_u[pos_p0] = CLIP_U8(val); 1392 /* q0' */ 1393 val = q0_u - delta; 1394 pu1_src_temp_u[pos_q0] = CLIP_U8(val); 1395 } 1396 1397 /* Filter Decision */ 1398 if((ABS(p0_v - q0_v) < alpha) && 1399 (ABS(q1_v - q0_v) < beta) && 1400 (ABS(p1_v - p0_v) < beta)) 1401 { 1402 val = ((((q0_v - p0_v) << 2) + (p1_v - q1_v) + 4) >> 3); 1403 delta = CLIP3(-tc, tc, val); 1404 /* p0' */ 1405 val = p0_v + delta; 1406 pu1_src_temp_v[pos_p0] = CLIP_U8(val); 1407 /* q0' */ 1408 val = q0_v - delta; 1409 pu1_src_temp_v[pos_q0] = CLIP_U8(val); 1410 } 1411 } 1412} 1413 1414/*****************************************************************************/ 1415/* Function Definitions for chroma deblocking in high profile */ 1416/*****************************************************************************/ 1417 1418/*****************************************************************************/ 1419/* */ 1420/* Function Name : ih264_deblk_chroma_vert_bs4() */ 1421/* */ 1422/* Description : This function performs filtering of a chroma block */ 1423/* vertical edge when the boundary strength is set to 4 in */ 1424/* high profile. */ 1425/* */ 1426/* Inputs : pu1_src - pointer to the src sample q0 of U */ 1427/* src_strd - source stride */ 1428/* alpha_cb - alpha value for the boundary in U */ 1429/* beta_cb - beta value for the boundary in U */ 1430/* alpha_cr - alpha value for the boundary in V */ 1431/* beta_cr - beta value for the boundary in V */ 1432/* */ 1433/* Globals : None */ 1434/* */ 1435/* Processing : This operation is described in Sec. 8.7.2.4 under the */ 1436/* title "Filtering process for edges for bS equal to 4" in */ 1437/* ITU T Rec H.264 with alpha and beta values different in */ 1438/* U and V. */ 1439/* */ 1440/* Outputs : None */ 1441/* */ 1442/* Returns : None */ 1443/* */ 1444/* Issues : None */ 1445/* */ 1446/* Revision History: */ 1447/* */ 1448/* DD MM YYYY Author(s) Changes (Describe the changes made) */ 1449/* 29 12 2014 Kaushik Draft */ 1450/* Senthoor */ 1451/* */ 1452/*****************************************************************************/ 1453void ih264_deblk_chroma_vert_bs4(UWORD8 *pu1_src, 1454 WORD32 src_strd, 1455 WORD32 alpha_cb, 1456 WORD32 beta_cb, 1457 WORD32 alpha_cr, 1458 WORD32 beta_cr) 1459{ 1460 UWORD8 *pu1_src_u = pu1_src; /* Pointer to the src sample q0 of U */ 1461 UWORD8 *pu1_src_v = pu1_src + 1; /* Pointer to the src sample q0 of V */ 1462 UWORD8 p1_u, p0_u, q0_u, q1_u, p1_v, p0_v, q0_v, q1_v; 1463 WORD32 blk_strd = src_strd << 1; /* block_increment = src_strd * 2*/ 1464 WORD32 pos_p1, pos_p0, pos_q0, pos_q1; 1465 UWORD8 *pu1_src_temp_u, *pu1_src_temp_v; 1466 WORD8 i = 0, edge; 1467 1468 pos_q0 = 0; 1469 pos_q1 = 2; 1470 pos_p0 = -2; 1471 pos_p1 = -4; 1472 1473 for(edge = 0; edge < 4; 1474 edge++, pu1_src_u += blk_strd, pu1_src_v += blk_strd) 1475 { 1476 pu1_src_temp_u = pu1_src_u; 1477 pu1_src_temp_v = pu1_src_v; 1478 for(i = 0; i < 2; ++i, pu1_src_temp_u += src_strd, pu1_src_temp_v += 1479 src_strd) 1480 { 1481 q0_u = pu1_src_temp_u[pos_q0]; 1482 q1_u = pu1_src_temp_u[pos_q1]; 1483 p0_u = pu1_src_temp_u[pos_p0]; 1484 p1_u = pu1_src_temp_u[pos_p1]; 1485 q0_v = pu1_src_temp_v[pos_q0]; 1486 q1_v = pu1_src_temp_v[pos_q1]; 1487 p0_v = pu1_src_temp_v[pos_p0]; 1488 p1_v = pu1_src_temp_v[pos_p1]; 1489 1490 /* Filter Decision */ 1491 if((ABS(p0_u - q0_u) < alpha_cb) && 1492 (ABS(q1_u - q0_u) < beta_cb) && 1493 (ABS(p1_u - p0_u) < beta_cb)) 1494 { 1495 /* p0' */ 1496 pu1_src_temp_u[pos_p0] = ((X2(p1_u) + p0_u + q1_u + 2) >> 2); 1497 /* q0' */ 1498 pu1_src_temp_u[pos_q0] = (X2(q1_u) + q0_u + p1_u + 2) >> 2; 1499 } 1500 1501 /* Filter Decision */ 1502 if((ABS(p0_v - q0_v) < alpha_cr) && 1503 (ABS(q1_v - q0_v) < beta_cr) && 1504 (ABS(p1_v - p0_v) < beta_cr)) 1505 { 1506 /* p0' */ 1507 pu1_src_temp_v[pos_p0] = ((X2(p1_v) + p0_v + q1_v + 2) >> 2); 1508 /* q0' */ 1509 pu1_src_temp_v[pos_q0] = (X2(q1_v) + q0_v + p1_v + 2) >> 2; 1510 } 1511 } 1512 } 1513} 1514 1515/*****************************************************************************/ 1516/* */ 1517/* Function Name : ih264_deblk_chroma_horz_bs4() */ 1518/* */ 1519/* Description : This function performs filtering of a chroma block */ 1520/* horizontal edge when the boundary strength is set to 4 */ 1521/* in high profile. */ 1522/* */ 1523/* Inputs : pu1_src - pointer to the src sample q0 of U */ 1524/* src_strd - source stride */ 1525/* alpha_cb - alpha value for the boundary in U */ 1526/* beta_cb - beta value for the boundary in U */ 1527/* alpha_cr - alpha value for the boundary in V */ 1528/* beta_cr - beta value for the boundary in V */ 1529/* */ 1530/* Globals : None */ 1531/* */ 1532/* Processing : This operation is described in Sec. 8.7.2.4 under the */ 1533/* title "Filtering process for edges for bS equal to 4" in */ 1534/* ITU T Rec H.264 with alpha and beta values different in */ 1535/* U and V. */ 1536/* */ 1537/* Outputs : None */ 1538/* */ 1539/* Returns : None */ 1540/* */ 1541/* Issues : None */ 1542/* */ 1543/* Revision History: */ 1544/* */ 1545/* DD MM YYYY Author(s) Changes (Describe the changes made) */ 1546/* 29 12 2014 Kaushik Draft */ 1547/* Senthoor */ 1548/* */ 1549/*****************************************************************************/ 1550void ih264_deblk_chroma_horz_bs4(UWORD8 *pu1_src, 1551 WORD32 src_strd, 1552 WORD32 alpha_cb, 1553 WORD32 beta_cb, 1554 WORD32 alpha_cr, 1555 WORD32 beta_cr) 1556{ 1557 UWORD8 *pu1_src_u = pu1_src; /* Pointer to the src sample q0 of U */ 1558 UWORD8 *pu1_src_v = pu1_src + 1; /* Pointer to the src sample q0 of V */ 1559 UWORD8 p1_u, p0_u, q0_u, q1_u, p1_v, p0_v, q0_v, q1_v; 1560 WORD32 pos_p1, pos_p0, pos_q0, pos_q1; 1561 UWORD8 *pu1_src_temp_u, *pu1_src_temp_v; 1562 UWORD8 *pu1_p1_u; /* Pointer to the src sample p1 of U */ 1563 UWORD8 *pu1_p1_v; /* Pointer to the src sample p1 of U */ 1564 UWORD8 *pu1_p1_temp_u, *pu1_p1_temp_v; 1565 WORD8 i = 0, edge; 1566 1567 pu1_p1_u = pu1_src_u - (src_strd << 1); 1568 pu1_p1_v = pu1_src_v - (src_strd << 1); 1569 pos_q0 = 0; 1570 pos_q1 = src_strd; 1571 pos_p0 = src_strd; 1572 pos_p1 = 0; 1573 1574 for(edge = 0; edge < 4; edge++, pu1_src_u += 4, pu1_p1_u += 4, pu1_src_v += 1575 4, pu1_p1_v += 4) 1576 { 1577 pu1_src_temp_u = pu1_src_u; 1578 pu1_p1_temp_u = pu1_p1_u; 1579 pu1_src_temp_v = pu1_src_v; 1580 pu1_p1_temp_v = pu1_p1_v; 1581 for(i = 0; i < 2; ++i, pu1_src_temp_u += 2, pu1_p1_temp_u += 2, 1582 pu1_src_temp_v += 2, pu1_p1_temp_v += 2) 1583 { 1584 q0_u = pu1_src_temp_u[pos_q0]; 1585 q1_u = pu1_src_temp_u[pos_q1]; 1586 p0_u = pu1_p1_temp_u[pos_p0]; 1587 p1_u = pu1_p1_temp_u[pos_p1]; 1588 1589 q0_v = pu1_src_temp_v[pos_q0]; 1590 q1_v = pu1_src_temp_v[pos_q1]; 1591 p0_v = pu1_p1_temp_v[pos_p0]; 1592 p1_v = pu1_p1_temp_v[pos_p1]; 1593 1594 /* Filter Decision */ 1595 if(ABS(p0_u - q0_u) < alpha_cb && ABS(q1_u - q0_u) < beta_cb 1596 && ABS(p1_u - p0_u) < beta_cb) 1597 { 1598 /* p0' */ 1599 pu1_p1_temp_u[pos_p0] = (X2(p1_u) + p0_u + q1_u + 2) >> 2; 1600 /* q0' */ 1601 pu1_src_temp_u[pos_q0] = (X2(q1_u) + q0_u + p1_u + 2) >> 2; 1602 } 1603 1604 /* Filter Decision */ 1605 if(ABS(p0_v - q0_v) < alpha_cr && ABS(q1_v - q0_v) < beta_cr 1606 && ABS(p1_v - p0_v) < beta_cr) 1607 { 1608 /* p0' */ 1609 pu1_p1_temp_v[pos_p0] = (X2(p1_v) + p0_v + q1_v + 2) >> 2; 1610 /* q0' */ 1611 pu1_src_temp_v[pos_q0] = (X2(q1_v) + q0_v + p1_v + 2) >> 2; 1612 } 1613 } 1614 } 1615} 1616 1617/*****************************************************************************/ 1618/* */ 1619/* Function Name : ih264_deblk_chroma_vert_bslt4() */ 1620/* */ 1621/* Description : This function performs filtering of a chroma block */ 1622/* vertical edge when the boundary strength is less than 4 */ 1623/* in high profile. */ 1624/* */ 1625/* Inputs : pu1_src - pointer to the src sample q0 of U */ 1626/* src_strd - source stride */ 1627/* alpha_cb - alpha value for the boundary in U */ 1628/* beta_cb - beta value for the boundary in U */ 1629/* alpha_cr - alpha value for the boundary in V */ 1630/* beta_cr - beta value for the boundary in V */ 1631/* u4_bs - packed Boundary strength array */ 1632/* pu1_cliptab_cb - tc0_table for U */ 1633/* pu1_cliptab_cr - tc0_table for V */ 1634/* */ 1635/* Globals : None */ 1636/* */ 1637/* Processing : This operation is described in Sec. 8.7.2.3 under the */ 1638/* title "Filtering process for edges for bS less than 4" */ 1639/* in ITU T Rec H.264 with alpha and beta values different */ 1640/* in U and V. */ 1641/* */ 1642/* Outputs : None */ 1643/* */ 1644/* Returns : None */ 1645/* */ 1646/* Issues : None */ 1647/* */ 1648/* Revision History: */ 1649/* */ 1650/* DD MM YYYY Author(s) Changes (Describe the changes made) */ 1651/* 29 12 2014 Kaushik Draft */ 1652/* Senthoor */ 1653/* */ 1654/*****************************************************************************/ 1655void ih264_deblk_chroma_vert_bslt4(UWORD8 *pu1_src, 1656 WORD32 src_strd, 1657 WORD32 alpha_cb, 1658 WORD32 beta_cb, 1659 WORD32 alpha_cr, 1660 WORD32 beta_cr, 1661 UWORD32 u4_bs, 1662 const UWORD8 *pu1_cliptab_cb, 1663 const UWORD8 *pu1_cliptab_cr) 1664{ 1665 UWORD8 *pu1_src_u = pu1_src; /* Pointer to the src sample q0 of plane U*/ 1666 UWORD8 *pu1_src_v = pu1_src + 1; /* Pointer to the src sample q0 of plane V*/ 1667 UWORD8 p1_u, p0_u, q0_u, q1_u, p1_v, p0_v, q0_v, q1_v; 1668 WORD32 blk_strd = src_strd << 1; /* block_increment = src_strd * 2 */ 1669 WORD32 pos_p1, pos_p0, pos_q0, pos_q1; 1670 UWORD8 *pu1_src_temp_u, *pu1_src_temp_v; 1671 WORD8 i = 0, edge; 1672 WORD8 delta; 1673 WORD8 tcb, tcr; 1674 WORD16 val; 1675 UWORD8 tcb0, tcr0, u1_bs; 1676 1677 pos_q0 = 0; 1678 pos_q1 = 2; 1679 pos_p0 = -2; 1680 pos_p1 = -4; 1681 1682 for(edge = 0; edge < 4; 1683 edge++, pu1_src_u += blk_strd, pu1_src_v += blk_strd) 1684 { 1685 pu1_src_temp_u = pu1_src_u; 1686 pu1_src_temp_v = pu1_src_v; 1687 /* Filter Decision */ 1688 u1_bs = (UWORD8)((u4_bs >> ((3 - edge) << 3)) & 0x0ff); 1689 if(!u1_bs) 1690 continue; 1691 /* tc0 */ 1692 tcb0 = pu1_cliptab_cb[u1_bs]; 1693 tcr0 = pu1_cliptab_cr[u1_bs]; 1694 tcb = tcb0 + 1; 1695 tcr = tcr0 + 1; 1696 for(i = 0; i < 2; ++i, pu1_src_temp_u += src_strd, pu1_src_temp_v += 1697 src_strd) 1698 { 1699 q0_u = pu1_src_temp_u[pos_q0]; 1700 q1_u = pu1_src_temp_u[pos_q1]; 1701 p0_u = pu1_src_temp_u[pos_p0]; 1702 p1_u = pu1_src_temp_u[pos_p1]; 1703 1704 q0_v = pu1_src_temp_v[pos_q0]; 1705 q1_v = pu1_src_temp_v[pos_q1]; 1706 p0_v = pu1_src_temp_v[pos_p0]; 1707 p1_v = pu1_src_temp_v[pos_p1]; 1708 1709 /* Filter Decision */ 1710 if(ABS(p0_u - q0_u) < alpha_cb && ABS(q1_u - q0_u) < beta_cb 1711 && ABS(p1_u - p0_u) < beta_cb) 1712 { 1713 val = ((((q0_u - p0_u) << 2) + (p1_u - q1_u) + 4) >> 3); 1714 delta = CLIP3(-tcb, tcb, val); 1715 /* p0' */ 1716 val = p0_u + delta; 1717 pu1_src_temp_u[pos_p0] = CLIP_U8(val); 1718 /* q0' */ 1719 val = q0_u - delta; 1720 pu1_src_temp_u[pos_q0] = CLIP_U8(val); 1721 } 1722 1723 /* Filter Decision */ 1724 if(ABS(p0_v - q0_v) < alpha_cr && ABS(q1_v - q0_v) < beta_cr 1725 && ABS(p1_v - p0_v) < beta_cr) 1726 { 1727 val = ((((q0_v - p0_v) << 2) + (p1_v - q1_v) + 4) >> 3); 1728 delta = CLIP3(-tcr, tcr, val); 1729 /* p0' */ 1730 val = p0_v + delta; 1731 pu1_src_temp_v[pos_p0] = CLIP_U8(val); 1732 /* q0' */ 1733 val = q0_v - delta; 1734 pu1_src_temp_v[pos_q0] = CLIP_U8(val); 1735 } 1736 } 1737 } 1738} 1739 1740/*****************************************************************************/ 1741/* */ 1742/* Function Name : ih264_deblk_chroma_horz_bslt4() */ 1743/* */ 1744/* Description : This function performs filtering of a chroma block */ 1745/* horizontal edge when the boundary strength is less than */ 1746/* 4 in high profile. */ 1747/* */ 1748/* Inputs : pu1_src - pointer to the src sample q0 of U */ 1749/* src_strd - source stride */ 1750/* alpha_cb - alpha value for the boundary in U */ 1751/* beta_cb - beta value for the boundary in U */ 1752/* alpha_cr - alpha value for the boundary in V */ 1753/* beta_cr - beta value for the boundary in V */ 1754/* u4_bs - packed Boundary strength array */ 1755/* pu1_cliptab_cb - tc0_table for U */ 1756/* pu1_cliptab_cr - tc0_table for V */ 1757/* */ 1758/* Globals : None */ 1759/* */ 1760/* Processing : This operation is described in Sec. 8.7.2.3 under the */ 1761/* title "Filtering process for edges for bS less than 4" */ 1762/* in ITU T Rec H.264 with alpha and beta values different */ 1763/* in U and V. */ 1764/* */ 1765/* Outputs : None */ 1766/* */ 1767/* Returns : None */ 1768/* */ 1769/* Issues : None */ 1770/* */ 1771/* Revision History: */ 1772/* */ 1773/* DD MM YYYY Author(s) Changes (Describe the changes made) */ 1774/* 29 12 2014 Kaushik Draft */ 1775/* Senthoor */ 1776/* */ 1777/*****************************************************************************/ 1778void ih264_deblk_chroma_horz_bslt4(UWORD8 *pu1_src, 1779 WORD32 src_strd, 1780 WORD32 alpha_cb, 1781 WORD32 beta_cb, 1782 WORD32 alpha_cr, 1783 WORD32 beta_cr, 1784 UWORD32 u4_bs, 1785 const UWORD8 *pu1_cliptab_cb, 1786 const UWORD8 *pu1_cliptab_cr) 1787{ 1788 UWORD8 *pu1_src_u = pu1_src; /* Pointer to the src sample q0 of plane U*/ 1789 UWORD8 *pu1_src_v = pu1_src + 1; /* Pointer to the src sample q0 of plane V*/ 1790 UWORD8 p1_u, p0_u, q0_u, q1_u, p1_v, p0_v, q0_v, q1_v; 1791 WORD32 pos_p1, pos_p0, pos_q0, pos_q1; 1792 UWORD8 *pu1_src_temp_u, *pu1_src_temp_v; 1793 UWORD8 *pu1_p1_u; /* Pointer to the src sample p1 of plane U*/ 1794 UWORD8 *pu1_p1_v; /* Pointer to the src sample p1 of plane V*/ 1795 UWORD8 *pu1_p1_temp_u, *pu1_p1_temp_v; 1796 WORD8 i = 0, edge; 1797 WORD8 delta; 1798 WORD8 tcb, tcr; 1799 WORD16 val; 1800 UWORD8 u1_bs; 1801 UWORD8 tcb0, tcr0; 1802 1803 pu1_p1_u = pu1_src_u - (src_strd << 1); 1804 pu1_p1_v = pu1_src_v - (src_strd << 1); 1805 pos_q0 = 0; 1806 pos_q1 = src_strd; 1807 pos_p0 = src_strd; 1808 pos_p1 = 0; 1809 1810 for(edge = 0; edge < 4; edge++, pu1_src_u += 4, pu1_p1_u += 4, 1811 pu1_src_v += 4, pu1_p1_v += 4) 1812 { 1813 pu1_src_temp_u = pu1_src_u; 1814 pu1_p1_temp_u = pu1_p1_u; 1815 pu1_src_temp_v = pu1_src_v; 1816 pu1_p1_temp_v = pu1_p1_v; 1817 1818 /* Filter Decision */ 1819 u1_bs = (UWORD8)((u4_bs >> ((3 - edge) << 3)) & 0x0ff); 1820 if(!u1_bs) 1821 continue; 1822 /* tc0 */ 1823 tcb0 = pu1_cliptab_cb[u1_bs]; 1824 tcr0 = pu1_cliptab_cr[u1_bs]; 1825 1826 for(i = 0; i < 2; ++i, pu1_src_temp_u += 2, pu1_p1_temp_u += 2, 1827 pu1_src_temp_v += 2, pu1_p1_temp_v += 2) 1828 { 1829 q0_u = pu1_src_temp_u[pos_q0]; 1830 q1_u = pu1_src_temp_u[pos_q1]; 1831 p0_u = pu1_p1_temp_u[pos_p0]; 1832 p1_u = pu1_p1_temp_u[pos_p1]; 1833 1834 q0_v = pu1_src_temp_v[pos_q0]; 1835 q1_v = pu1_src_temp_v[pos_q1]; 1836 p0_v = pu1_p1_temp_v[pos_p0]; 1837 p1_v = pu1_p1_temp_v[pos_p1]; 1838 1839 /* tc */ 1840 tcb = tcb0 + 1; 1841 tcr = tcr0 + 1; 1842 /* Filter Decision */ 1843 if(ABS(p0_u - q0_u) < alpha_cb && ABS(q1_u - q0_u) < beta_cb 1844 && ABS(p1_u - p0_u) < beta_cb) 1845 { 1846 val = ((((q0_u - p0_u) << 2) + (p1_u - q1_u) + 4) >> 3); 1847 delta = CLIP3(-tcb, tcb, val); 1848 /* p0' */ 1849 val = p0_u + delta; 1850 pu1_p1_temp_u[pos_p0] = CLIP_U8(val); 1851 /* q0' */ 1852 val = q0_u - delta; 1853 pu1_src_temp_u[pos_q0] = CLIP_U8(val); 1854 } 1855 /* Filter Decision */ 1856 if(ABS(p0_v - q0_v) < alpha_cr && ABS(q1_v - q0_v) < beta_cr 1857 && ABS(p1_v - p0_v) < beta_cr) 1858 { 1859 val = ((((q0_v - p0_v) << 2) + (p1_v - q1_v) + 4) >> 3); 1860 delta = CLIP3(-tcr, tcr, val); 1861 /* p0' */ 1862 val = p0_v + delta; 1863 pu1_p1_temp_v[pos_p0] = CLIP_U8(val); 1864 /* q0' */ 1865 val = q0_v - delta; 1866 pu1_src_temp_v[pos_q0] = CLIP_U8(val); 1867 } 1868 } 1869 } 1870} 1871 1872/*****************************************************************************/ 1873/* */ 1874/* Function Name : ih264_deblk_chroma_vert_bs4_mbaff() */ 1875/* */ 1876/* Description : This function performs filtering of a chroma block */ 1877/* vertical edge when boundary strength is set to 4 in high */ 1878/* profile. */ 1879/* */ 1880/* Inputs : pu1_src - pointer to the src sample q0 of U */ 1881/* src_strd - source stride */ 1882/* alpha_cb - alpha value for the boundary in U */ 1883/* beta_cb - beta value for the boundary in U */ 1884/* alpha_cr - alpha value for the boundary in V */ 1885/* beta_cr - beta value for the boundary in V */ 1886/* u4_bs - packed Boundary strength array */ 1887/* pu1_cliptab_cb - tc0_table for U */ 1888/* pu1_cliptab_cr - tc0_table for V */ 1889/* */ 1890/* Globals : None */ 1891/* */ 1892/* Processing : When the function is called twice, this operation is as */ 1893/* described in Sec. 8.7.2.4 under the title "Filtering */ 1894/* process for edges for bS equal to 4" in ITU T Rec H.264 */ 1895/* with alpha and beta values different in U and V. */ 1896/* */ 1897/* Outputs : None */ 1898/* */ 1899/* Returns : None */ 1900/* */ 1901/* Issues : None */ 1902/* */ 1903/* Revision History: */ 1904/* */ 1905/* DD MM YYYY Author(s) Changes (Describe the changes made) */ 1906/* 29 12 2014 Kaushik Draft */ 1907/* Senthoor */ 1908/* */ 1909/*****************************************************************************/ 1910void ih264_deblk_chroma_vert_bs4_mbaff(UWORD8 *pu1_src, 1911 WORD32 src_strd, 1912 WORD32 alpha_cb, 1913 WORD32 beta_cb, 1914 WORD32 alpha_cr, 1915 WORD32 beta_cr) 1916{ 1917 UWORD8 *pu1_src_u = pu1_src; /* Pointer to the src sample q0 of U */ 1918 UWORD8 *pu1_src_v = pu1_src + 1; /* Pointer to the src sample q0 of V */ 1919 UWORD8 p1_u, p0_u, q0_u, q1_u, p1_v, p0_v, q0_v, q1_v; 1920 WORD32 blk_strd = src_strd; 1921 WORD32 pos_p1, pos_p0, pos_q0, pos_q1; 1922 UWORD8 *pu1_src_temp_u, *pu1_src_temp_v; 1923 WORD8 edge; 1924 1925 pos_q0 = 0; 1926 pos_q1 = 2; 1927 pos_p0 = -2; 1928 pos_p1 = -4; 1929 1930 for(edge = 0; edge < 4; 1931 edge++, pu1_src_u += blk_strd, pu1_src_v += blk_strd) 1932 { 1933 pu1_src_temp_u = pu1_src_u; 1934 pu1_src_temp_v = pu1_src_v; 1935 q0_u = pu1_src_temp_u[pos_q0]; 1936 q1_u = pu1_src_temp_u[pos_q1]; 1937 p0_u = pu1_src_temp_u[pos_p0]; 1938 p1_u = pu1_src_temp_u[pos_p1]; 1939 q0_v = pu1_src_temp_v[pos_q0]; 1940 q1_v = pu1_src_temp_v[pos_q1]; 1941 p0_v = pu1_src_temp_v[pos_p0]; 1942 p1_v = pu1_src_temp_v[pos_p1]; 1943 1944 /* Filter Decision */ 1945 if((ABS(p0_u - q0_u) < alpha_cb) && 1946 (ABS(q1_u - q0_u) < beta_cb) && 1947 (ABS(p1_u - p0_u) < beta_cb)) 1948 { 1949 /* p0' */ 1950 pu1_src_temp_u[pos_p0] = ((X2(p1_u) + p0_u + q1_u + 2) >> 2); 1951 /* q0' */ 1952 pu1_src_temp_u[pos_q0] = (X2(q1_u) + q0_u + p1_u + 2) >> 2; 1953 } 1954 1955 /* Filter Decision */ 1956 if((ABS(p0_v - q0_v) < alpha_cr) && 1957 (ABS(q1_v - q0_v) < beta_cr) && 1958 (ABS(p1_v - p0_v) < beta_cr)) 1959 { 1960 /* p0' */ 1961 pu1_src_temp_v[pos_p0] = ((X2(p1_v) + p0_v + q1_v + 2) >> 2); 1962 /* q0' */ 1963 pu1_src_temp_v[pos_q0] = (X2(q1_v) + q0_v + p1_v + 2) >> 2; 1964 } 1965 } 1966} 1967 1968/*****************************************************************************/ 1969/* */ 1970/* Function Name : ih264_deblk_chroma_vert_bslt4_mbaff() */ 1971/* */ 1972/* Description : This function performs filtering of a chroma block */ 1973/* vertical edge when boundary strength is less than 4 in */ 1974/* high profile. */ 1975/* */ 1976/* Inputs : pu1_src - pointer to the src sample q0 of U */ 1977/* src_strd - source stride */ 1978/* alpha_cb - alpha value for the boundary in U */ 1979/* beta_cb - beta value for the boundary in U */ 1980/* alpha_cr - alpha value for the boundary in V */ 1981/* beta_cr - beta value for the boundary in V */ 1982/* u4_bs - packed Boundary strength array */ 1983/* pu1_cliptab_cb - tc0_table for U */ 1984/* pu1_cliptab_cr - tc0_table for V */ 1985/* */ 1986/* Globals : None */ 1987/* */ 1988/* Processing : When the function is called twice, this operation is as */ 1989/* described in Sec. 8.7.2.4 under the title "Filtering */ 1990/* process for edges for bS less than 4" in ITU T Rec H.264 */ 1991/* with alpha and beta values different in U and V. */ 1992/* */ 1993/* Outputs : None */ 1994/* */ 1995/* Returns : None */ 1996/* */ 1997/* Issues : None */ 1998/* */ 1999/* Revision History: */ 2000/* */ 2001/* DD MM YYYY Author(s) Changes (Describe the changes made) */ 2002/* 29 12 2014 Kaushik Draft */ 2003/* Senthoor */ 2004/* */ 2005/*****************************************************************************/ 2006void ih264_deblk_chroma_vert_bslt4_mbaff(UWORD8 *pu1_src, 2007 WORD32 src_strd, 2008 WORD32 alpha_cb, 2009 WORD32 beta_cb, 2010 WORD32 alpha_cr, 2011 WORD32 beta_cr, 2012 UWORD32 u4_bs, 2013 const UWORD8 *pu1_cliptab_cb, 2014 const UWORD8 *pu1_cliptab_cr) 2015{ 2016 UWORD8 *pu1_src_u = pu1_src; /* Pointer to the src sample q0 of plane U*/ 2017 UWORD8 *pu1_src_v = pu1_src + 1; /* Pointer to the src sample q0 of plane V*/ 2018 UWORD8 p1_u, p0_u, q0_u, q1_u, p1_v, p0_v, q0_v, q1_v; 2019 WORD32 blk_strd = src_strd; 2020 WORD32 pos_p1, pos_p0, pos_q0, pos_q1; 2021 UWORD8 *pu1_src_temp_u, *pu1_src_temp_v; 2022 WORD8 edge; 2023 WORD8 delta; 2024 WORD8 tcb, tcr; 2025 WORD16 val; 2026 UWORD8 tcb0, tcr0, u1_bs; 2027 2028 pos_q0 = 0; 2029 pos_q1 = 2; 2030 pos_p0 = -2; 2031 pos_p1 = -4; 2032 2033 for(edge = 0; edge < 4; 2034 edge++, pu1_src_u += blk_strd, pu1_src_v += blk_strd) 2035 { 2036 pu1_src_temp_u = pu1_src_u; 2037 pu1_src_temp_v = pu1_src_v; 2038 /* Filter Decision */ 2039 u1_bs = (UWORD8)((u4_bs >> ((3 - edge) << 3)) & 0x0ff); 2040 if(!u1_bs) 2041 continue; 2042 /* tc0 */ 2043 tcb0 = pu1_cliptab_cb[u1_bs]; 2044 tcr0 = pu1_cliptab_cr[u1_bs]; 2045 tcb = tcb0 + 1; 2046 tcr = tcr0 + 1; 2047 q0_u = pu1_src_temp_u[pos_q0]; 2048 q1_u = pu1_src_temp_u[pos_q1]; 2049 p0_u = pu1_src_temp_u[pos_p0]; 2050 p1_u = pu1_src_temp_u[pos_p1]; 2051 2052 q0_v = pu1_src_temp_v[pos_q0]; 2053 q1_v = pu1_src_temp_v[pos_q1]; 2054 p0_v = pu1_src_temp_v[pos_p0]; 2055 p1_v = pu1_src_temp_v[pos_p1]; 2056 2057 /* Filter Decision */ 2058 if((ABS(p0_u - q0_u) < alpha_cb) && 2059 (ABS(q1_u - q0_u) < beta_cb) && 2060 (ABS(p1_u - p0_u) < beta_cb)) 2061 { 2062 val = ((((q0_u - p0_u) << 2) + (p1_u - q1_u) + 4) >> 3); 2063 delta = CLIP3(-tcb, tcb, val); 2064 /* p0' */ 2065 val = p0_u + delta; 2066 pu1_src_temp_u[pos_p0] = CLIP_U8(val); 2067 /* q0' */ 2068 val = q0_u - delta; 2069 pu1_src_temp_u[pos_q0] = CLIP_U8(val); 2070 } 2071 2072 /* Filter Decision */ 2073 if((ABS(p0_v - q0_v) < alpha_cr) && 2074 (ABS(q1_v - q0_v) < beta_cr) && 2075 (ABS(p1_v - p0_v) < beta_cr)) 2076 { 2077 val = ((((q0_v - p0_v) << 2) + (p1_v - q1_v) + 4) >> 3); 2078 delta = CLIP3(-tcr, tcr, val); 2079 /* p0' */ 2080 val = p0_v + delta; 2081 pu1_src_temp_v[pos_p0] = CLIP_U8(val); 2082 /* q0' */ 2083 val = q0_v - delta; 2084 pu1_src_temp_v[pos_q0] = CLIP_U8(val); 2085 } 2086 } 2087} 2088