| /****************************************************************************** |
| * |
| * 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; |
| } |
| } |
