You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
496 lines
25 KiB
496 lines
25 KiB
/******************************************************************************
|
|
*
|
|
* Copyright (C) 2015 The Android Open Source Project
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at:
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*
|
|
*****************************************************************************
|
|
* Originally developed and contributed by Ittiam Systems Pvt. Ltd, Bangalore
|
|
*/
|
|
/*****************************************************************************/
|
|
/* */
|
|
/* File Name : ih264_weighted_pred.c */
|
|
/* */
|
|
/* Description : Contains function definitions for weighted */
|
|
/* prediction functions */
|
|
/* */
|
|
/* List of Functions : ih264_default_weighted_pred_luma() */
|
|
/* ih264_default_weighted_pred_chroma() */
|
|
/* ih264_weighted_pred_luma() */
|
|
/* ih264_weighted_pred_chroma() */
|
|
/* ih264_weighted_bipred_luma() */
|
|
/* ih264_weighted_bipred_chroma() */
|
|
/* */
|
|
/* Issues / Problems : None */
|
|
/* */
|
|
/* Revision History : */
|
|
/* */
|
|
/* DD MM YYYY Author(s) Changes */
|
|
/* 07 01 2015 Kaushik Initial version */
|
|
/* Senthoor */
|
|
/* */
|
|
/*****************************************************************************/
|
|
/*****************************************************************************/
|
|
/* File Includes */
|
|
/*****************************************************************************/
|
|
|
|
/* User include files */
|
|
#include "ih264_typedefs.h"
|
|
#include "ih264_macros.h"
|
|
#include "ih264_platform_macros.h"
|
|
#include "ih264_weighted_pred.h"
|
|
|
|
/*****************************************************************************/
|
|
/* Function definitions . */
|
|
/*****************************************************************************/
|
|
/*****************************************************************************/
|
|
/* */
|
|
/* Function Name : ih264_default_weighted_pred_luma */
|
|
/* */
|
|
/* Description : This function performs the default weighted prediction */
|
|
/* as described in sec 8.4.2.3.1 titled "Default weighted */
|
|
/* sample prediction process" for luma. The function gets */
|
|
/* two ht x wd blocks, calculates their rounded-average and */
|
|
/* stores it in the destination block. (ht,wd) can be */
|
|
/* (4,4), (8,4), (4,8), (8,8), (16,8), (8,16) or (16,16). */
|
|
/* */
|
|
/* Inputs : puc_src1 - Pointer to source 1 */
|
|
/* puc_src2 - Pointer to source 2 */
|
|
/* puc_dst - Pointer to destination */
|
|
/* src_strd1 - stride for source 1 */
|
|
/* src_strd1 - stride for source 2 */
|
|
/* dst_strd - stride for destination */
|
|
/* ht - height of the block */
|
|
/* wd - width of the block */
|
|
/* */
|
|
/* Issues : None */
|
|
/* */
|
|
/* Revision History: */
|
|
/* */
|
|
/* DD MM YYYY Author(s) Changes */
|
|
/* 07 01 2015 Kaushik Initial Version */
|
|
/* Senthoor */
|
|
/* */
|
|
/*****************************************************************************/
|
|
void ih264_default_weighted_pred_luma(UWORD8 *pu1_src1,
|
|
UWORD8 *pu1_src2,
|
|
UWORD8 *pu1_dst,
|
|
WORD32 src_strd1,
|
|
WORD32 src_strd2,
|
|
WORD32 dst_strd,
|
|
WORD32 ht,
|
|
WORD32 wd)
|
|
{
|
|
WORD32 i, j;
|
|
|
|
src_strd1 -= wd;
|
|
src_strd2 -= wd;
|
|
dst_strd -= wd;
|
|
|
|
for(i = 0; i < ht; i++)
|
|
{
|
|
for(j = 0; j < wd; j++, pu1_src1++, pu1_src2++, pu1_dst++)
|
|
*pu1_dst = (*pu1_src1 + *pu1_src2 + 1) >> 1;
|
|
|
|
pu1_src1 += src_strd1;
|
|
pu1_src2 += src_strd2;
|
|
pu1_dst += dst_strd;
|
|
}
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
/* */
|
|
/* Function Name : ih264_default_weighted_pred_chroma */
|
|
/* */
|
|
/* Description : This function performs the default weighted prediction */
|
|
/* as described in sec 8.4.2.3.1 titled "Default weighted */
|
|
/* sample prediction process" for chroma. The function gets */
|
|
/* two ht x wd blocks, calculates their rounded-average and */
|
|
/* stores it in the destination block. (ht,wd) can be */
|
|
/* (2,2), (4,2) , (2,4), (4,4), (8,4), (4,8) or (8,8). */
|
|
/* */
|
|
/* Inputs : puc_src1 - Pointer to source 1 */
|
|
/* puc_src2 - Pointer to source 2 */
|
|
/* puc_dst - Pointer to destination */
|
|
/* src_strd1 - stride for source 1 */
|
|
/* src_strd1 - stride for source 2 */
|
|
/* dst_strd - stride for destination */
|
|
/* ht - height of the block */
|
|
/* wd - width of the block */
|
|
/* */
|
|
/* Issues : None */
|
|
/* */
|
|
/* Revision History: */
|
|
/* */
|
|
/* DD MM YYYY Author(s) Changes */
|
|
/* 07 01 2015 Kaushik Initial Version */
|
|
/* Senthoor */
|
|
/* */
|
|
/*****************************************************************************/
|
|
void ih264_default_weighted_pred_chroma(UWORD8 *pu1_src1,
|
|
UWORD8 *pu1_src2,
|
|
UWORD8 *pu1_dst,
|
|
WORD32 src_strd1,
|
|
WORD32 src_strd2,
|
|
WORD32 dst_strd,
|
|
WORD32 ht,
|
|
WORD32 wd)
|
|
{
|
|
WORD32 i, j;
|
|
|
|
wd = wd << 1;
|
|
|
|
src_strd1 -= wd;
|
|
src_strd2 -= wd;
|
|
dst_strd -= wd;
|
|
|
|
for(i = 0; i < ht; i++)
|
|
{
|
|
for(j = 0; j < wd; j++, pu1_src1++, pu1_src2++, pu1_dst++)
|
|
*pu1_dst = (*pu1_src1 + *pu1_src2 + 1) >> 1;
|
|
|
|
pu1_src1 += src_strd1;
|
|
pu1_src2 += src_strd2;
|
|
pu1_dst += dst_strd;
|
|
}
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
/* */
|
|
/* Function Name : ih264_weighted_pred_luma */
|
|
/* */
|
|
/* Description : This function performs the weighted prediction as */
|
|
/* described in sec 8.4.2.3.2 titled "Weighted sample */
|
|
/* prediction process" for luma. The function gets one */
|
|
/* ht x wd block, weights it, rounds it off, offsets it, */
|
|
/* saturates it to unsigned 8-bit and stores it in the */
|
|
/* destination block. (ht,wd) can be (4,4), (8,4), (4,8), */
|
|
/* (8,8), (16,8), (8,16) or (16,16). */
|
|
/* */
|
|
/* Inputs : puc_src - Pointer to source */
|
|
/* puc_dst - Pointer to destination */
|
|
/* src_strd - stride for source */
|
|
/* dst_strd - stride for destination */
|
|
/* log_wd - number of bits to be rounded off */
|
|
/* wt - weight value */
|
|
/* ofst - offset value */
|
|
/* ht - height of the block */
|
|
/* wd - width of the block */
|
|
/* */
|
|
/* Issues : None */
|
|
/* */
|
|
/* Revision History: */
|
|
/* */
|
|
/* DD MM YYYY Author(s) Changes */
|
|
/* 07 01 2015 Kaushik Initial Version */
|
|
/* Senthoor */
|
|
/* */
|
|
/*****************************************************************************/
|
|
void ih264_weighted_pred_luma(UWORD8 *pu1_src,
|
|
UWORD8 *pu1_dst,
|
|
WORD32 src_strd,
|
|
WORD32 dst_strd,
|
|
WORD32 log_wd,
|
|
WORD32 wt,
|
|
WORD32 ofst,
|
|
WORD32 ht,
|
|
WORD32 wd)
|
|
{
|
|
WORD32 i, j;
|
|
|
|
wt = (WORD16)(wt & 0xffff);
|
|
ofst = (WORD8)(ofst & 0xff);
|
|
|
|
src_strd -= wd;
|
|
dst_strd -= wd;
|
|
|
|
if(log_wd >= 1)
|
|
{
|
|
WORD32 i_ofst = (1 << (log_wd - 1)) + (ofst << log_wd);
|
|
for(i = 0; i < ht; i++)
|
|
{
|
|
for(j = 0; j < wd; j++, pu1_src++, pu1_dst++)
|
|
*pu1_dst = CLIP_U8((wt * (*pu1_src) + i_ofst) >> log_wd);
|
|
|
|
pu1_src += src_strd;
|
|
pu1_dst += dst_strd;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for(i = 0; i < ht; i++)
|
|
{
|
|
for(j = 0; j < wd; j++, pu1_src++, pu1_dst++)
|
|
*pu1_dst = CLIP_U8(wt * (*pu1_src) + ofst);
|
|
|
|
pu1_src += src_strd;
|
|
pu1_dst += dst_strd;
|
|
}
|
|
}
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
/* */
|
|
/* Function Name : ih264_weighted_pred_chroma */
|
|
/* */
|
|
/* Description : This function performs the weighted prediction as */
|
|
/* described in sec 8.4.2.3.2 titled "Weighted sample */
|
|
/* prediction process" for chroma. The function gets one */
|
|
/* ht x wd block, weights it, rounds it off, offsets it, */
|
|
/* saturates it to unsigned 8-bit and stores it in the */
|
|
/* destination block. (ht,wd) can be (2,2), (4,2), (2,4), */
|
|
/* (4,4), (8,4), (4,8) or (8,8). */
|
|
/* */
|
|
/* Inputs : puc_src - Pointer to source */
|
|
/* puc_dst - Pointer to destination */
|
|
/* src_strd - stride for source */
|
|
/* dst_strd - stride for destination */
|
|
/* log_wd - number of bits to be rounded off */
|
|
/* wt - weight values for u and v */
|
|
/* ofst - offset values for u and v */
|
|
/* ht - height of the block */
|
|
/* wd - width of the block */
|
|
/* */
|
|
/* Issues : None */
|
|
/* */
|
|
/* Revision History: */
|
|
/* */
|
|
/* DD MM YYYY Author(s) Changes */
|
|
/* 07 01 2015 Kaushik Initial Version */
|
|
/* Senthoor */
|
|
/* */
|
|
/*****************************************************************************/
|
|
void ih264_weighted_pred_chroma(UWORD8 *pu1_src,
|
|
UWORD8 *pu1_dst,
|
|
WORD32 src_strd,
|
|
WORD32 dst_strd,
|
|
WORD32 log_wd,
|
|
WORD32 wt,
|
|
WORD32 ofst,
|
|
WORD32 ht,
|
|
WORD32 wd)
|
|
{
|
|
WORD32 i, j;
|
|
WORD32 wt_u, wt_v;
|
|
WORD32 ofst_u, ofst_v;
|
|
|
|
wt_u = (WORD16)(wt & 0xffff);
|
|
wt_v = (WORD16)(wt >> 16);
|
|
|
|
ofst_u = (WORD8)(ofst & 0xff);
|
|
ofst_v = (WORD8)(ofst >> 8);
|
|
|
|
src_strd -= wd << 1;
|
|
dst_strd -= wd << 1;
|
|
|
|
if(log_wd >= 1)
|
|
{
|
|
ofst_u = (1 << (log_wd - 1)) + (ofst_u << log_wd);
|
|
ofst_v = (1 << (log_wd - 1)) + (ofst_v << log_wd);
|
|
|
|
for(i = 0; i < ht; i++)
|
|
{
|
|
for(j = 0; j < wd; j++, pu1_src++, pu1_dst++)
|
|
{
|
|
*pu1_dst = CLIP_U8((wt_u * (*pu1_src) + ofst_u) >> log_wd);
|
|
pu1_src++;
|
|
pu1_dst++;
|
|
*pu1_dst = CLIP_U8((wt_v * (*pu1_src) + ofst_v) >> log_wd);
|
|
}
|
|
pu1_src += src_strd;
|
|
pu1_dst += dst_strd;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for(i = 0; i < ht; i++)
|
|
{
|
|
for(j = 0; j < wd; j++, pu1_src++, pu1_dst++)
|
|
{
|
|
*pu1_dst = CLIP_U8(wt_u * (*pu1_src) + ofst_u);
|
|
pu1_src++;
|
|
pu1_dst++;
|
|
*pu1_dst = CLIP_U8(wt_v * (*pu1_src) + ofst_v);
|
|
}
|
|
pu1_src += src_strd;
|
|
pu1_dst += dst_strd;
|
|
}
|
|
}
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
/* */
|
|
/* Function Name : ih264_weighted_bi_pred_luma */
|
|
/* */
|
|
/* Description : This function performs the weighted biprediction as */
|
|
/* described in sec 8.4.2.3.2 titled "Weighted sample */
|
|
/* prediction process" for luma. The function gets two */
|
|
/* ht x wd blocks, weights them, adds them, rounds off the */
|
|
/* sum, offsets it, saturates it to unsigned 8-bit and */
|
|
/* stores it in the destination block. (ht,wd) can be */
|
|
/* (4,4), (8,4), (4,8), (8,8), (16,8), (8,16) or (16,16). */
|
|
/* */
|
|
/* Inputs : puc_src1 - Pointer to source 1 */
|
|
/* puc_src2 - Pointer to source 2 */
|
|
/* puc_dst - Pointer to destination */
|
|
/* src_strd1 - stride for source 1 */
|
|
/* src_strd2 - stride for source 2 */
|
|
/* dst_strd2 - stride for destination */
|
|
/* log_wd - number of bits to be rounded off */
|
|
/* wt1 - weight value for source 1 */
|
|
/* wt2 - weight value for source 2 */
|
|
/* ofst1 - offset value for source 1 */
|
|
/* ofst2 - offset value for source 2 */
|
|
/* ht - height of the block */
|
|
/* wd - width of the block */
|
|
/* */
|
|
/* Issues : None */
|
|
/* */
|
|
/* Revision History: */
|
|
/* */
|
|
/* DD MM YYYY Author(s) Changes */
|
|
/* 07 01 2015 Kaushik Initial Version */
|
|
/* Senthoor */
|
|
/* */
|
|
/*****************************************************************************/
|
|
void ih264_weighted_bi_pred_luma(UWORD8 *pu1_src1,
|
|
UWORD8 *pu1_src2,
|
|
UWORD8 *pu1_dst,
|
|
WORD32 src_strd1,
|
|
WORD32 src_strd2,
|
|
WORD32 dst_strd,
|
|
WORD32 log_wd,
|
|
WORD32 wt1,
|
|
WORD32 wt2,
|
|
WORD32 ofst1,
|
|
WORD32 ofst2,
|
|
WORD32 ht,
|
|
WORD32 wd)
|
|
{
|
|
WORD32 i, j;
|
|
WORD32 shft, ofst;
|
|
|
|
ofst1 = (WORD8)(ofst1 & 0xff);
|
|
ofst2 = (WORD8)(ofst2 & 0xff);
|
|
wt1 = (WORD16)(wt1 & 0xffff);
|
|
wt2 = (WORD16)(wt2 & 0xffff);
|
|
ofst = (ofst1 + ofst2 + 1) >> 1;
|
|
|
|
shft = log_wd + 1;
|
|
ofst = (1 << log_wd) + (ofst << shft);
|
|
|
|
src_strd1 -= wd;
|
|
src_strd2 -= wd;
|
|
dst_strd -= wd;
|
|
|
|
for(i = 0; i < ht; i++)
|
|
{
|
|
for(j = 0; j < wd; j++, pu1_src1++, pu1_src2++, pu1_dst++)
|
|
*pu1_dst = CLIP_U8((wt1 * (*pu1_src1) + wt2 * (*pu1_src2) + ofst) >> shft);
|
|
|
|
pu1_src1 += src_strd1;
|
|
pu1_src2 += src_strd2;
|
|
pu1_dst += dst_strd;
|
|
}
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
/* */
|
|
/* Function Name : ih264_weighted_bi_pred_chroma */
|
|
/* */
|
|
/* Description : This function performs the weighted biprediction as */
|
|
/* described in sec 8.4.2.3.2 titled "Weighted sample */
|
|
/* prediction process" for chroma. The function gets two */
|
|
/* ht x wd blocks, weights them, adds them, rounds off the */
|
|
/* sum, offsets it, saturates it to unsigned 8-bit and */
|
|
/* stores it in the destination block. (ht,wd) can be */
|
|
/* (2,2), (4,2), (2,4), (4,4), (8,4), (4,8) or (8,8). */
|
|
/* */
|
|
/* Inputs : puc_src1 - Pointer to source 1 */
|
|
/* puc_src2 - Pointer to source 2 */
|
|
/* puc_dst - Pointer to destination */
|
|
/* src_strd1 - stride for source 1 */
|
|
/* src_strd2 - stride for source 2 */
|
|
/* dst_strd2 - stride for destination */
|
|
/* log_wd - number of bits to be rounded off */
|
|
/* wt1 - weight values for u and v in source 1 */
|
|
/* wt2 - weight values for u and v in source 2 */
|
|
/* ofst1 - offset value for u and v in source 1 */
|
|
/* ofst2 - offset value for u and v in source 2 */
|
|
/* ht - height of the block */
|
|
/* wd - width of the block */
|
|
/* */
|
|
/* Issues : None */
|
|
/* */
|
|
/* Revision History: */
|
|
/* */
|
|
/* DD MM YYYY Author(s) Changes */
|
|
/* 07 01 2015 Kaushik Initial Version */
|
|
/* Senthoor */
|
|
/* */
|
|
/*****************************************************************************/
|
|
void ih264_weighted_bi_pred_chroma(UWORD8 *pu1_src1,
|
|
UWORD8 *pu1_src2,
|
|
UWORD8 *pu1_dst,
|
|
WORD32 src_strd1,
|
|
WORD32 src_strd2,
|
|
WORD32 dst_strd,
|
|
WORD32 log_wd,
|
|
WORD32 wt1,
|
|
WORD32 wt2,
|
|
WORD32 ofst1,
|
|
WORD32 ofst2,
|
|
WORD32 ht,
|
|
WORD32 wd)
|
|
{
|
|
WORD32 i, j;
|
|
WORD32 wt1_u, wt1_v, wt2_u, wt2_v;
|
|
WORD32 ofst1_u, ofst1_v, ofst2_u, ofst2_v;
|
|
WORD32 ofst_u, ofst_v;
|
|
WORD32 shft;
|
|
|
|
ofst1_u = (WORD8)(ofst1 & 0xff);
|
|
ofst1_v = (WORD8)(ofst1 >> 8);
|
|
ofst2_u = (WORD8)(ofst2 & 0xff);
|
|
ofst2_v = (WORD8)(ofst2 >> 8);
|
|
wt1_u = (WORD16)(wt1 & 0xffff);
|
|
wt1_v = (WORD16)(wt1 >> 16);
|
|
wt2_u = (WORD16)(wt2 & 0xffff);
|
|
wt2_v = (WORD16)(wt2 >> 16);
|
|
ofst_u = (ofst1_u + ofst2_u + 1) >> 1;
|
|
ofst_v = (ofst1_v + ofst2_v + 1) >> 1;
|
|
|
|
src_strd1 -= wd << 1;
|
|
src_strd2 -= wd << 1;
|
|
dst_strd -= wd << 1;
|
|
|
|
shft = log_wd + 1;
|
|
ofst_u = (1 << log_wd) + (ofst_u << shft);
|
|
ofst_v = (1 << log_wd) + (ofst_v << shft);
|
|
|
|
for(i = 0; i < ht; i++)
|
|
{
|
|
for(j = 0; j < wd; j++, pu1_src1++, pu1_src2++, pu1_dst++)
|
|
{
|
|
*pu1_dst = CLIP_U8((wt1_u * (*pu1_src1) + wt2_u * (*pu1_src2) + ofst_u) >> shft);
|
|
pu1_src1++;
|
|
pu1_src2++;
|
|
pu1_dst++;
|
|
*pu1_dst = CLIP_U8((wt1_v * (*pu1_src1) + wt2_v * (*pu1_src2) + ofst_v) >> shft);
|
|
}
|
|
pu1_src1 += src_strd1;
|
|
pu1_src2 += src_strd2;
|
|
pu1_dst += dst_strd;
|
|
}
|
|
}
|