The-Homebrew-Cloud/Cemu
2
0
Fork 0
mirror of https://github.com/cemu-project/Cemu.git synced 2024-11-28 20:14:18 +01:00
Code Issues Packages Projects Releases Wiki Activity
0d8fd7c0dc
Cemu/dependencies/ih264d/common/ih264_weighted_pred.c

496 lines
25 KiB
C
Raw Normal View History

Add all the files
2022-08-22 22:21:23 +02:00
/******************************************************************************
*
* 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;
}
}
Reference in New Issue Copy Permalink