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_weighted_pred.c */ 23/* */ 24/* Description : Contains function definitions for weighted */ 25/* prediction functions */ 26/* */ 27/* List of Functions : ih264_default_weighted_pred_luma() */ 28/* ih264_default_weighted_pred_chroma() */ 29/* ih264_weighted_pred_luma() */ 30/* ih264_weighted_pred_chroma() */ 31/* ih264_weighted_bipred_luma() */ 32/* ih264_weighted_bipred_chroma() */ 33/* */ 34/* Issues / Problems : None */ 35/* */ 36/* Revision History : */ 37/* */ 38/* DD MM YYYY Author(s) Changes */ 39/* 07 01 2015 Kaushik Initial version */ 40/* Senthoor */ 41/* */ 42/*****************************************************************************/ 43/*****************************************************************************/ 44/* File Includes */ 45/*****************************************************************************/ 46 47/* User include files */ 48#include "ih264_typedefs.h" 49#include "ih264_macros.h" 50#include "ih264_platform_macros.h" 51#include "ih264_weighted_pred.h" 52 53/*****************************************************************************/ 54/* Function definitions . */ 55/*****************************************************************************/ 56/*****************************************************************************/ 57/* */ 58/* Function Name : ih264_default_weighted_pred_luma */ 59/* */ 60/* Description : This function performs the default weighted prediction */ 61/* as described in sec 8.4.2.3.1 titled "Default weighted */ 62/* sample prediction process" for luma. The function gets */ 63/* two ht x wd blocks, calculates their rounded-average and */ 64/* stores it in the destination block. (ht,wd) can be */ 65/* (4,4), (8,4), (4,8), (8,8), (16,8), (8,16) or (16,16). */ 66/* */ 67/* Inputs : puc_src1 - Pointer to source 1 */ 68/* puc_src2 - Pointer to source 2 */ 69/* puc_dst - Pointer to destination */ 70/* src_strd1 - stride for source 1 */ 71/* src_strd1 - stride for source 2 */ 72/* dst_strd - stride for destination */ 73/* ht - height of the block */ 74/* wd - width of the block */ 75/* */ 76/* Issues : None */ 77/* */ 78/* Revision History: */ 79/* */ 80/* DD MM YYYY Author(s) Changes */ 81/* 07 01 2015 Kaushik Initial Version */ 82/* Senthoor */ 83/* */ 84/*****************************************************************************/ 85void ih264_default_weighted_pred_luma(UWORD8 *pu1_src1, 86 UWORD8 *pu1_src2, 87 UWORD8 *pu1_dst, 88 WORD32 src_strd1, 89 WORD32 src_strd2, 90 WORD32 dst_strd, 91 WORD32 ht, 92 WORD32 wd) 93{ 94 WORD32 i, j; 95 96 src_strd1 -= wd; 97 src_strd2 -= wd; 98 dst_strd -= wd; 99 100 for(i = 0; i < ht; i++) 101 { 102 for(j = 0; j < wd; j++, pu1_src1++, pu1_src2++, pu1_dst++) 103 *pu1_dst = (*pu1_src1 + *pu1_src2 + 1) >> 1; 104 105 pu1_src1 += src_strd1; 106 pu1_src2 += src_strd2; 107 pu1_dst += dst_strd; 108 } 109} 110 111/*****************************************************************************/ 112/* */ 113/* Function Name : ih264_default_weighted_pred_chroma */ 114/* */ 115/* Description : This function performs the default weighted prediction */ 116/* as described in sec 8.4.2.3.1 titled "Default weighted */ 117/* sample prediction process" for chroma. The function gets */ 118/* two ht x wd blocks, calculates their rounded-average and */ 119/* stores it in the destination block. (ht,wd) can be */ 120/* (2,2), (4,2) , (2,4), (4,4), (8,4), (4,8) or (8,8). */ 121/* */ 122/* Inputs : puc_src1 - Pointer to source 1 */ 123/* puc_src2 - Pointer to source 2 */ 124/* puc_dst - Pointer to destination */ 125/* src_strd1 - stride for source 1 */ 126/* src_strd1 - stride for source 2 */ 127/* dst_strd - stride for destination */ 128/* ht - height of the block */ 129/* wd - width of the block */ 130/* */ 131/* Issues : None */ 132/* */ 133/* Revision History: */ 134/* */ 135/* DD MM YYYY Author(s) Changes */ 136/* 07 01 2015 Kaushik Initial Version */ 137/* Senthoor */ 138/* */ 139/*****************************************************************************/ 140void ih264_default_weighted_pred_chroma(UWORD8 *pu1_src1, 141 UWORD8 *pu1_src2, 142 UWORD8 *pu1_dst, 143 WORD32 src_strd1, 144 WORD32 src_strd2, 145 WORD32 dst_strd, 146 WORD32 ht, 147 WORD32 wd) 148{ 149 WORD32 i, j; 150 151 wd = wd << 1; 152 153 src_strd1 -= wd; 154 src_strd2 -= wd; 155 dst_strd -= wd; 156 157 for(i = 0; i < ht; i++) 158 { 159 for(j = 0; j < wd; j++, pu1_src1++, pu1_src2++, pu1_dst++) 160 *pu1_dst = (*pu1_src1 + *pu1_src2 + 1) >> 1; 161 162 pu1_src1 += src_strd1; 163 pu1_src2 += src_strd2; 164 pu1_dst += dst_strd; 165 } 166} 167 168/*****************************************************************************/ 169/* */ 170/* Function Name : ih264_weighted_pred_luma */ 171/* */ 172/* Description : This function performs the weighted prediction as */ 173/* described in sec 8.4.2.3.2 titled "Weighted sample */ 174/* prediction process" for luma. The function gets one */ 175/* ht x wd block, weights it, rounds it off, offsets it, */ 176/* saturates it to unsigned 8-bit and stores it in the */ 177/* destination block. (ht,wd) can be (4,4), (8,4), (4,8), */ 178/* (8,8), (16,8), (8,16) or (16,16). */ 179/* */ 180/* Inputs : puc_src - Pointer to source */ 181/* puc_dst - Pointer to destination */ 182/* src_strd - stride for source */ 183/* dst_strd - stride for destination */ 184/* log_wd - number of bits to be rounded off */ 185/* wt - weight value */ 186/* ofst - offset value */ 187/* ht - height of the block */ 188/* wd - width of the block */ 189/* */ 190/* Issues : None */ 191/* */ 192/* Revision History: */ 193/* */ 194/* DD MM YYYY Author(s) Changes */ 195/* 07 01 2015 Kaushik Initial Version */ 196/* Senthoor */ 197/* */ 198/*****************************************************************************/ 199void ih264_weighted_pred_luma(UWORD8 *pu1_src, 200 UWORD8 *pu1_dst, 201 WORD32 src_strd, 202 WORD32 dst_strd, 203 WORD32 log_wd, 204 WORD32 wt, 205 WORD32 ofst, 206 WORD32 ht, 207 WORD32 wd) 208{ 209 WORD32 i, j; 210 211 wt = (WORD16)(wt & 0xffff); 212 ofst = (WORD8)(ofst & 0xff); 213 214 src_strd -= wd; 215 dst_strd -= wd; 216 217 if(log_wd >= 1) 218 { 219 WORD32 i_ofst = (1 << (log_wd - 1)) + (ofst << log_wd); 220 for(i = 0; i < ht; i++) 221 { 222 for(j = 0; j < wd; j++, pu1_src++, pu1_dst++) 223 *pu1_dst = CLIP_U8((wt * (*pu1_src) + i_ofst) >> log_wd); 224 225 pu1_src += src_strd; 226 pu1_dst += dst_strd; 227 } 228 } 229 else 230 { 231 for(i = 0; i < ht; i++) 232 { 233 for(j = 0; j < wd; j++, pu1_src++, pu1_dst++) 234 *pu1_dst = CLIP_U8(wt * (*pu1_src) + ofst); 235 236 pu1_src += src_strd; 237 pu1_dst += dst_strd; 238 } 239 } 240} 241 242/*****************************************************************************/ 243/* */ 244/* Function Name : ih264_weighted_pred_chroma */ 245/* */ 246/* Description : This function performs the weighted prediction as */ 247/* described in sec 8.4.2.3.2 titled "Weighted sample */ 248/* prediction process" for chroma. The function gets one */ 249/* ht x wd block, weights it, rounds it off, offsets it, */ 250/* saturates it to unsigned 8-bit and stores it in the */ 251/* destination block. (ht,wd) can be (2,2), (4,2), (2,4), */ 252/* (4,4), (8,4), (4,8) or (8,8). */ 253/* */ 254/* Inputs : puc_src - Pointer to source */ 255/* puc_dst - Pointer to destination */ 256/* src_strd - stride for source */ 257/* dst_strd - stride for destination */ 258/* log_wd - number of bits to be rounded off */ 259/* wt - weight values for u and v */ 260/* ofst - offset values for u and v */ 261/* ht - height of the block */ 262/* wd - width of the block */ 263/* */ 264/* Issues : None */ 265/* */ 266/* Revision History: */ 267/* */ 268/* DD MM YYYY Author(s) Changes */ 269/* 07 01 2015 Kaushik Initial Version */ 270/* Senthoor */ 271/* */ 272/*****************************************************************************/ 273void ih264_weighted_pred_chroma(UWORD8 *pu1_src, 274 UWORD8 *pu1_dst, 275 WORD32 src_strd, 276 WORD32 dst_strd, 277 WORD32 log_wd, 278 WORD32 wt, 279 WORD32 ofst, 280 WORD32 ht, 281 WORD32 wd) 282{ 283 WORD32 i, j; 284 WORD32 wt_u, wt_v; 285 WORD32 ofst_u, ofst_v; 286 287 wt_u = (WORD16)(wt & 0xffff); 288 wt_v = (WORD16)(wt >> 16); 289 290 ofst_u = (WORD8)(ofst & 0xff); 291 ofst_v = (WORD8)(ofst >> 8); 292 293 src_strd -= wd << 1; 294 dst_strd -= wd << 1; 295 296 if(log_wd >= 1) 297 { 298 ofst_u = (1 << (log_wd - 1)) + (ofst_u << log_wd); 299 ofst_v = (1 << (log_wd - 1)) + (ofst_v << log_wd); 300 301 for(i = 0; i < ht; i++) 302 { 303 for(j = 0; j < wd; j++, pu1_src++, pu1_dst++) 304 { 305 *pu1_dst = CLIP_U8((wt_u * (*pu1_src) + ofst_u) >> log_wd); 306 pu1_src++; 307 pu1_dst++; 308 *pu1_dst = CLIP_U8((wt_v * (*pu1_src) + ofst_v) >> log_wd); 309 } 310 pu1_src += src_strd; 311 pu1_dst += dst_strd; 312 } 313 } 314 else 315 { 316 for(i = 0; i < ht; i++) 317 { 318 for(j = 0; j < wd; j++, pu1_src++, pu1_dst++) 319 { 320 *pu1_dst = CLIP_U8(wt_u * (*pu1_src) + ofst_u); 321 pu1_src++; 322 pu1_dst++; 323 *pu1_dst = CLIP_U8(wt_v * (*pu1_src) + ofst_v); 324 } 325 pu1_src += src_strd; 326 pu1_dst += dst_strd; 327 } 328 } 329} 330 331/*****************************************************************************/ 332/* */ 333/* Function Name : ih264_weighted_bi_pred_luma */ 334/* */ 335/* Description : This function performs the weighted biprediction as */ 336/* described in sec 8.4.2.3.2 titled "Weighted sample */ 337/* prediction process" for luma. The function gets two */ 338/* ht x wd blocks, weights them, adds them, rounds off the */ 339/* sum, offsets it, saturates it to unsigned 8-bit and */ 340/* stores it in the destination block. (ht,wd) can be */ 341/* (4,4), (8,4), (4,8), (8,8), (16,8), (8,16) or (16,16). */ 342/* */ 343/* Inputs : puc_src1 - Pointer to source 1 */ 344/* puc_src2 - Pointer to source 2 */ 345/* puc_dst - Pointer to destination */ 346/* src_strd1 - stride for source 1 */ 347/* src_strd2 - stride for source 2 */ 348/* dst_strd2 - stride for destination */ 349/* log_wd - number of bits to be rounded off */ 350/* wt1 - weight value for source 1 */ 351/* wt2 - weight value for source 2 */ 352/* ofst1 - offset value for source 1 */ 353/* ofst2 - offset value for source 2 */ 354/* ht - height of the block */ 355/* wd - width of the block */ 356/* */ 357/* Issues : None */ 358/* */ 359/* Revision History: */ 360/* */ 361/* DD MM YYYY Author(s) Changes */ 362/* 07 01 2015 Kaushik Initial Version */ 363/* Senthoor */ 364/* */ 365/*****************************************************************************/ 366void ih264_weighted_bi_pred_luma(UWORD8 *pu1_src1, 367 UWORD8 *pu1_src2, 368 UWORD8 *pu1_dst, 369 WORD32 src_strd1, 370 WORD32 src_strd2, 371 WORD32 dst_strd, 372 WORD32 log_wd, 373 WORD32 wt1, 374 WORD32 wt2, 375 WORD32 ofst1, 376 WORD32 ofst2, 377 WORD32 ht, 378 WORD32 wd) 379{ 380 WORD32 i, j; 381 WORD32 shft, ofst; 382 383 ofst1 = (WORD8)(ofst1 & 0xff); 384 ofst2 = (WORD8)(ofst2 & 0xff); 385 wt1 = (WORD16)(wt1 & 0xffff); 386 wt2 = (WORD16)(wt2 & 0xffff); 387 ofst = (ofst1 + ofst2 + 1) >> 1; 388 389 shft = log_wd + 1; 390 ofst = (1 << log_wd) + (ofst << shft); 391 392 src_strd1 -= wd; 393 src_strd2 -= wd; 394 dst_strd -= wd; 395 396 for(i = 0; i < ht; i++) 397 { 398 for(j = 0; j < wd; j++, pu1_src1++, pu1_src2++, pu1_dst++) 399 *pu1_dst = CLIP_U8((wt1 * (*pu1_src1) + wt2 * (*pu1_src2) + ofst) >> shft); 400 401 pu1_src1 += src_strd1; 402 pu1_src2 += src_strd2; 403 pu1_dst += dst_strd; 404 } 405} 406 407/*****************************************************************************/ 408/* */ 409/* Function Name : ih264_weighted_bi_pred_chroma */ 410/* */ 411/* Description : This function performs the weighted biprediction as */ 412/* described in sec 8.4.2.3.2 titled "Weighted sample */ 413/* prediction process" for chroma. The function gets two */ 414/* ht x wd blocks, weights them, adds them, rounds off the */ 415/* sum, offsets it, saturates it to unsigned 8-bit and */ 416/* stores it in the destination block. (ht,wd) can be */ 417/* (2,2), (4,2), (2,4), (4,4), (8,4), (4,8) or (8,8). */ 418/* */ 419/* Inputs : puc_src1 - Pointer to source 1 */ 420/* puc_src2 - Pointer to source 2 */ 421/* puc_dst - Pointer to destination */ 422/* src_strd1 - stride for source 1 */ 423/* src_strd2 - stride for source 2 */ 424/* dst_strd2 - stride for destination */ 425/* log_wd - number of bits to be rounded off */ 426/* wt1 - weight values for u and v in source 1 */ 427/* wt2 - weight values for u and v in source 2 */ 428/* ofst1 - offset value for u and v in source 1 */ 429/* ofst2 - offset value for u and v in source 2 */ 430/* ht - height of the block */ 431/* wd - width of the block */ 432/* */ 433/* Issues : None */ 434/* */ 435/* Revision History: */ 436/* */ 437/* DD MM YYYY Author(s) Changes */ 438/* 07 01 2015 Kaushik Initial Version */ 439/* Senthoor */ 440/* */ 441/*****************************************************************************/ 442void ih264_weighted_bi_pred_chroma(UWORD8 *pu1_src1, 443 UWORD8 *pu1_src2, 444 UWORD8 *pu1_dst, 445 WORD32 src_strd1, 446 WORD32 src_strd2, 447 WORD32 dst_strd, 448 WORD32 log_wd, 449 WORD32 wt1, 450 WORD32 wt2, 451 WORD32 ofst1, 452 WORD32 ofst2, 453 WORD32 ht, 454 WORD32 wd) 455{ 456 WORD32 i, j; 457 WORD32 wt1_u, wt1_v, wt2_u, wt2_v; 458 WORD32 ofst1_u, ofst1_v, ofst2_u, ofst2_v; 459 WORD32 ofst_u, ofst_v; 460 WORD32 shft; 461 462 ofst1_u = (WORD8)(ofst1 & 0xff); 463 ofst1_v = (WORD8)(ofst1 >> 8); 464 ofst2_u = (WORD8)(ofst2 & 0xff); 465 ofst2_v = (WORD8)(ofst2 >> 8); 466 wt1_u = (WORD16)(wt1 & 0xffff); 467 wt1_v = (WORD16)(wt1 >> 16); 468 wt2_u = (WORD16)(wt2 & 0xffff); 469 wt2_v = (WORD16)(wt2 >> 16); 470 ofst_u = (ofst1_u + ofst2_u + 1) >> 1; 471 ofst_v = (ofst1_v + ofst2_v + 1) >> 1; 472 473 src_strd1 -= wd << 1; 474 src_strd2 -= wd << 1; 475 dst_strd -= wd << 1; 476 477 shft = log_wd + 1; 478 ofst_u = (1 << log_wd) + (ofst_u << shft); 479 ofst_v = (1 << log_wd) + (ofst_v << shft); 480 481 for(i = 0; i < ht; i++) 482 { 483 for(j = 0; j < wd; j++, pu1_src1++, pu1_src2++, pu1_dst++) 484 { 485 *pu1_dst = CLIP_U8((wt1_u * (*pu1_src1) + wt2_u * (*pu1_src2) + ofst_u) >> shft); 486 pu1_src1++; 487 pu1_src2++; 488 pu1_dst++; 489 *pu1_dst = CLIP_U8((wt1_v * (*pu1_src1) + wt2_v * (*pu1_src2) + ofst_v) >> shft); 490 } 491 pu1_src1 += src_strd1; 492 pu1_src2 += src_strd2; 493 pu1_dst += dst_strd; 494 } 495} 496