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 23 * ih264_luma_intra_pred_filters.c 24 * 25 * @brief 26 * Contains function definitions for intra prediction filters 27 * 28 * @author 29 * Ittiam 30 * 31 * @par List of Functions: 32 * - ih264_intra_pred_luma_4x4_mode_vert 33 * - ih264_intra_pred_luma_4x4_mode_horz 34 * - ih264_intra_pred_luma_4x4_mode_dc 35 * - ih264_intra_pred_luma_4x4_mode_diag_dl 36 * - ih264_intra_pred_luma_4x4_mode_diag_dr 37 * - ih264_intra_pred_luma_4x4_mode_vert_r 38 * - ih264_intra_pred_luma_4x4_mode_horz_d 39 * - ih264_intra_pred_luma_4x4_mode_vert_l 40 * - ih264_intra_pred_luma_4x4_mode_horz_u 41 * - ih264_intra_pred_luma_8x8_mode_ref_filtering 42 * - ih264_intra_pred_luma_8x8_mode_vert 43 * - ih264_intra_pred_luma_8x8_mode_horz 44 * - ih264_intra_pred_luma_8x8_mode_dc 45 * - ih264_intra_pred_luma_8x8_mode_diag_dl 46 * - ih264_intra_pred_luma_8x8_mode_diag_dr 47 * - ih264_intra_pred_luma_8x8_mode_vert_r 48 * - ih264_intra_pred_luma_8x8_mode_horz_d 49 * - ih264_intra_pred_luma_8x8_mode_vert_l 50 * - ih264_intra_pred_luma_8x8_mode_horz_u 51 * - ih264_intra_pred_luma_16x16_mode_vert 52 * - ih264_intra_pred_luma_16x16_mode_horz 53 * - ih264_intra_pred_luma_16x16_mode_dc 54 * - ih264_intra_pred_luma_16x16_mode_plane 55 * 56 * 57 * @remarks 58 * None 59 * 60 ****************************************************************************** 61 */ 62 63/*****************************************************************************/ 64/* File Includes */ 65/*****************************************************************************/ 66/* System include files */ 67#include <stdio.h> 68#include <stddef.h> 69#include <string.h> 70 71/* User include files */ 72#include "ih264_defs.h" 73#include "ih264_typedefs.h" 74#include "ih264_macros.h" 75#include "ih264_platform_macros.h" 76#include "ih264_intra_pred_filters.h" 77 78/* Global variables used only in assembly files*/ 79const WORD8 ih264_gai1_intrapred_luma_plane_coeffs[] = 80{ 0x01, 0x02, 0x03, 0x04, 81 0x05, 0x06, 0x07, 0x08, 82 0x09, 0x0A, 0x0B, 0x0C, 83 0x0D, 0x0E, 0x0F, 0x10, }; 84 85const WORD8 ih264_gai1_intrapred_luma_8x8_horz_u[] = 86{ 0x06,0x15,0x05,0x14, 87 0x04,0x13,0x03,0x12, 88 0x02,0x11,0x01,0x10, 89 0x00,0x1F,0x0F,0x0F 90}; 91 92/******************* LUMA INTRAPREDICTION *******************/ 93 94/******************* 4x4 Modes *******************/ 95 96/** 97 ******************************************************************************* 98 * 99 *ih264_intra_pred_luma_4x4_mode_vert 100 * 101 * @brief 102 * Perform Intra prediction for luma_4x4 mode:vertical 103 * 104 * @par Description: 105 * Perform Intra prediction for luma_4x4 mode:vertical ,described in sec 8.3.1.2.1 106 * 107 * @param[in] pu1_src 108 * UWORD8 pointer to the source 109 * 110 * @param[out] pu1_dst 111 * UWORD8 pointer to the destination 112 * 113 * @param[in] src_strd 114 * integer source stride 115 * 116 * @param[in] dst_strd 117 * integer destination stride 118 * 119 * @param[in] ngbr_avail 120 * availability of neighbouring pixels(Not used in this function) 121 * 122 * @returns 123 * 124 * @remarks 125 * None 126 * 127 ******************************************************************************* 128 */ 129void ih264_intra_pred_luma_4x4_mode_vert(UWORD8 *pu1_src, 130 UWORD8 *pu1_dst, 131 WORD32 src_strd, 132 WORD32 dst_strd, 133 WORD32 ngbr_avail) 134{ 135 UWORD8 *pu1_top = NULL; /* Pointer to start of top predictors */ 136 UNUSED(src_strd); 137 UNUSED(ngbr_avail); 138 pu1_top = pu1_src + BLK_SIZE + 1; 139 140 memcpy(pu1_dst, pu1_top, 4); 141 memcpy(pu1_dst + dst_strd, pu1_top, 4); 142 memcpy(pu1_dst + 2 * dst_strd, pu1_top, 4); 143 memcpy(pu1_dst + 3 * dst_strd, pu1_top, 4); 144} 145 146/** 147 ******************************************************************************* 148 * 149 *ih264_intra_pred_luma_4x4_mode_horz 150 * 151 * @brief 152 * Perform Intra prediction for luma_4x4 mode:horizontal 153 * 154 * @par Description: 155 * Perform Intra prediction for luma_4x4 mode:horizontal ,described in sec 8.3.1.2.2 156 * 157 * @param[in] pu1_src 158 * UWORD8 pointer to the source 159 * 160 * @param[out] pu1_dst 161 * UWORD8 pointer to the destination 162 * 163 * @param[in] src_strd 164 * integer source stride 165 * 166 * @param[in] dst_strd 167 * integer destination stride 168 * 169 * @param[in] ngbr_avail 170 * availability of neighbouring pixels(Not used in this function) 171 * 172 * @returns 173 * 174 * @remarks 175 * None 176 * 177 ******************************************************************************* 178 */ 179void ih264_intra_pred_luma_4x4_mode_horz(UWORD8 *pu1_src, 180 UWORD8 *pu1_dst, 181 WORD32 src_strd, 182 WORD32 dst_strd, 183 WORD32 ngbr_avail) 184{ 185 UWORD8 *pu1_left = NULL; /* Pointer to start of left predictors */ 186 187 UNUSED(src_strd); 188 UNUSED(ngbr_avail); 189 pu1_left = pu1_src + BLK_SIZE - 1; 190 191 memset(pu1_dst, *pu1_left, 4); 192 memset(pu1_dst + dst_strd, *(pu1_left - 1), 4); 193 memset(pu1_dst + 2 * dst_strd, *(pu1_left - 2), 4); 194 memset(pu1_dst + 3 * dst_strd, *(pu1_left - 3), 4); 195} 196 197/** 198 ******************************************************************************* 199 * 200 *ih264_intra_pred_luma_4x4_mode_dc 201 * 202 * @brief 203 * Perform Intra prediction for luma_4x4 mode:DC 204 * 205 * @par Description: 206 * Perform Intra prediction for luma_4x4 mode:DC ,described in sec 8.3.1.2.3 207 * 208 * @param[in] pu1_src 209 * UWORD8 pointer to the source 210 * 211 * @param[out] pu1_dst 212 * UWORD8 pointer to the destination 213 * 214 * @param[in] src_strd 215 * integer source stride 216 * 217 * @param[in] dst_strd 218 * integer destination stride 219 * 220 * @param[in] ngbr_avail 221 * availability of neighbouring pixels 222 * 223 * @returns 224 * 225 * @remarks 226 * None 227 * 228 *******************************************************************************/ 229void ih264_intra_pred_luma_4x4_mode_dc(UWORD8 *pu1_src, 230 UWORD8 *pu1_dst, 231 WORD32 src_strd, 232 WORD32 dst_strd, 233 WORD32 ngbr_avail) 234{ 235 UWORD8 u1_useleft; /* availability of left predictors (only for DC) */ 236 UWORD8 u1_usetop; /* availability of top predictors (only for DC) */ 237 UWORD8 *pu1_left = NULL; /* Pointer to start of left predictors */ 238 UWORD8 *pu1_top = NULL; /* Pointer to start of top predictors */ 239 WORD32 val = 0; 240 UNUSED(src_strd); 241 UNUSED(ngbr_avail); 242 u1_useleft = BOOLEAN(ngbr_avail & LEFT_MB_AVAILABLE_MASK); 243 u1_usetop = BOOLEAN(ngbr_avail & TOP_MB_AVAILABLE_MASK); 244 pu1_top = pu1_src + BLK_SIZE + 1; 245 pu1_left = pu1_src + BLK_SIZE - 1; 246 247 if(u1_useleft) 248 { 249 val += *pu1_left--; 250 val += *pu1_left--; 251 val += *pu1_left--; 252 val += *pu1_left + 2; 253 } 254 if(u1_usetop) 255 { 256 val += *pu1_top + *(pu1_top + 1) + *(pu1_top + 2) + *(pu1_top + 3) 257 + 2; 258 } 259 /* Since 2 is added if either left/top pred is there, 260 val still being zero implies both preds are not there */ 261 val = (val) ? (val >> (1 + u1_useleft + u1_usetop)) : 128; 262 263 /* 4 bytes are copied from src to dst */ 264 memset(pu1_dst, val, 4); 265 memset(pu1_dst + dst_strd, val, 4); 266 memset(pu1_dst + 2 * dst_strd, val, 4); 267 memset(pu1_dst + 3 * dst_strd, val, 4); 268} 269 270/** 271 ******************************************************************************* 272 * 273 *ih264_intra_pred_luma_4x4_mode_diag_dl 274 * 275 * @brief 276 * Perform Intra prediction for luma_4x4 mode:Diagonal_Down_Left 277 * 278 * @par Description: 279 * Perform Intra prediction for luma_4x4 mode:Diagonal_Down_Left ,described in sec 8.3.1.2.4 280 * 281 * @param[in] pu1_src 282 * UWORD8 pointer to the source 283 * 284 * @param[out] pu1_dst 285 * UWORD8 pointer to the destination 286 * 287 * @param[in] src_strd 288 * integer source stride 289 * 290 * @param[in] dst_strd 291 * integer destination stride 292 * 293 * @param[in] ngbr_avail 294 * availability of neighbouring pixels(Not used in this function) 295 * 296 * @returns 297 * 298 * @remarks 299 * None 300 * 301 *******************************************************************************/ 302void ih264_intra_pred_luma_4x4_mode_diag_dl(UWORD8 *pu1_src, 303 UWORD8 *pu1_dst, 304 WORD32 src_strd, 305 WORD32 dst_strd, 306 WORD32 ngbr_avail) 307{ 308 UWORD8 *pu1_top = NULL; /* Pointer to start of top predictors */ 309 UWORD32 ui4_a, ui4_b, ui4_c, ui4_d, ui4_e, ui4_f, ui4_g, ui4_h; 310 UWORD8 predicted_pixels[7]; 311 UNUSED(src_strd); 312 UNUSED(ngbr_avail); 313 pu1_top = pu1_src +BLK_SIZE + 1; 314 315 ui4_a = *pu1_top++; 316 ui4_b = *pu1_top++; 317 ui4_c = *pu1_top++; 318 ui4_d = *pu1_top++; 319 ui4_e = *pu1_top++; 320 ui4_f = *pu1_top++; 321 ui4_g = *pu1_top++; 322 ui4_h = *pu1_top; 323 324 predicted_pixels[0] = FILT121(ui4_a, ui4_b, ui4_c); 325 predicted_pixels[1] = FILT121(ui4_b, ui4_c, ui4_d); 326 predicted_pixels[2] = FILT121(ui4_c, ui4_d, ui4_e); 327 predicted_pixels[3] = FILT121(ui4_d, ui4_e, ui4_f); 328 predicted_pixels[4] = FILT121(ui4_e, ui4_f, ui4_g); 329 predicted_pixels[5] = FILT121(ui4_f, ui4_g, ui4_h); 330 predicted_pixels[6] = FILT121(ui4_g, ui4_h, ui4_h); 331 332 memcpy(pu1_dst, predicted_pixels, 4); 333 memcpy(pu1_dst + dst_strd, predicted_pixels + 1, 4); 334 memcpy(pu1_dst + 2 * dst_strd, predicted_pixels + 2, 4); 335 memcpy(pu1_dst + 3 * dst_strd, predicted_pixels + 3, 4); 336} 337 338/** 339 ******************************************************************************* 340 * 341 *ih264_intra_pred_luma_4x4_mode_diag_dr 342 * 343 * @brief 344 * Perform Intra prediction for luma_4x4 mode:Diagonal_Down_Right 345 * 346 * @par Description: 347 * Perform Intra prediction for luma_4x4 mode:Diagonal_Down_Right ,described in sec 8.3.1.2.5 348 * 349 * @param[in] pu1_src 350 * UWORD8 pointer to the source 351 * 352 * @param[out] pu1_dst 353 * UWORD8 pointer to the destination 354 * 355 * @param[in] src_strd 356 * integer source stride 357 * 358 * @param[in] dst_strd 359 * integer destination stride 360 * 361 * @param[in] ngbr_avail 362 * availability of neighbouring pixels(Not used in this function) 363 * 364 * @returns 365 * 366 * @remarks 367 * None 368 * 369 *******************************************************************************/ 370void ih264_intra_pred_luma_4x4_mode_diag_dr(UWORD8 *pu1_src, 371 UWORD8 *pu1_dst, 372 WORD32 src_strd, 373 WORD32 dst_strd, 374 WORD32 ngbr_avail) 375{ 376 UWORD8 *pu1_top = NULL; /* Pointer to start of top predictors */ 377 UWORD8 *pu1_left = NULL; /* Pointer to start of left predictors */ 378 UWORD8 *pu1_topleft = NULL;/* Pointer to top left predictor */ 379 UWORD32 ui4_a, ui4_b, ui4_c, ui4_d, ui4_i, ui4_j, ui4_k, ui4_l, ui4_m; 380 UWORD8 predicted_pixels[7]; 381 UNUSED(src_strd); 382 UNUSED(ngbr_avail); 383 pu1_top = pu1_src + BLK_SIZE + 1; 384 pu1_left = pu1_src + BLK_SIZE - 1; 385 pu1_topleft = pu1_src +BLK_SIZE; 386 387 ui4_a = *pu1_top++; 388 ui4_b = *pu1_top++; 389 ui4_c = *pu1_top++; 390 ui4_d = *pu1_top++; 391 ui4_i = *pu1_left--; 392 ui4_j = *pu1_left--; 393 ui4_k = *pu1_left--; 394 ui4_l = *pu1_left; 395 ui4_m = *pu1_topleft; 396 397 predicted_pixels[2] = FILT121(ui4_j, ui4_i, ui4_m); 398 predicted_pixels[1] = FILT121(ui4_k, ui4_j, ui4_i); 399 predicted_pixels[0] = FILT121(ui4_l, ui4_k, ui4_j); 400 predicted_pixels[3] = FILT121(ui4_i, ui4_m, ui4_a); 401 predicted_pixels[4] = FILT121(ui4_m, ui4_a, ui4_b); 402 predicted_pixels[5] = FILT121(ui4_a, ui4_b, ui4_c); 403 predicted_pixels[6] = FILT121(ui4_b, ui4_c, ui4_d); 404 405 memcpy(pu1_dst, predicted_pixels + 3, 4); 406 memcpy(pu1_dst + dst_strd, predicted_pixels + 2, 4); 407 memcpy(pu1_dst + 2 * dst_strd, predicted_pixels + 1, 4); 408 memcpy(pu1_dst + 3 * dst_strd, predicted_pixels, 4); 409} 410 411/** 412 ******************************************************************************* 413 * 414 *ih264_intra_pred_luma_4x4_mode_vert_r 415 * 416 * @brief 417 * Perform Intra prediction for luma_4x4 mode:Vertical_Right 418 * 419 * @par Description: 420 * Perform Intra prediction for luma_4x4 mode:Vertical_Right ,described in sec 8.3.1.2.6 421 * 422 * @param[in] pu1_src 423 * UWORD8 pointer to the source 424 * 425 * @param[out] pu1_dst 426 * UWORD8 pointer to the destination 427 * 428 * @param[in] src_strd 429 * integer source stride 430 * 431 * @param[in] dst_strd 432 * integer destination stride 433 * 434 * @param[in] ngbr_avail 435 * availability of neighbouring pixels(Not used in this function) 436 * 437 * @returns 438 * 439 * @remarks 440 * None 441 * 442 *******************************************************************************/ 443void ih264_intra_pred_luma_4x4_mode_vert_r(UWORD8 *pu1_src, 444 UWORD8 *pu1_dst, 445 WORD32 src_strd, 446 WORD32 dst_strd, 447 WORD32 ngbr_avail) 448{ 449 450 UWORD32 ui4_a, ui4_b, ui4_c, ui4_d, ui4_i, ui4_j, ui4_k, ui4_m; 451 UWORD8 *pu1_top = NULL; /* Pointer to start of top predictors */ 452 UWORD8 *pu1_left = NULL; /* Pointer to start of left predictors */ 453 UWORD8 *pu1_topleft = NULL;/* Pointer to top left predictor */ 454 UWORD8 predicted_pixels[10]; 455 UNUSED(src_strd); 456 UNUSED(ngbr_avail); 457 pu1_top = pu1_src +BLK_SIZE + 1; 458 pu1_left = pu1_src + BLK_SIZE - 1; 459 pu1_topleft = pu1_src + BLK_SIZE; 460 461 ui4_a = *pu1_top++; 462 ui4_b = *pu1_top++; 463 ui4_c = *pu1_top++; 464 ui4_d = *pu1_top++; 465 ui4_i = *pu1_left--; 466 ui4_j = *pu1_left--; 467 ui4_k = *pu1_left; 468 ui4_m = *pu1_topleft; 469 470 predicted_pixels[6] = FILT11(ui4_m, ui4_a); 471 predicted_pixels[7] = FILT11(ui4_a, ui4_b); 472 predicted_pixels[8] = FILT11(ui4_b, ui4_c); 473 predicted_pixels[9] = FILT11(ui4_c, ui4_d); 474 predicted_pixels[1] = FILT121(ui4_i, ui4_m, ui4_a); 475 predicted_pixels[2] = FILT121(ui4_m, ui4_a, ui4_b); 476 predicted_pixels[3] = FILT121(ui4_a, ui4_b, ui4_c); 477 predicted_pixels[4] = FILT121(ui4_b, ui4_c, ui4_d); 478 predicted_pixels[5] = FILT121(ui4_j, ui4_i, ui4_m); 479 predicted_pixels[0] = FILT121(ui4_k, ui4_j, ui4_i); 480 481 memcpy(pu1_dst, predicted_pixels + 6, 4); 482 memcpy(pu1_dst + dst_strd, predicted_pixels + 1, 4); 483 memcpy(pu1_dst + 2 * dst_strd, predicted_pixels + 5, 4); 484 memcpy(pu1_dst + 3 * dst_strd, predicted_pixels, 4); 485} 486 487/* 488 ******************************************************************************* 489 * 490 *ih264_intra_pred_luma_4x4_mode_horz_d 491 * 492 * @brief 493 * Perform Intra prediction for luma_4x4 mode:Horizontal_Down 494 * 495 * @par Description: 496 * Perform Intra prediction for luma_4x4 mode:Horizontal_Down ,described in sec 8.3.1.2.7 497 * 498 * @param[in] pu1_src 499 * UWORD8 pointer to the source 500 * 501 * @param[out] pu1_dst 502 * UWORD8 pointer to the destination 503 * 504 * @param[in] src_strd 505 * integer source stride 506 * 507 * @param[in] dst_strd 508 * integer destination stride 509 * 510 * @param[in] ngbr_avail 511 * availability of neighbouring pixels(Not used in this function) 512 * 513 * @returns 514 * 515 * @remarks 516 * None 517 * 518 *******************************************************************************/ 519void ih264_intra_pred_luma_4x4_mode_horz_d(UWORD8 *pu1_src, 520 UWORD8 *pu1_dst, 521 WORD32 src_strd, 522 WORD32 dst_strd, 523 WORD32 ngbr_avail) 524{ 525 UWORD8 *pu1_top = NULL; /* Pointer to start of top predictors */ 526 UWORD8 *pu1_left = NULL; /* Pointer to start of left predictors */ 527 UWORD8 *pu1_topleft = NULL;/* Pointer to top left predictor */ 528 UWORD32 ui4_a, ui4_b, ui4_c, ui4_i, ui4_j, ui4_k, ui4_l, ui4_m; 529 UWORD8 predicted_pixels[10]; 530 UNUSED(src_strd); 531 UNUSED(ngbr_avail); 532 pu1_top = pu1_src + BLK_SIZE + 1; 533 pu1_left = pu1_src + BLK_SIZE - 1; 534 pu1_topleft = pu1_src + BLK_SIZE; 535 536 ui4_a = *pu1_top++; 537 ui4_b = *pu1_top++; 538 ui4_c = *pu1_top++; 539 ui4_i = *pu1_left--; 540 ui4_j = *pu1_left--; 541 ui4_k = *pu1_left--; 542 ui4_l = *pu1_left--; 543 ui4_m = *pu1_topleft; 544 545 predicted_pixels[6] = FILT11(ui4_i, ui4_m); 546 predicted_pixels[7] = FILT121(ui4_i, ui4_m, ui4_a); 547 predicted_pixels[8] = FILT121(ui4_m, ui4_a, ui4_b); 548 predicted_pixels[9] = FILT121(ui4_a, ui4_b, ui4_c); 549 predicted_pixels[1] = FILT121(ui4_l, ui4_k, ui4_j); 550 predicted_pixels[2] = FILT11(ui4_k, ui4_j); 551 predicted_pixels[3] = FILT121(ui4_k, ui4_j, ui4_i); 552 predicted_pixels[4] = FILT11(ui4_j, ui4_i); 553 predicted_pixels[5] = FILT121(ui4_j, ui4_i, ui4_m); 554 predicted_pixels[0] = FILT11(ui4_l, ui4_k); 555 556 memcpy(pu1_dst, predicted_pixels + 6, 4); 557 memcpy(pu1_dst + dst_strd, predicted_pixels + 4, 4); 558 memcpy(pu1_dst + 2 * dst_strd, predicted_pixels + 2, 4); 559 memcpy(pu1_dst + 3 * dst_strd, predicted_pixels, 4); 560} 561 562/** 563 ******************************************************************************* 564 * 565 *ih264_intra_pred_luma_4x4_mode_vert_l 566 * 567 * @brief 568 * Perform Intra prediction for luma_4x4 mode:Vertical_Left 569 * 570 * @par Description: 571 * Perform Intra prediction for luma_4x4 mode:Vertical_Left ,described in sec 8.3.1.2.8 572 * 573 * @param[in] pu1_src 574 * UWORD8 pointer to the source 575 * 576 * @param[out] pu1_dst 577 * UWORD8 pointer to the destination 578 * 579 * @param[in] src_strd 580 * integer source stride 581 * 582 * @param[in] dst_strd 583 * integer destination stride 584 * 585 * @param[in] ngbr_avail 586 * availability of neighbouring pixels(Not used in this function) 587 * 588 * @returns 589 * 590 * @remarks 591 * None 592 * 593 *******************************************************************************/ 594void ih264_intra_pred_luma_4x4_mode_vert_l(UWORD8 *pu1_src, 595 UWORD8 *pu1_dst, 596 WORD32 src_strd, 597 WORD32 dst_strd, 598 WORD32 ngbr_avail) 599{ 600 UWORD8 *pu1_top = NULL; /* Pointer to start of top predictors */ 601 UWORD32 ui4_a, ui4_b, ui4_c, ui4_d, ui4_e, ui4_f, ui4_g; 602 UWORD8 predicted_pixels[10]; 603 UNUSED(src_strd); 604 UNUSED(ngbr_avail); 605 pu1_top = pu1_src + BLK_SIZE + 1; 606 607 ui4_a = *pu1_top++; 608 ui4_b = *pu1_top++; 609 ui4_c = *pu1_top++; 610 ui4_d = *pu1_top++; 611 ui4_e = *pu1_top++; 612 ui4_f = *pu1_top++; 613 ui4_g = *pu1_top; 614 615 predicted_pixels[5] = FILT11(ui4_a, ui4_b); 616 predicted_pixels[6] = FILT11(ui4_b, ui4_c); 617 predicted_pixels[7] = FILT11(ui4_c, ui4_d); 618 predicted_pixels[8] = FILT11(ui4_d, ui4_e); 619 predicted_pixels[0] = FILT121(ui4_a, ui4_b, ui4_c); 620 predicted_pixels[1] = FILT121(ui4_b, ui4_c, ui4_d); 621 predicted_pixels[2] = FILT121(ui4_c, ui4_d, ui4_e); 622 predicted_pixels[3] = FILT121(ui4_d, ui4_e, ui4_f); 623 predicted_pixels[9] = FILT11(ui4_e, ui4_f); 624 predicted_pixels[4] = FILT121(ui4_e, ui4_f, ui4_g); 625 626 memcpy(pu1_dst, predicted_pixels + 5, 4); 627 memcpy(pu1_dst + dst_strd, predicted_pixels, 4); 628 memcpy(pu1_dst + 2 * dst_strd, predicted_pixels + 6, 4); 629 memcpy(pu1_dst + 3 * dst_strd, predicted_pixels + 1, 4); 630} 631 632/** 633 ******************************************************************************* 634 * 635 *ih264_intra_pred_luma_4x4_mode_horz_u 636 * 637 * @brief 638 * Perform Intra prediction for luma_4x4 mode:Horizontal_Up 639 * 640 * @par Description: 641 * Perform Intra prediction for luma_4x4 mode:Horizontal_Up ,described in sec 8.3.1.2.9 642 * 643 * @param[in] pu1_src 644 * UWORD8 pointer to the source 645 * 646 * @param[out] pu1_dst 647 * UWORD8 pointer to the destination 648 * 649 * @param[in] src_strd 650 * integer source stride 651 * 652 * @param[in] dst_strd 653 * integer destination stride 654 * 655 * @param[in] ngbr_avail 656 * availability of neighbouring pixels(Not used in this function) 657 * 658 * @returns 659 * 660 * @remarks 661 * None 662 * 663 *******************************************************************************/ 664void ih264_intra_pred_luma_4x4_mode_horz_u(UWORD8 *pu1_src, 665 UWORD8 *pu1_dst, 666 WORD32 src_strd, 667 WORD32 dst_strd, 668 WORD32 ngbr_avail) 669{ 670 UWORD8 *pu1_left = NULL; /* Pointer to start of left predictors */ 671 UWORD32 ui4_i, ui4_j, ui4_k, ui4_l; 672 UWORD8 predicted_pixels[10]; 673 UNUSED(src_strd); 674 UNUSED(ngbr_avail); 675 pu1_left = pu1_src + BLK_SIZE - 1; 676 677 ui4_i = *pu1_left--; 678 ui4_j = *pu1_left--; 679 ui4_k = *pu1_left--; 680 ui4_l = *pu1_left--; 681 682 predicted_pixels[0] = FILT11(ui4_j, ui4_i); 683 predicted_pixels[1] = FILT121(ui4_k, ui4_j, ui4_i); 684 predicted_pixels[2] = FILT11(ui4_k, ui4_j); 685 predicted_pixels[3] = FILT121(ui4_l, ui4_k, ui4_j); 686 predicted_pixels[4] = FILT11(ui4_l, ui4_k); 687 predicted_pixels[5] = FILT121(ui4_l, ui4_l, ui4_k); 688 predicted_pixels[6] = ui4_l; 689 predicted_pixels[7] = ui4_l; 690 predicted_pixels[8] = ui4_l; 691 predicted_pixels[9] = ui4_l; 692 693 memcpy(pu1_dst, predicted_pixels, 4); 694 memcpy(pu1_dst + dst_strd, predicted_pixels + 2, 4); 695 memcpy(pu1_dst + 2 * dst_strd, predicted_pixels + 4, 4); 696 memcpy(pu1_dst + 3 * dst_strd, predicted_pixels + 6, 4); 697} 698 699/******************* 8x8 Modes *******************/ 700 701/** 702 ******************************************************************************* 703 * 704 *ih264_intra_pred_luma_8x8_mode_ref_filtering 705 * 706 * @brief 707 * Reference sample filtering process for Intra_8x8 sample prediction 708 * 709 * @par Description: 710 * Perform Reference sample filtering process for Intra_8x8 sample prediction ,described in sec 8.3.2.2.1 711 * 712 * @param[in] pu1_src 713 * UWORD8 pointer to the source 714 * 715 * @param[out] pu1_dst 716 * UWORD8 pointer to the destination 717 * 718 * @param[in] src_strd 719 * integer source stride[Not Used] 720 * 721 * @param[in] dst_strd 722 * integer destination stride[Not Used] 723 * 724 * @param[in] ngbr_avail 725 * availability of neighbouring pixels(Not used in this function) 726 * 727 * @returns 728 * 729 * @remarks 730 * None 731 * 732 * 733 *******************************************************************************/ 734void ih264_intra_pred_luma_8x8_mode_ref_filtering(UWORD8 *pu1_left, 735 UWORD8 *pu1_topleft, 736 UWORD8 *pu1_top, 737 UWORD8 *pu1_dst, 738 WORD32 left_strd, 739 WORD32 ngbr_avail) 740{ 741 WORD32 top_avail, left_avail, top_left_avail, top_right_avail; 742 743 left_avail = BOOLEAN(ngbr_avail & LEFT_MB_AVAILABLE_MASK); 744 top_avail = BOOLEAN(ngbr_avail & TOP_MB_AVAILABLE_MASK); 745 top_left_avail = BOOLEAN(ngbr_avail & TOP_LEFT_MB_AVAILABLE_MASK); 746 top_right_avail = BOOLEAN(ngbr_avail & TOP_RIGHT_MB_AVAILABLE_MASK); 747 748 if(top_avail) 749 { 750 WORD32 i; 751 UWORD32 u4_xm1; 752 753 if(!top_right_avail) 754 { 755 memset(pu1_dst + 8 + 1 + 8, pu1_top[7], 8); 756 top_right_avail = 1; 757 } 758 else 759 { 760 memcpy(pu1_dst + 8 + 1 + 8, pu1_top + 8, 8); 761 } 762 763 if(top_left_avail) 764 { 765 pu1_dst[8 + 1 + 0] = FILT121((*pu1_topleft), pu1_top[0], 766 pu1_top[1]); 767 768 } 769 else 770 { 771 pu1_dst[8 + 1] = ((3 * pu1_top[0]) + pu1_top[1] + 2) >> 2; 772 } 773 774 for(i = 1; i <= 6; i++) 775 { 776 pu1_dst[8 + 1 + i] = FILT121(pu1_top[i - 1], pu1_top[i], 777 pu1_top[i + 1]); 778 779 } 780 /* First byte of Top Right input is in pu1_dst[8 + 1 + 8]*/ 781 pu1_dst[8 + 1 + 7] = FILT121(pu1_top[6], pu1_top[7], 782 pu1_dst[8 + 1 + 8]); 783 784 /* filtered output and source in same buf, to prevent output(x - 1) 785 being over written in process */ 786 u4_xm1 = pu1_top[7]; 787 788 for(i = 8; i <= 14; i++) 789 { 790 UWORD32 u4_x; 791 u4_x = (u4_xm1 + (pu1_dst[8 + 1 + i] << 1) + pu1_dst[8 + 1 + i + 1] 792 + 2) >> 2; 793 /* assigning u4_xm1 from the un-filtered values for the next iteration */ 794 u4_xm1 = pu1_dst[8 + 1 + i]; 795 pu1_dst[8 + 1 + i] = u4_x; 796 } 797 798 pu1_dst[8 + 1 + 15] = (u4_xm1 + (3 * pu1_dst[8 + 1 + 15]) + 2) >> 2; 799 800 } 801 802 /* pu1_topleft is overloaded. It is both: */ 803 /* a. A pointer for the top left pixel */ 804 /* b. An indicator of availability of top left. */ 805 /* If it is null then top left not available */ 806 if(top_left_avail) 807 { 808 if((!top_avail) || (!left_avail)) 809 { 810 if(top_avail) 811 pu1_dst[8] = (3 * pu1_topleft[0] + pu1_top[0] + 2) >> 2; 812 else if(left_avail) 813 pu1_dst[8] = (3 * pu1_topleft[0] + pu1_left[0] + 2) >> 2; 814 } 815 else 816 { 817 pu1_dst[8] = FILT121(pu1_top[0], (*pu1_topleft), pu1_left[0]); 818 } 819 } 820 821 if(left_avail) 822 { 823 UWORD32 idx; 824 if(0 != pu1_topleft) 825 { 826 pu1_dst[7] = FILT121((*pu1_topleft), pu1_left[0], 827 pu1_left[left_strd]); 828 } 829 else 830 { 831 pu1_dst[7] = ((3 * pu1_left[0]) + pu1_left[left_strd] + 2) >> 2; 832 } 833 834 for(idx = 1; idx <= 6; idx++) 835 { 836 pu1_dst[7 - idx] = FILT121(pu1_left[(idx - 1) * left_strd], 837 pu1_left[idx * left_strd], 838 pu1_left[(idx + 1) * left_strd]); 839 840 } 841 pu1_dst[0] = (pu1_left[6 * left_strd] + 3 * pu1_left[7 * left_strd] + 2) 842 >> 2; 843 844 } 845} 846 847/** 848 ******************************************************************************* 849 * 850 *ih264_intra_pred_luma_8x8_mode_vert 851 * 852 * @brief 853 * Perform Intra prediction for luma_8x8 mode:vertical 854 * 855 * @par Description: 856 * Perform Intra prediction for luma_8x8 mode:vertical ,described in sec 8.3.2.2.2 857 * 858 * @param[in] pu1_src 859 * UWORD8 pointer to the source 860 * 861 * @param[out] pu1_dst 862 * UWORD8 pointer to the destination 863 * 864 * @param[in] src_strd 865 * integer source stride 866 * 867 * @param[in] dst_strd 868 * integer destination stride 869 * 870 * @param[in] ngbr_avail 871 * availability of neighbouring pixels(Not used in this function) 872 * 873 * @returns 874 * 875 * @remarks 876 * None 877 * 878 ******************************************************************************* 879 */ 880void ih264_intra_pred_luma_8x8_mode_vert(UWORD8 *pu1_src, 881 UWORD8 *pu1_dst, 882 WORD32 src_strd, 883 WORD32 dst_strd, 884 WORD32 ngbr_avail) 885{ 886 UWORD8 *pu1_top = NULL; 887 UNUSED(src_strd); 888 UNUSED(ngbr_avail); 889 pu1_top = pu1_src + BLK8x8SIZE + 1; 890 891 memcpy(pu1_dst, pu1_top, 8); 892 memcpy(pu1_dst + dst_strd, pu1_top, 8); 893 memcpy(pu1_dst + 2 * dst_strd, pu1_top, 8); 894 memcpy(pu1_dst + 3 * dst_strd, pu1_top, 8); 895 memcpy(pu1_dst + 4 * dst_strd, pu1_top, 8); 896 memcpy(pu1_dst + 5 * dst_strd, pu1_top, 8); 897 memcpy(pu1_dst + 6 * dst_strd, pu1_top, 8); 898 memcpy(pu1_dst + 7 * dst_strd, pu1_top, 8); 899} 900 901/** 902 ******************************************************************************* 903 * 904 *ih264_intra_pred_luma_8x8_mode_horz 905 * 906 * @brief 907 * Perform Intra prediction for luma_8x8 mode:horizontal 908 * 909 * @par Description: 910 * Perform Intra prediction for luma_8x8 mode:horizontal ,described in sec 8.3.2.2.2 911 * 912 * @param[in] pu1_src 913 * UWORD8 pointer to the source 914 * 915 * @param[out] pu1_dst 916 * UWORD8 pointer to the destination 917 * 918 * @param[in] src_strd 919 * integer source stride 920 * 921 * @param[in] dst_strd 922 * integer destination stride 923 * 924 * @param[in] ngbr_avail 925 * availability of neighbouring pixels(Not used in this function) 926 * 927 * @returns 928 * 929 * @remarks 930 * None 931 * 932 ******************************************************************************* 933 */ 934 935void ih264_intra_pred_luma_8x8_mode_horz(UWORD8 *pu1_src, 936 UWORD8 *pu1_dst, 937 WORD32 src_strd, 938 WORD32 dst_strd, 939 WORD32 ngbr_avail) 940{ 941 UWORD8 *pu1_left = pu1_src + BLK8x8SIZE - 1; 942 UNUSED(src_strd); 943 UNUSED(ngbr_avail); 944 memset(pu1_dst, *pu1_left, 8); 945 memset(pu1_dst + dst_strd, *(pu1_left - 1), 8); 946 memset(pu1_dst + 2 * dst_strd, *(pu1_left - 2), 8); 947 memset(pu1_dst + 3 * dst_strd, *(pu1_left - 3), 8); 948 memset(pu1_dst + 4 * dst_strd, *(pu1_left - 4), 8); 949 memset(pu1_dst + 5 * dst_strd, *(pu1_left - 5), 8); 950 memset(pu1_dst + 6 * dst_strd, *(pu1_left - 6), 8); 951 memset(pu1_dst + 7 * dst_strd, *(pu1_left - 7), 8); 952} 953 954/** 955 ******************************************************************************* 956 * 957 *ih264_intra_pred_luma_8x8_mode_dc 958 * 959 * @brief 960 * Perform Intra prediction for luma_8x8 mode:DC 961 * 962 * @par Description: 963 * Perform Intra prediction for luma_8x8 mode:DC ,described in sec 8.3.2.2.4 964 * 965 * @param[in] pu1_src 966 * UWORD8 pointer to the source 967 * 968 * @param[out] pu1_dst 969 * UWORD8 pointer to the destination 970 * 971 * @param[in] src_strd 972 * integer source stride 973 * 974 * @param[in] dst_strd 975 * integer destination stride 976 * 977 * @param[in] ngbr_avail 978 * availability of neighbouring pixels 979 * 980 * @returns 981 * 982 * @remarks 983 * None 984 * 985 *******************************************************************************/ 986void ih264_intra_pred_luma_8x8_mode_dc(UWORD8 *pu1_src, 987 UWORD8 *pu1_dst, 988 WORD32 src_strd, 989 WORD32 dst_strd, 990 WORD32 ngbr_avail) 991{ 992 UWORD8 u1_useleft; /* availability of left predictors (only for DC) */ 993 UWORD8 u1_usetop; /* availability of top predictors (only for DC) */ 994 UWORD8 *pu1_left = NULL; /* Pointer to start of left predictors */ 995 UWORD8 *pu1_top = NULL; /* Pointer to start of top predictors */ 996 WORD32 row; 997 WORD32 val = 0; 998 UNUSED(src_strd); 999 1000 u1_useleft = BOOLEAN(ngbr_avail & LEFT_MB_AVAILABLE_MASK); 1001 u1_usetop = BOOLEAN(ngbr_avail & TOP_MB_AVAILABLE_MASK); 1002 pu1_top = pu1_src + BLK8x8SIZE + 1; 1003 pu1_left = pu1_src + BLK8x8SIZE - 1; 1004 1005 if(u1_useleft) 1006 { 1007 for(row = 0; row < BLK8x8SIZE; row++) 1008 val += *(pu1_left - row); 1009 val += 4; 1010 } 1011 if(u1_usetop) 1012 { 1013 for(row = 0; row < BLK8x8SIZE; row++) 1014 val += *(pu1_top + row); 1015 val += 4; 1016 } 1017 1018 /* Since 4 is added if either left/top pred is there, 1019 val still being zero implies both preds are not there */ 1020 val = (val) ? (val >> (2 + u1_useleft + u1_usetop)) : 128; 1021 1022 memset(pu1_dst, val, 8); 1023 memset(pu1_dst + dst_strd, val, 8); 1024 memset(pu1_dst + 2 * dst_strd, val, 8); 1025 memset(pu1_dst + 3 * dst_strd, val, 8); 1026 memset(pu1_dst + 4 * dst_strd, val, 8); 1027 memset(pu1_dst + 5 * dst_strd, val, 8); 1028 memset(pu1_dst + 6 * dst_strd, val, 8); 1029 memset(pu1_dst + 7 * dst_strd, val, 8); 1030} 1031 1032/** 1033 ******************************************************************************* 1034 * 1035 *ih264_intra_pred_luma_8x8_mode_diag_dl 1036 * 1037 * @brief 1038 * Perform Intra prediction for luma_8x8 mode:Diagonal_Down_Left 1039 * 1040 * @par Description: 1041 * Perform Intra prediction for luma_8x8 mode:Diagonal_Down_Left ,described in sec 8.3.2.2.5 1042 * 1043 * @param[in] pu1_src 1044 * UWORD8 pointer to the source 1045 * 1046 * @param[out] pu1_dst 1047 * UWORD8 pointer to the destination 1048 * 1049 * @param[in] src_strd 1050 * integer source stride 1051 * 1052 * @param[in] dst_strd 1053 * integer destination stride 1054 * 1055 * @param[in] ngbr_avail 1056 * availability of neighbouring pixels(Not used in this function) 1057 * 1058 * @returns 1059 * 1060 * @remarks 1061 * None 1062 * 1063 *******************************************************************************/ 1064void ih264_intra_pred_luma_8x8_mode_diag_dl(UWORD8 *pu1_src, 1065 UWORD8 *pu1_dst, 1066 WORD32 src_strd, 1067 WORD32 dst_strd, 1068 WORD32 ngbr_avail) 1069{ 1070 UWORD8 *pu1_top = NULL; /* Pointer to start of top predictors */ 1071 UWORD32 ui4_a, ui4_b, ui4_c, ui4_d, ui4_e, ui4_f, ui4_g, ui4_h; 1072 UWORD32 ui4_i, ui4_j, ui4_k, ui4_l, ui4_m, ui4_n, ui4_o, ui4_p; 1073 UWORD8 predicted_pixels[15]; 1074 UNUSED(src_strd); 1075 UNUSED(ngbr_avail); 1076 pu1_top = pu1_src + BLK8x8SIZE + 1; 1077 1078 ui4_a = *pu1_top++; 1079 ui4_b = *pu1_top++; 1080 ui4_c = *pu1_top++; 1081 ui4_d = *pu1_top++; 1082 ui4_e = *pu1_top++; 1083 ui4_f = *pu1_top++; 1084 ui4_g = *pu1_top++; 1085 ui4_h = *pu1_top++; 1086 ui4_i = *pu1_top++; 1087 ui4_j = *pu1_top++; 1088 ui4_k = *pu1_top++; 1089 ui4_l = *pu1_top++; 1090 ui4_m = *pu1_top++; 1091 ui4_n = *pu1_top++; 1092 ui4_o = *pu1_top++; 1093 ui4_p = *pu1_top; 1094 1095 predicted_pixels[0] = FILT121(ui4_a, ui4_b, ui4_c); 1096 predicted_pixels[1] = FILT121(ui4_b, ui4_c, ui4_d); 1097 predicted_pixels[2] = FILT121(ui4_c, ui4_d, ui4_e); 1098 predicted_pixels[3] = FILT121(ui4_d, ui4_e, ui4_f); 1099 predicted_pixels[4] = FILT121(ui4_e, ui4_f, ui4_g); 1100 predicted_pixels[5] = FILT121(ui4_f, ui4_g, ui4_h); 1101 predicted_pixels[6] = FILT121(ui4_g, ui4_h, ui4_i); 1102 predicted_pixels[7] = FILT121(ui4_h, ui4_i, ui4_j); 1103 predicted_pixels[8] = FILT121(ui4_i, ui4_j, ui4_k); 1104 predicted_pixels[9] = FILT121(ui4_j, ui4_k, ui4_l); 1105 predicted_pixels[10] = FILT121(ui4_k, ui4_l, ui4_m); 1106 predicted_pixels[11] = FILT121(ui4_l, ui4_m, ui4_n); 1107 predicted_pixels[12] = FILT121(ui4_m, ui4_n, ui4_o); 1108 predicted_pixels[13] = FILT121(ui4_n, ui4_o, ui4_p); 1109 predicted_pixels[14] = FILT121(ui4_o, ui4_p, ui4_p); 1110 1111 memcpy(pu1_dst, predicted_pixels, 8); 1112 memcpy(pu1_dst + dst_strd, predicted_pixels + 1, 8); 1113 memcpy(pu1_dst + 2 * dst_strd, predicted_pixels + 2, 8); 1114 memcpy(pu1_dst + 3 * dst_strd, predicted_pixels + 3, 8); 1115 memcpy(pu1_dst + 4 * dst_strd, predicted_pixels + 4, 8); 1116 memcpy(pu1_dst + 5 * dst_strd, predicted_pixels + 5, 8); 1117 memcpy(pu1_dst + 6 * dst_strd, predicted_pixels + 6, 8); 1118 memcpy(pu1_dst + 7 * dst_strd, predicted_pixels + 7, 8); 1119} 1120 1121/** 1122 ******************************************************************************* 1123 * 1124 *ih264_intra_pred_luma_8x8_mode_diag_dr 1125 * 1126 * @brief 1127 * Perform Intra prediction for luma_8x8 mode:Diagonal_Down_Right 1128 * 1129 * @par Description: 1130 * Perform Intra prediction for luma_8x8 mode:Diagonal_Down_Right ,described in sec 8.3.2.2.6 1131 * 1132 * @param[in] pu1_src 1133 * UWORD8 pointer to the source 1134 * 1135 * @param[out] pu1_dst 1136 * UWORD8 pointer to the destination 1137 * 1138 * @param[in] src_strd 1139 * integer source stride 1140 * 1141 * @param[in] dst_strd 1142 * integer destination stride 1143 * 1144 * @param[in] ngbr_avail 1145 * availability of neighbouring pixels(Not used in this function) 1146 * 1147 * @returns 1148 * 1149 * @remarks 1150 * None 1151 * 1152 *******************************************************************************/ 1153void ih264_intra_pred_luma_8x8_mode_diag_dr(UWORD8 *pu1_src, 1154 UWORD8 *pu1_dst, 1155 WORD32 src_strd, 1156 WORD32 dst_strd, 1157 WORD32 ngbr_avail) 1158{ 1159 UWORD8 *pu1_left = NULL; /* Pointer to start of left predictors */ 1160 UWORD8 *pu1_top = NULL; /* Pointer to start of top predictors */ 1161 UWORD8 *pu1_topleft = NULL; /* Pointer to start of top left predictors */ 1162 UWORD32 ui4_a; 1163 UWORD32 ui4_b, ui4_c, ui4_d, ui4_e, ui4_f, ui4_g, ui4_h, ui4_i; 1164 UWORD32 ui4_j, ui4_k, ui4_l, ui4_m, ui4_n, ui4_o, ui4_p, ui4_q; 1165 UWORD8 predicted_pixels[15]; 1166 UNUSED(src_strd); 1167 UNUSED(ngbr_avail); 1168 pu1_top = pu1_src + BLK8x8SIZE + 1; 1169 pu1_left = pu1_src + BLK8x8SIZE - 1; 1170 pu1_topleft = pu1_src + BLK8x8SIZE; 1171 1172 ui4_a = *pu1_topleft; 1173 ui4_b = *pu1_top++; 1174 ui4_c = *pu1_top++; 1175 ui4_d = *pu1_top++; 1176 ui4_e = *pu1_top++; 1177 ui4_f = *pu1_top++; 1178 ui4_g = *pu1_top++; 1179 ui4_h = *pu1_top++; 1180 ui4_i = *pu1_top; 1181 ui4_j = *pu1_left--; 1182 ui4_k = *pu1_left--; 1183 ui4_l = *pu1_left--; 1184 ui4_m = *pu1_left--; 1185 ui4_n = *pu1_left--; 1186 ui4_o = *pu1_left--; 1187 ui4_p = *pu1_left--; 1188 ui4_q = *pu1_left; 1189 1190 predicted_pixels[6] = FILT121(ui4_a, ui4_j, ui4_k); 1191 predicted_pixels[5] = FILT121(ui4_j, ui4_k, ui4_l); 1192 predicted_pixels[4] = FILT121(ui4_k, ui4_l, ui4_m); 1193 predicted_pixels[3] = FILT121(ui4_l, ui4_m, ui4_n); 1194 predicted_pixels[2] = FILT121(ui4_m, ui4_n, ui4_o); 1195 predicted_pixels[1] = FILT121(ui4_n, ui4_o, ui4_p); 1196 predicted_pixels[0] = FILT121(ui4_o, ui4_p, ui4_q); 1197 predicted_pixels[7] = FILT121(ui4_b, ui4_a, ui4_j); 1198 predicted_pixels[8] = FILT121(ui4_a, ui4_b, ui4_c); 1199 predicted_pixels[9] = FILT121(ui4_b, ui4_c, ui4_d); 1200 predicted_pixels[10] = FILT121(ui4_c, ui4_d, ui4_e); 1201 predicted_pixels[11] = FILT121(ui4_d, ui4_e, ui4_f); 1202 predicted_pixels[12] = FILT121(ui4_e, ui4_f, ui4_g); 1203 predicted_pixels[13] = FILT121(ui4_f, ui4_g, ui4_h); 1204 predicted_pixels[14] = FILT121(ui4_g, ui4_h, ui4_i); 1205 1206 memcpy(pu1_dst, predicted_pixels + 7, 8); 1207 memcpy(pu1_dst + dst_strd, predicted_pixels + 6, 8); 1208 memcpy(pu1_dst + 2 * dst_strd, predicted_pixels + 5, 8); 1209 memcpy(pu1_dst + 3 * dst_strd, predicted_pixels + 4, 8); 1210 memcpy(pu1_dst + 4 * dst_strd, predicted_pixels + 3, 8); 1211 memcpy(pu1_dst + 5 * dst_strd, predicted_pixels + 2, 8); 1212 memcpy(pu1_dst + 6 * dst_strd, predicted_pixels + 1, 8); 1213 memcpy(pu1_dst + 7 * dst_strd, predicted_pixels, 8); 1214} 1215 1216/** 1217 ******************************************************************************* 1218 * 1219 *ih264_intra_pred_luma_8x8_mode_vert_r 1220 * 1221 * @brief 1222 * Perform Intra prediction for luma_8x8 mode:Vertical_Right 1223 * 1224 * @par Description: 1225 * Perform Intra prediction for luma_8x8 mode:Vertical_Right ,described in sec 8.3.2.2.7 1226 * 1227 * @param[in] pu1_src 1228 * UWORD8 pointer to the source 1229 * 1230 * @param[out] pu1_dst 1231 * UWORD8 pointer to the destination 1232 * 1233 * @param[in] src_strd 1234 * integer source stride 1235 * 1236 * @param[in] dst_strd 1237 * integer destination stride 1238 * 1239 * @param[in] ngbr_avail 1240 * availability of neighbouring pixels(Not used in this function) 1241 * 1242 * @returns 1243 * 1244 * @remarks 1245 * None 1246 * 1247 *******************************************************************************/ 1248void ih264_intra_pred_luma_8x8_mode_vert_r(UWORD8 *pu1_src, 1249 UWORD8 *pu1_dst, 1250 WORD32 src_strd, 1251 WORD32 dst_strd, 1252 WORD32 ngbr_avail) 1253{ 1254 UWORD8 *pu1_left = NULL; /* Pointer to start of left predictors */ 1255 UWORD8 *pu1_top = NULL; /* Pointer to start of top predictors */ 1256 UWORD8 *pu1_topleft = NULL; /* Pointer to start of top left predictors */ 1257 UWORD32 ui4_a; 1258 UWORD32 ui4_b, ui4_c, ui4_d, ui4_e, ui4_f, ui4_g, ui4_h, ui4_i; 1259 UWORD32 ui4_j, ui4_k, ui4_l, ui4_m, ui4_n, ui4_o, ui4_p; 1260 UWORD8 predicted_pixels[22]; 1261 1262 UNUSED(src_strd); 1263 UNUSED(ngbr_avail); 1264 pu1_top = pu1_src + BLK8x8SIZE + 1; 1265 pu1_left = pu1_src + BLK8x8SIZE - 1; 1266 pu1_topleft = pu1_src + BLK8x8SIZE; 1267 1268 ui4_a = *pu1_topleft; 1269 1270 ui4_b = *pu1_top++; 1271 ui4_c = *pu1_top++; 1272 ui4_d = *pu1_top++; 1273 ui4_e = *pu1_top++; 1274 ui4_f = *pu1_top++; 1275 ui4_g = *pu1_top++; 1276 ui4_h = *pu1_top++; 1277 ui4_i = *pu1_top; 1278 ui4_j = *pu1_left--; 1279 ui4_k = *pu1_left--; 1280 ui4_l = *pu1_left--; 1281 ui4_m = *pu1_left--; 1282 ui4_n = *pu1_left--; 1283 ui4_o = *pu1_left--; 1284 ui4_p = *pu1_left--; 1285 1286 predicted_pixels[0] = FILT121(ui4_o, ui4_n, ui4_m); 1287 predicted_pixels[1] = FILT121(ui4_m, ui4_l, ui4_k); 1288 predicted_pixels[2] = FILT121(ui4_k, ui4_j, ui4_a); 1289 predicted_pixels[3] = FILT11(ui4_a, ui4_b); 1290 predicted_pixels[4] = FILT11(ui4_b, ui4_c); 1291 predicted_pixels[5] = FILT11(ui4_c, ui4_d); 1292 predicted_pixels[6] = FILT11(ui4_d, ui4_e); 1293 predicted_pixels[7] = FILT11(ui4_e, ui4_f); 1294 predicted_pixels[8] = FILT11(ui4_f, ui4_g); 1295 predicted_pixels[9] = FILT11(ui4_g, ui4_h); 1296 predicted_pixels[10] = FILT11(ui4_h, ui4_i); 1297 predicted_pixels[11] = FILT121(ui4_p, ui4_o, ui4_n); 1298 predicted_pixels[12] = FILT121(ui4_n, ui4_m, ui4_l); 1299 predicted_pixels[13] = FILT121(ui4_l, ui4_k, ui4_j); 1300 predicted_pixels[14] = FILT121(ui4_b, ui4_a, ui4_j); 1301 predicted_pixels[15] = FILT121(ui4_a, ui4_b, ui4_c); 1302 predicted_pixels[16] = FILT121(ui4_b, ui4_c, ui4_d); 1303 predicted_pixels[17] = FILT121(ui4_c, ui4_d, ui4_e); 1304 predicted_pixels[18] = FILT121(ui4_d, ui4_e, ui4_f); 1305 predicted_pixels[19] = FILT121(ui4_e, ui4_f, ui4_g); 1306 predicted_pixels[20] = FILT121(ui4_f, ui4_g, ui4_h); 1307 predicted_pixels[21] = FILT121(ui4_g, ui4_h, ui4_i); 1308 1309 memcpy(pu1_dst, predicted_pixels + 3, 8); 1310 memcpy(pu1_dst + 1 * dst_strd, predicted_pixels + 14, 8); 1311 memcpy(pu1_dst + 2 * dst_strd, predicted_pixels + 2, 8); 1312 memcpy(pu1_dst + 3 * dst_strd, predicted_pixels + 13, 8); 1313 memcpy(pu1_dst + 4 * dst_strd, predicted_pixels + 1, 8); 1314 memcpy(pu1_dst + 5 * dst_strd, predicted_pixels + 12, 8); 1315 memcpy(pu1_dst + 6 * dst_strd, predicted_pixels, 8); 1316 memcpy(pu1_dst + 7 * dst_strd, predicted_pixels + 11, 8); 1317 1318} 1319 1320/* 1321 ******************************************************************************* 1322 * 1323 *ih264_intra_pred_luma_8x8_mode_horz_d 1324 * 1325 * @brief 1326 * Perform Intra prediction for luma_8x8 mode:Horizontal_Down 1327 * 1328 * @par Description: 1329 * Perform Intra prediction for luma_8x8 mode:Horizontal_Down ,described in sec 8.3.2.2.8 1330 * 1331 * @param[in] pu1_src 1332 * UWORD8 pointer to the source 1333 * 1334 * @param[out] pu1_dst 1335 * UWORD8 pointer to the destination 1336 * 1337 * @param[in] src_strd 1338 * integer source stride 1339 * 1340 * @param[in] dst_strd 1341 * integer destination stride 1342 * 1343 * @param[in] ngbr_avail 1344 * availability of neighbouring pixels(Not used in this function) 1345 * 1346 * @returns 1347 * 1348 * @remarks 1349 * None 1350 * 1351 *******************************************************************************/ 1352 1353void ih264_intra_pred_luma_8x8_mode_horz_d(UWORD8 *pu1_src, 1354 UWORD8 *pu1_dst, 1355 WORD32 src_strd, 1356 WORD32 dst_strd, 1357 WORD32 ngbr_avail) 1358{ 1359 UWORD8 *pu1_left = NULL; /* Pointer to start of left predictors */ 1360 UWORD8 *pu1_top = NULL; /* Pointer to start of top predictors */ 1361 UWORD8 *pu1_topleft = NULL; /* Pointer to start of top left predictors */ 1362 UWORD32 ui4_a; 1363 UWORD32 ui4_b, ui4_c, ui4_d, ui4_e, ui4_f, ui4_g, ui4_h, ui4_i; 1364 UWORD32 ui4_j, ui4_k, ui4_l, ui4_m, ui4_n, ui4_o, ui4_p; 1365 UWORD8 predicted_pixels[22]; 1366 UNUSED(src_strd); 1367 UNUSED(ngbr_avail); 1368 pu1_top = pu1_src + BLK8x8SIZE + 1; 1369 pu1_left = pu1_src + BLK8x8SIZE - 1; 1370 pu1_topleft = pu1_src + BLK8x8SIZE; 1371 1372 ui4_a = *pu1_topleft; 1373 ui4_j = *pu1_top++; 1374 ui4_k = *pu1_top++; 1375 ui4_l = *pu1_top++; 1376 ui4_m = *pu1_top++; 1377 ui4_n = *pu1_top++; 1378 ui4_o = *pu1_top++; 1379 ui4_p = *pu1_top++; 1380 ui4_b = *pu1_left--; 1381 ui4_c = *pu1_left--; 1382 ui4_d = *pu1_left--; 1383 ui4_e = *pu1_left--; 1384 ui4_f = *pu1_left--; 1385 ui4_g = *pu1_left--; 1386 ui4_h = *pu1_left--; 1387 ui4_i = *pu1_left; 1388 1389 predicted_pixels[0] = FILT11(ui4_h, ui4_i); 1390 predicted_pixels[1] = FILT121(ui4_g, ui4_h, ui4_i); 1391 predicted_pixels[2] = FILT11(ui4_g, ui4_h); 1392 predicted_pixels[3] = FILT121(ui4_f, ui4_g, ui4_h); 1393 predicted_pixels[4] = FILT11(ui4_f, ui4_g); 1394 predicted_pixels[5] = FILT121(ui4_e, ui4_f, ui4_g); 1395 predicted_pixels[6] = FILT11(ui4_e, ui4_f); 1396 predicted_pixels[7] = FILT121(ui4_d, ui4_e, ui4_f); 1397 predicted_pixels[8] = FILT11(ui4_d, ui4_e); 1398 predicted_pixels[9] = FILT121(ui4_c, ui4_d, ui4_e); 1399 predicted_pixels[10] = FILT11(ui4_c, ui4_d); 1400 predicted_pixels[11] = FILT121(ui4_b, ui4_c, ui4_d); 1401 predicted_pixels[12] = FILT11(ui4_b, ui4_c); 1402 predicted_pixels[13] = FILT121(ui4_a, ui4_b, ui4_c); 1403 predicted_pixels[14] = FILT11(ui4_a, ui4_b); 1404 predicted_pixels[15] = FILT121(ui4_j, ui4_a, ui4_b); 1405 predicted_pixels[16] = FILT121(ui4_k, ui4_j, ui4_a); 1406 predicted_pixels[17] = FILT121(ui4_l, ui4_k, ui4_j); 1407 predicted_pixels[18] = FILT121(ui4_m, ui4_l, ui4_k); 1408 predicted_pixels[19] = FILT121(ui4_n, ui4_m, ui4_l); 1409 predicted_pixels[20] = FILT121(ui4_o, ui4_n, ui4_m); 1410 predicted_pixels[21] = FILT121(ui4_p, ui4_o, ui4_n); 1411 1412 memcpy(pu1_dst, predicted_pixels + 14, 8); 1413 memcpy(pu1_dst + dst_strd, predicted_pixels + 12, 8); 1414 memcpy(pu1_dst + 2 * dst_strd, predicted_pixels + 10, 8); 1415 memcpy(pu1_dst + 3 * dst_strd, predicted_pixels + 8, 8); 1416 memcpy(pu1_dst + 4 * dst_strd, predicted_pixels + 6, 8); 1417 memcpy(pu1_dst + 5 * dst_strd, predicted_pixels + 4, 8); 1418 memcpy(pu1_dst + 6 * dst_strd, predicted_pixels + 2, 8); 1419 memcpy(pu1_dst + 7 * dst_strd, predicted_pixels, 8); 1420} 1421 1422/** 1423 ******************************************************************************* 1424 * 1425 *ih264_intra_pred_luma_8x8_mode_vert_l 1426 * 1427 * @brief 1428 * Perform Intra prediction for luma_8x8 mode:Vertical_Left 1429 * 1430 * @par Description: 1431 * Perform Intra prediction for luma_8x8 mode:Vertical_Left ,described in sec 8.3.2.2.9 1432 * 1433 * @param[in] pu1_src 1434 * UWORD8 pointer to the source 1435 * 1436 * @param[out] pu1_dst 1437 * UWORD8 pointer to the destination 1438 * 1439 * @param[in] src_strd 1440 * integer source stride 1441 * 1442 * @param[in] dst_strd 1443 * integer destination stride 1444 * 1445 * @param[in] ngbr_avail 1446 * availability of neighbouring pixels(Not used in this function) 1447 * 1448 * @returns 1449 * 1450 * @remarks 1451 * None 1452 * 1453 *******************************************************************************/ 1454 1455void ih264_intra_pred_luma_8x8_mode_vert_l(UWORD8 *pu1_src, 1456 UWORD8 *pu1_dst, 1457 WORD32 src_strd, 1458 WORD32 dst_strd, 1459 WORD32 ngbr_avail) 1460{ 1461 UWORD8 *pu1_top = NULL; /* Pointer to start of top predictors */ 1462 UWORD32 ui4_a, ui4_b, ui4_c, ui4_d, ui4_e, ui4_f, ui4_g, ui4_h; 1463 UWORD32 ui4_i, ui4_j, ui4_k, ui4_l, ui4_m; 1464 UWORD8 predicted_pixels[22]; 1465 UNUSED(src_strd); 1466 UNUSED(ngbr_avail); 1467 pu1_top = pu1_src + BLK8x8SIZE + 1; 1468 1469 ui4_a = *pu1_top++; 1470 ui4_b = *pu1_top++; 1471 ui4_c = *pu1_top++; 1472 ui4_d = *pu1_top++; 1473 ui4_e = *pu1_top++; 1474 ui4_f = *pu1_top++; 1475 ui4_g = *pu1_top++; 1476 ui4_h = *pu1_top++; 1477 ui4_i = *pu1_top++; 1478 ui4_j = *pu1_top++; 1479 ui4_k = *pu1_top++; 1480 ui4_l = *pu1_top++; 1481 ui4_m = *pu1_top++; 1482 1483 predicted_pixels[0] = FILT11(ui4_a, ui4_b); 1484 predicted_pixels[1] = FILT11(ui4_b, ui4_c); 1485 predicted_pixels[2] = FILT11(ui4_c, ui4_d); 1486 predicted_pixels[3] = FILT11(ui4_d, ui4_e); 1487 predicted_pixels[4] = FILT11(ui4_e, ui4_f); 1488 predicted_pixels[5] = FILT11(ui4_f, ui4_g); 1489 predicted_pixels[6] = FILT11(ui4_g, ui4_h); 1490 predicted_pixels[7] = FILT11(ui4_h, ui4_i); 1491 predicted_pixels[8] = FILT11(ui4_i, ui4_j); 1492 predicted_pixels[9] = FILT11(ui4_j, ui4_k); 1493 predicted_pixels[10] = FILT11(ui4_k, ui4_l); 1494 predicted_pixels[11] = FILT121(ui4_a, ui4_b, ui4_c); 1495 predicted_pixels[12] = FILT121(ui4_b, ui4_c, ui4_d); 1496 predicted_pixels[13] = FILT121(ui4_c, ui4_d, ui4_e); 1497 predicted_pixels[14] = FILT121(ui4_d, ui4_e, ui4_f); 1498 predicted_pixels[15] = FILT121(ui4_e, ui4_f, ui4_g); 1499 predicted_pixels[16] = FILT121(ui4_f, ui4_g, ui4_h); 1500 predicted_pixels[17] = FILT121(ui4_g, ui4_h, ui4_i); 1501 predicted_pixels[18] = FILT121(ui4_h, ui4_i, ui4_j); 1502 predicted_pixels[19] = FILT121(ui4_i, ui4_j, ui4_k); 1503 predicted_pixels[20] = FILT121(ui4_j, ui4_k, ui4_l); 1504 predicted_pixels[21] = FILT121(ui4_k, ui4_l, ui4_m); 1505 1506 memcpy(pu1_dst, predicted_pixels, 8); 1507 memcpy(pu1_dst + 2 * dst_strd, predicted_pixels + 1, 8); 1508 memcpy(pu1_dst + 4 * dst_strd, predicted_pixels + 2, 8); 1509 memcpy(pu1_dst + 6 * dst_strd, predicted_pixels + 3, 8); 1510 memcpy(pu1_dst + 1 * dst_strd, predicted_pixels + 11, 8); 1511 memcpy(pu1_dst + 3 * dst_strd, predicted_pixels + 12, 8); 1512 memcpy(pu1_dst + 5 * dst_strd, predicted_pixels + 13, 8); 1513 memcpy(pu1_dst + 7 * dst_strd, predicted_pixels + 14, 8); 1514} 1515 1516/** 1517 ******************************************************************************* 1518 * 1519 *ih264_intra_pred_luma_8x8_mode_horz_u 1520 * 1521 * @brief 1522 * Perform Intra prediction for luma_8x8 mode:Horizontal_Up 1523 * 1524 * @par Description: 1525 * Perform Intra prediction for luma_8x8 mode:Horizontal_Up ,described in sec 8.3.2.2.10 1526 * 1527 * @param[in] pu1_src 1528 * UWORD8 pointer to the source 1529 * 1530 * @param[out] pu1_dst 1531 * UWORD8 pointer to the destination 1532 * 1533 * @param[in] src_strd 1534 * integer source stride 1535 * 1536 * @param[in] dst_strd 1537 * integer destination stride 1538 * 1539 * @param[in] ngbr_avail 1540 * availability of neighbouring pixels(Not used in this function) 1541 * 1542 * @returns 1543 * 1544 * @remarks 1545 * None 1546 * 1547 *******************************************************************************/ 1548 1549void ih264_intra_pred_luma_8x8_mode_horz_u(UWORD8 *pu1_src, 1550 UWORD8 *pu1_dst, 1551 WORD32 src_strd, 1552 WORD32 dst_strd, 1553 WORD32 ngbr_avail) 1554 1555{ 1556 UWORD8 *pu1_left = NULL; /* Pointer to start of left predictors */ 1557 UWORD32 ui4_j, ui4_k, ui4_l, ui4_m, ui4_n, ui4_o, ui4_p, ui4_q; 1558 UWORD8 predicted_pixels[22]; 1559 UNUSED(src_strd); 1560 UNUSED(ngbr_avail); 1561 pu1_left = pu1_src + BLK8x8SIZE - 1; 1562 1563 ui4_j = *pu1_left--; 1564 ui4_k = *pu1_left--; 1565 ui4_l = *pu1_left--; 1566 ui4_m = *pu1_left--; 1567 ui4_n = *pu1_left--; 1568 ui4_o = *pu1_left--; 1569 ui4_p = *pu1_left--; 1570 ui4_q = *pu1_left; 1571 1572 pu1_left = pu1_src + BLK8x8SIZE - 1; 1573 1574 predicted_pixels[0] = FILT11(ui4_j, ui4_k); 1575 predicted_pixels[1] = FILT121(ui4_j, ui4_k, ui4_l); 1576 predicted_pixels[2] = FILT11(ui4_k, ui4_l); 1577 predicted_pixels[3] = FILT121(ui4_k, ui4_l, ui4_m); 1578 predicted_pixels[4] = FILT11(ui4_l, ui4_m); 1579 predicted_pixels[5] = FILT121(ui4_l, ui4_m, ui4_n); 1580 predicted_pixels[6] = FILT11(ui4_m, ui4_n); 1581 predicted_pixels[7] = FILT121(ui4_m, ui4_n, ui4_o); 1582 predicted_pixels[8] = FILT11(ui4_n, ui4_o); 1583 predicted_pixels[9] = FILT121(ui4_n, ui4_o, ui4_p); 1584 predicted_pixels[10] = FILT11(ui4_o, ui4_p); 1585 predicted_pixels[11] = FILT121(ui4_o, ui4_p, ui4_q); 1586 predicted_pixels[12] = FILT11(ui4_p, ui4_q); 1587 predicted_pixels[13] = FILT121(ui4_p, ui4_q, ui4_q); 1588 memset(predicted_pixels+14,ui4_q,8); 1589 1590 memcpy(pu1_dst, predicted_pixels, 8); 1591 memcpy(pu1_dst + 1 * dst_strd, predicted_pixels + 2, 8); 1592 memcpy(pu1_dst + 2 * dst_strd, predicted_pixels + 4, 8); 1593 memcpy(pu1_dst + 3 * dst_strd, predicted_pixels + 6, 8); 1594 memcpy(pu1_dst + 4 * dst_strd, predicted_pixels + 8, 8); 1595 memcpy(pu1_dst + 5 * dst_strd, predicted_pixels + 10, 8); 1596 memcpy(pu1_dst + 6 * dst_strd, predicted_pixels + 12, 8); 1597 memcpy(pu1_dst + 7 * dst_strd, predicted_pixels + 14, 8); 1598} 1599 1600 1601/******************* 16x16 Modes *******************/ 1602 1603/** 1604 ******************************************************************************* 1605 * 1606 *ih264_intra_pred_luma_16x16_mode_vert 1607 * 1608 * @brief 1609 * Perform Intra prediction for luma_16x16 mode:Vertical 1610 * 1611 * @par Description: 1612 * Perform Intra prediction for luma_16x16 mode:Vertical, described in sec 8.3.3.1 1613 * 1614 * @param[in] pu1_src 1615 * UWORD8 pointer to the source 1616 * 1617 * @param[out] pu1_dst 1618 * UWORD8 pointer to the destination 1619 * 1620 * @param[in] src_strd 1621 * integer source stride 1622 * 1623 * @param[in] dst_strd 1624 * integer destination stride 1625 * 1626 * @param[in] ngbr_avail 1627 * availability of neighbouring pixels (Not used in this function) 1628 * 1629 * @returns 1630 * 1631 * @remarks 1632 * None 1633 * 1634 *******************************************************************************/ 1635 1636void ih264_intra_pred_luma_16x16_mode_vert(UWORD8 *pu1_src, 1637 UWORD8 *pu1_dst, 1638 WORD32 src_strd, 1639 WORD32 dst_strd, 1640 WORD32 ngbr_avail) 1641{ 1642 UWORD8 *pu1_top = NULL; /* Pointer to start of top predictors */ 1643 WORD32 rows; /* loop variables*/ 1644 UNUSED(src_strd); 1645 UNUSED(ngbr_avail); 1646 pu1_top = pu1_src + MB_SIZE + 1; 1647 1648 for(rows = 0; rows < 16; rows += 4, pu1_dst += dst_strd) 1649 { 1650 memcpy(pu1_dst, pu1_top, 16); 1651 pu1_dst += dst_strd; 1652 memcpy(pu1_dst, pu1_top, 16); 1653 pu1_dst += dst_strd; 1654 memcpy(pu1_dst, pu1_top, 16); 1655 pu1_dst += dst_strd; 1656 memcpy(pu1_dst, pu1_top, 16); 1657 } 1658} 1659 1660/** 1661 ******************************************************************************* 1662 * 1663 *ih264_intra_pred_luma_16x16_mode_horz 1664 * 1665 * @brief 1666 * Perform Intra prediction for luma_16x16 mode:Horizontal 1667 * 1668 * @par Description: 1669 * Perform Intra prediction for luma_16x16 mode:Horizontal, described in sec 8.3.3.2 1670 * 1671 * @param[in] pu1_src 1672 * UWORD8 pointer to the source 1673 * 1674 * @param[out] pu1_dst 1675 * UWORD8 pointer to the destination 1676 * 1677 * @param[in] src_strd 1678 * integer source stride 1679 * 1680 * @param[in] dst_strd 1681 * integer destination stride 1682 * 1683 * @param[in] ngbr_avail 1684 * availability of neighbouring pixels(Not used in this function) 1685 * 1686 * @returns 1687 * 1688 * @remarks 1689 * None 1690 * 1691 *******************************************************************************/ 1692 1693void ih264_intra_pred_luma_16x16_mode_horz(UWORD8 *pu1_src, 1694 UWORD8 *pu1_dst, 1695 WORD32 src_strd, 1696 WORD32 dst_strd, 1697 WORD32 ngbr_avail) 1698{ 1699 UWORD8 *pu1_left = NULL; /* Pointer to start of top predictors */ 1700 WORD32 rows; 1701 UNUSED(src_strd); 1702 UNUSED(ngbr_avail); 1703 pu1_left = pu1_src + MB_SIZE - 1; 1704 1705 for(rows = 0; rows < 16; rows += 4, pu1_dst += dst_strd, pu1_left --) 1706 { 1707 memset(pu1_dst, *pu1_left, 16); /* copy the left value to the entire row*/ 1708 pu1_left --; 1709 pu1_dst += dst_strd; 1710 memset(pu1_dst, *pu1_left, 16); 1711 pu1_left --; 1712 pu1_dst += dst_strd; 1713 memset(pu1_dst, *pu1_left, 16); 1714 pu1_left --; 1715 pu1_dst += dst_strd; 1716 memset(pu1_dst, *pu1_left, 16); 1717 } 1718} 1719 1720/** 1721 ******************************************************************************* 1722 * 1723 *ih264_intra_pred_luma_16x16_mode_dc 1724 * 1725 * @brief 1726 * Perform Intra prediction for luma_16x16 mode:DC 1727 * 1728 * @par Description: 1729 * Perform Intra prediction for luma_16x16 mode:DC, described in sec 8.3.3.3 1730 * 1731 * @param[in] pu1_src 1732 * UWORD8 pointer to the source 1733 * 1734 * @param[out] pu1_dst 1735 * UWORD8 pointer to the destination 1736 * 1737 * @param[in] src_strd 1738 * integer source stride 1739 * 1740 * @param[in] dst_strd 1741 * integer destination stride 1742 * 1743 ** @param[in] ngbr_avail 1744 * availability of neighbouring pixels 1745 * 1746 * @returns 1747 * 1748 * @remarks 1749 * None 1750 * 1751 *******************************************************************************/ 1752 1753void ih264_intra_pred_luma_16x16_mode_dc(UWORD8 *pu1_src, 1754 UWORD8 *pu1_dst, 1755 WORD32 src_strd, 1756 WORD32 dst_strd, 1757 WORD32 ngbr_avail) 1758{ 1759 WORD8 u1_useleft; /* availability of left predictors (only for DC) */ 1760 UWORD8 u1_usetop; /* availability of top predictors (only for DC) */ 1761 UWORD8 *pu1_left = NULL; /* Pointer to start of left predictors */ 1762 UWORD8 *pu1_top = NULL; /* Pointer to start of top predictors */ 1763 WORD32 rows; /* loop variables*/ 1764 WORD32 val = 0; 1765 UNUSED(src_strd); 1766 1767 u1_useleft = BOOLEAN(ngbr_avail & LEFT_MB_AVAILABLE_MASK); 1768 u1_usetop = BOOLEAN(ngbr_avail & TOP_MB_AVAILABLE_MASK); 1769 pu1_top = pu1_src + MB_SIZE + 1; 1770 pu1_left = pu1_src + MB_SIZE - 1; 1771 if(u1_useleft) 1772 { 1773 for(rows = 0; rows < 16; rows++) 1774 val += *(pu1_left - rows); 1775 val += 8; 1776 } 1777 if(u1_usetop) 1778 { 1779 for(rows = 0; rows < 16; rows++) 1780 val += *(pu1_top + rows); 1781 val += 8; 1782 } 1783 /* Since 8 is added if either left/top pred is there, 1784 val still being zero implies both preds are not there */ 1785 val = (val) ? (val >> (3 + u1_useleft + u1_usetop)) : 128; 1786 1787 for(rows = 0; rows < 16; rows += 4, pu1_dst += dst_strd) 1788 { 1789 memset(pu1_dst, val, 16); 1790 pu1_dst += dst_strd; 1791 memset(pu1_dst, val, 16); 1792 pu1_dst += dst_strd; 1793 memset(pu1_dst, val, 16); 1794 pu1_dst += dst_strd; 1795 memset(pu1_dst, val, 16); 1796 } 1797} 1798 1799/** 1800 ******************************************************************************* 1801 * 1802 *ih264_intra_pred_luma_16x16_mode_plane 1803 * 1804 * @brief 1805 * Perform Intra prediction for luma_16x16 mode:PLANE 1806 * 1807 * @par Description: 1808 * Perform Intra prediction for luma_16x16 mode:PLANE, described in sec 8.3.3.4 1809 * 1810 * @param[in] pu1_src 1811 * UWORD8 pointer to the source 1812 * 1813 * @param[out] pu1_dst 1814 * UWORD8 pointer to the destination 1815 * 1816 * @param[in] src_strd 1817 * integer source stride 1818 * 1819 * @param[in] dst_strd 1820 * integer destination stride 1821 * 1822 * @param[in] ngbr_avail 1823 * availability of neighbouring pixels(Not used in this function) 1824 * 1825 * @returns 1826 * 1827 * @remarks 1828 * None 1829 * 1830 *******************************************************************************/ 1831 1832void ih264_intra_pred_luma_16x16_mode_plane(UWORD8 *pu1_src, 1833 UWORD8 *pu1_dst, 1834 WORD32 src_strd, 1835 WORD32 dst_strd, 1836 WORD32 ngbr_avail) 1837{ 1838 /*! Written with no multiplications */ 1839 UWORD8 *pu1_left = NULL; /* Pointer to start of left predictors */ 1840 UWORD8 *pu1_top = NULL; /* Pointer to start of top predictors */ 1841 UWORD8 *pu1_topleft = NULL; 1842 WORD32 a, b, c, tmp; 1843 UWORD8 *pu1_tmp1, *pu1_tmp2; 1844 WORD32 shift; 1845 UNUSED(src_strd); 1846 UNUSED(ngbr_avail); 1847 pu1_top = pu1_src + MB_SIZE + 1; 1848 pu1_left = pu1_src + MB_SIZE - 1; 1849 pu1_topleft = pu1_src + MB_SIZE; 1850 1851 { 1852 a = (*(pu1_top + 15) + *(pu1_left - 15)) << 4; 1853 1854 /*! Implement Sum(x*(P((x+7),-1) - P((x-7),-1))) x=1...8 */ 1855 pu1_tmp1 = pu1_top + 8; 1856 pu1_tmp2 = pu1_tmp1 - 2; 1857 1858 /* Pixel diffs are only 9 bits; 1859 so sign extension allows shifts to be used even for signed */ 1860 b = ((*pu1_tmp1++) - (*pu1_tmp2--)); /* x=1 */ 1861 b += ((*pu1_tmp1++) - (*pu1_tmp2--)) << 1; /* x=2 */ 1862 tmp = ((*pu1_tmp1++) - (*pu1_tmp2--)); 1863 b += (tmp << 1) + tmp; /* x=3 */ 1864 b += ((*pu1_tmp1++) - (*pu1_tmp2--)) << 2; /* x=4 */ 1865 1866 tmp = ((*pu1_tmp1++) - (*pu1_tmp2--)); 1867 b += (tmp << 2) + tmp; /* x=5 */ 1868 tmp = ((*pu1_tmp1++) - (*pu1_tmp2--)); 1869 b += (tmp << 2) + (tmp << 1); /* x=6 */ 1870 tmp = ((*pu1_tmp1++) - (*pu1_tmp2--)); 1871 b += (tmp << 3) - tmp; /* x=7 */ 1872 b += ((*pu1_tmp1) - (*pu1_topleft)) << 3; /* x=8 */ 1873 1874 b = ((b << 2) + b + 32) >> 6; /*! (5*H + 32)>>6 */ 1875 1876 /*! Implement Sum(y*(P(-1,(y+7)) - P(-1,(y-7)))) y=1...8 */ 1877 pu1_tmp1 = pu1_left - 8; 1878 pu1_tmp2 = pu1_tmp1 + 2; 1879 1880 c = ((*pu1_tmp1) - (*pu1_tmp2)); /* y=1 */ 1881 pu1_tmp1--; 1882 pu1_tmp2++; 1883 c += ((*pu1_tmp1) - (*pu1_tmp2)) << 1; /* y=2 */ 1884 pu1_tmp1--; 1885 pu1_tmp2++; 1886 tmp = ((*pu1_tmp1) - (*pu1_tmp2)); 1887 c += (tmp << 1) + tmp; /* y=3 */ 1888 pu1_tmp1--; 1889 pu1_tmp2++; 1890 c += ((*pu1_tmp1) - (*pu1_tmp2)) << 2; /* y=4 */ 1891 pu1_tmp1--; 1892 pu1_tmp2++; 1893 1894 tmp = ((*pu1_tmp1) - (*pu1_tmp2)); 1895 c += (tmp << 2) + tmp; /* y=5 */ 1896 pu1_tmp1--; 1897 pu1_tmp2++; 1898 tmp = ((*pu1_tmp1) - (*pu1_tmp2)); 1899 c += (tmp << 2) + (tmp << 1); /* y=6 */ 1900 pu1_tmp1--; 1901 pu1_tmp2++; 1902 tmp = ((*pu1_tmp1) - (*pu1_tmp2)); 1903 c += (tmp << 3) - tmp; /* y=7 */ 1904 pu1_tmp1--; //pu1_tmp2 ++; 1905 /* Modified to get (-1,-1) location as *(pu1_top - 1) instead of (pu1_left - ui4_stride) */ 1906 //c += ((*pu1_tmp1) - (*(pu1_top - 1)))<<3; /* y=8 */ 1907 c += ((*pu1_tmp1) - (*pu1_topleft)) << 3; /* y=8 */ 1908 1909 c = ((c << 2) + c + 32) >> 6; /*! (5*V + 32)>>32 */ 1910 shift = 3; 1911 } 1912 1913 /*! Now from the plane parameters a, b, and c, 1914 compute the fitted plane values over the block */ 1915 { 1916 WORD32 tmp1, tmpx, tmpx_init, j, i; 1917 1918 tmpx_init = -(b << shift); /* -8b */ 1919 tmp = a - (c << shift) + 16; /* a-((4or8)*c)+16 */ 1920 for(i = 0; i < 16; i++) 1921 { 1922 tmp += c; /*increment every time by c to get c*(y-7or3)*/ 1923 tmpx = tmpx_init; /* Init to -8b */ 1924 for(j = 0; j < 16; j++) 1925 { 1926 tmpx += b; /* increment every time by b to get b*(x-7or3) */ 1927 tmp1 = (tmp + tmpx) >> 5; 1928 *pu1_dst++ = CLIP_U8(tmp1); 1929 } 1930 pu1_dst += (dst_strd - 16); 1931 } 1932 } 1933} 1934