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 /*****************************************************************************/ 104 void 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 /*****************************************************************************/ 224 void 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 /*****************************************************************************/ 347 void 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 /*****************************************************************************/ 437 void 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 /*****************************************************************************/ 536 void 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 /*****************************************************************************/ 652 void 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 /*****************************************************************************/ 766 void 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 /*****************************************************************************/ 885 void 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 /*****************************************************************************/ 1009 void 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 /*****************************************************************************/ 1130 void 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 /*****************************************************************************/ 1219 void 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 /*****************************************************************************/ 1335 void 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 /*****************************************************************************/ 1453 void 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 /*****************************************************************************/ 1550 void 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 /*****************************************************************************/ 1655 void 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 /*****************************************************************************/ 1778 void 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 /*****************************************************************************/ 1910 void 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 /*****************************************************************************/ 2006 void 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
