Ignore:
Timestamp:
12 Nov 2014, 08:09:17 (10 years ago)
Author:
seregin
Message:

initial porting

File:
1 edited

Legend:

Unmodified
Added
Removed

  • branches/SHM-upgrade/source/Lib/TLibCommon/TComWeightPrediction.cpp

    r595 r916  
    22 * License, included below. This software may be subject to other third party
    33 * and contributor rights, including patent rights, and no such rights are
    4  * granted under this license. 
     4 * granted under this license.
    55 *
    66 * Copyright (c) 2010-2014, ITU/ISO/IEC
    … …  
    4141#include "TComInterpolationFilter.h"
    4242
    43 static inline Pel weightBidirY( Int w0, Pel P0, Int w1, Pel P1, Int round, Int shift, Int offset)
    44 {
    45   return ClipY( ( (w0*(P0 + IF_INTERNAL_OFFS) + w1*(P1 + IF_INTERNAL_OFFS) + round + (offset << (shift-1))) >> shift ) );
    46 }
    47 static inline Pel weightBidirC( Int w0, Pel P0, Int w1, Pel P1, Int round, Int shift, Int offset)
    48 {
    49   return ClipC( ( (w0*(P0 + IF_INTERNAL_OFFS) + w1*(P1 + IF_INTERNAL_OFFS) + round + (offset << (shift-1))) >> shift ) );
    50 }
    51 
    52 static inline Pel weightUnidirY( Int w0, Pel P0, Int round, Int shift, Int offset)
    53 {
    54   return ClipY( ( (w0*(P0 + IF_INTERNAL_OFFS) + round) >> shift ) + offset );
    55 }
    56 static inline Pel weightUnidirC( Int w0, Pel P0, Int round, Int shift, Int offset)
    57 {
    58   return ClipC( ( (w0*(P0 + IF_INTERNAL_OFFS) + round) >> shift ) + offset );
     43
     44static inline Pel weightBidir( Int w0, Pel P0, Int w1, Pel P1, Int round, Int shift, Int offset, Int clipBD)
     45{
     46  return ClipBD( ( (w0*(P0 + IF_INTERNAL_OFFS) + w1*(P1 + IF_INTERNAL_OFFS) + round + (offset << (shift-1))) >> shift ), clipBD );
     47}
     48
     49
     50static inline Pel weightUnidir( Int w0, Pel P0, Int round, Int shift, Int offset, Int clipBD)
     51{
     52  return ClipBD( ( (w0*(P0 + IF_INTERNAL_OFFS) + round) >> shift ) + offset, clipBD );
    5953}
    6054
    … …  
    6256// Class definition
    6357// ====================================================================================================================
     58
    6459TComWeightPrediction::TComWeightPrediction()
    6560{
    6661}
     62
    6763
    6864/** weighted averaging for bi-pred
    … …  
    7268 * \param iWidth
    7369 * \param iHeight
    74  * \param wpScalingParam *wp0
    75  * \param wpScalingParam *wp1
     70 * \param WPScalingParam *wp0
     71 * \param WPScalingParam *wp1
    7672 * \param TComYuv* rpcYuvDst
    7773 * \returns Void
    7874 */
    79 Void TComWeightPrediction::addWeightBi( TComYuv* pcYuvSrc0, TComYuv* pcYuvSrc1, UInt iPartUnitIdx, UInt iWidth, UInt iHeight, wpScalingParam *wp0, wpScalingParam *wp1, TComYuv* rpcYuvDst, Bool bRound )
    80 {
    81   Int x, y;
    82 
    83   Pel* pSrcY0  = pcYuvSrc0->getLumaAddr( iPartUnitIdx );
    84   Pel* pSrcU0  = pcYuvSrc0->getCbAddr  ( iPartUnitIdx );
    85   Pel* pSrcV0  = pcYuvSrc0->getCrAddr  ( iPartUnitIdx );
    86  
    87   Pel* pSrcY1  = pcYuvSrc1->getLumaAddr( iPartUnitIdx );
    88   Pel* pSrcU1  = pcYuvSrc1->getCbAddr  ( iPartUnitIdx );
    89   Pel* pSrcV1  = pcYuvSrc1->getCrAddr  ( iPartUnitIdx );
    90  
    91   Pel* pDstY   = rpcYuvDst->getLumaAddr( iPartUnitIdx );
    92   Pel* pDstU   = rpcYuvDst->getCbAddr  ( iPartUnitIdx );
    93   Pel* pDstV   = rpcYuvDst->getCrAddr  ( iPartUnitIdx );
    94  
    95   // Luma : --------------------------------------------
    96   Int w0      = wp0[0].w;
    97   Int offset  = wp0[0].offset;
    98   Int shiftNum = IF_INTERNAL_PREC - g_bitDepthY;
    99   Int shift   = wp0[0].shift + shiftNum;
    100   Int round   = shift?(1<<(shift-1)) * bRound:0;
    101   Int w1      = wp1[0].w;
    102 
    103   UInt  iSrc0Stride = pcYuvSrc0->getStride();
    104   UInt  iSrc1Stride = pcYuvSrc1->getStride();
    105   UInt  iDstStride  = rpcYuvDst->getStride();
    106   for ( y = iHeight-1; y >= 0; y-- )
    107   {
    108     for ( x = iWidth-1; x >= 0; )
    109     {
    110       // note: luma min width is 4
    111       pDstY[x] = weightBidirY(w0,pSrcY0[x], w1,pSrcY1[x], round, shift, offset); x--;
    112       pDstY[x] = weightBidirY(w0,pSrcY0[x], w1,pSrcY1[x], round, shift, offset); x--;
    113       pDstY[x] = weightBidirY(w0,pSrcY0[x], w1,pSrcY1[x], round, shift, offset); x--;
    114       pDstY[x] = weightBidirY(w0,pSrcY0[x], w1,pSrcY1[x], round, shift, offset); x--;
    115     }
    116     pSrcY0 += iSrc0Stride;
    117     pSrcY1 += iSrc1Stride;
    118     pDstY  += iDstStride;
    119   }
    120 
    121  
    122   // Chroma U : --------------------------------------------
    123   w0      = wp0[1].w;
    124   offset  = wp0[1].offset;
    125   shiftNum = IF_INTERNAL_PREC - g_bitDepthC;
    126   shift   = wp0[1].shift + shiftNum;
    127   round   = shift?(1<<(shift-1)):0;
    128   w1      = wp1[1].w;
    129 
    130   iSrc0Stride = pcYuvSrc0->getCStride();
    131   iSrc1Stride = pcYuvSrc1->getCStride();
    132   iDstStride  = rpcYuvDst->getCStride();
    133  
    134   iWidth  >>=1;
    135   iHeight >>=1;
    136  
    137   for ( y = iHeight-1; y >= 0; y-- )
    138   {
    139     for ( x = iWidth-1; x >= 0; )
    140     {
    141       // note: chroma min width is 2
    142       pDstU[x] = weightBidirC(w0,pSrcU0[x], w1,pSrcU1[x], round, shift, offset); x--;
    143       pDstU[x] = weightBidirC(w0,pSrcU0[x], w1,pSrcU1[x], round, shift, offset); x--;
    144     }
    145     pSrcU0 += iSrc0Stride;
    146     pSrcU1 += iSrc1Stride;
    147     pDstU  += iDstStride;
    148   }
    149 
    150   // Chroma V : --------------------------------------------
    151   w0      = wp0[2].w;
    152   offset  = wp0[2].offset;
    153   shift   = wp0[2].shift + shiftNum;
    154   round   = shift?(1<<(shift-1)):0;
    155   w1      = wp1[2].w;
    156 
    157   for ( y = iHeight-1; y >= 0; y-- )
    158   {
    159     for ( x = iWidth-1; x >= 0; )
    160     {
    161       // note: chroma min width is 2
    162       pDstV[x] = weightBidirC(w0,pSrcV0[x], w1,pSrcV1[x], round, shift, offset); x--;
    163       pDstV[x] = weightBidirC(w0,pSrcV0[x], w1,pSrcV1[x], round, shift, offset); x--;
    164     }
    165     pSrcV0 += iSrc0Stride;
    166     pSrcV1 += iSrc1Stride;
    167     pDstV  += iDstStride;
    168   }
    169 }
     75Void TComWeightPrediction::addWeightBi( const TComYuv              *pcYuvSrc0,
     76                                        const TComYuv              *pcYuvSrc1,
     77                                        const UInt                  iPartUnitIdx,
     78                                        const UInt                  uiWidth,
     79                                        const UInt                  uiHeight,
     80                                        const WPScalingParam *const wp0,
     81                                        const WPScalingParam *const wp1,
     82                                              TComYuv        *const rpcYuvDst,
     83                                        const Bool                  bRoundLuma )
     84{
     85
     86  const Bool enableRounding[MAX_NUM_COMPONENT]={ bRoundLuma, true, true };
     87
     88  const UInt numValidComponent = pcYuvSrc0->getNumberValidComponents();
     89
     90  for(Int componentIndex=0; componentIndex<numValidComponent; componentIndex++)
     91  {
     92    const ComponentID compID=ComponentID(componentIndex);
     93
     94    const Pel* pSrc0       = pcYuvSrc0->getAddr( compID,  iPartUnitIdx );
     95    const Pel* pSrc1       = pcYuvSrc1->getAddr( compID,  iPartUnitIdx );
     96          Pel* pDst        = rpcYuvDst->getAddr( compID,  iPartUnitIdx );
     97
     98    // Luma : --------------------------------------------
     99    const Int  w0          = wp0[compID].w;
     100    const Int  offset      = wp0[compID].offset;
     101    const Int  clipBD      = g_bitDepth[toChannelType(compID)];
     102    const Int  shiftNum    = std::max<Int>(2, (IF_INTERNAL_PREC - clipBD));
     103    const Int  shift       = wp0[compID].shift + shiftNum;
     104    const Int  round       = (enableRounding[compID] && (shift > 0)) ? (1<<(shift-1)) : 0;
     105    const Int  w1          = wp1[compID].w;
     106    const UInt csx         = pcYuvSrc0->getComponentScaleX(compID);
     107    const UInt csy         = pcYuvSrc0->getComponentScaleY(compID);
     108    const Int  iHeight     = uiHeight>>csy;
     109    const Int  iWidth      = uiWidth>>csx;
     110
     111    const UInt iSrc0Stride = pcYuvSrc0->getStride(compID);
     112    const UInt iSrc1Stride = pcYuvSrc1->getStride(compID);
     113    const UInt iDstStride  = rpcYuvDst->getStride(compID);
     114
     115    for ( Int y = iHeight-1; y >= 0; y-- )
     116    {
     117      // do it in batches of 4 (partial unroll)
     118      Int x = iWidth-1;
     119      for ( ; x >= 3; )
     120      {
     121        pDst[x] = weightBidir(w0,pSrc0[x], w1,pSrc1[x], round, shift, offset, clipBD); x--;
     122        pDst[x] = weightBidir(w0,pSrc0[x], w1,pSrc1[x], round, shift, offset, clipBD); x--;
     123        pDst[x] = weightBidir(w0,pSrc0[x], w1,pSrc1[x], round, shift, offset, clipBD); x--;
     124        pDst[x] = weightBidir(w0,pSrc0[x], w1,pSrc1[x], round, shift, offset, clipBD); x--;
     125      }
     126      for( ; x >= 0; x-- )
     127      {
     128        pDst[x] = weightBidir(w0,pSrc0[x], w1,pSrc1[x], round, shift, offset, clipBD);
     129      }
     130
     131      pSrc0 += iSrc0Stride;
     132      pSrc1 += iSrc1Stride;
     133      pDst  += iDstStride;
     134    } // y loop
     135  } // compID loop
     136}
     137
    170138
    171139/** weighted averaging for uni-pred
    … …  
    174142 * \param iWidth
    175143 * \param iHeight
    176  * \param wpScalingParam *wp0
     144 * \param WPScalingParam *wp0
    177145 * \param TComYuv* rpcYuvDst
    178146 * \returns Void
    179147 */
    180 Void TComWeightPrediction::addWeightUni( TComYuv* pcYuvSrc0, UInt iPartUnitIdx, UInt iWidth, UInt iHeight, wpScalingParam *wp0, TComYuv* rpcYuvDst )
    181 {
    182   Int x, y;
    183  
    184   Pel* pSrcY0  = pcYuvSrc0->getLumaAddr( iPartUnitIdx );
    185   Pel* pSrcU0  = pcYuvSrc0->getCbAddr  ( iPartUnitIdx );
    186   Pel* pSrcV0  = pcYuvSrc0->getCrAddr  ( iPartUnitIdx );
    187  
    188   Pel* pDstY   = rpcYuvDst->getLumaAddr( iPartUnitIdx );
    189   Pel* pDstU   = rpcYuvDst->getCbAddr  ( iPartUnitIdx );
    190   Pel* pDstV   = rpcYuvDst->getCrAddr  ( iPartUnitIdx );
    191  
    192   // Luma : --------------------------------------------
    193   Int w0      = wp0[0].w;
    194   Int offset  = wp0[0].offset;
    195   Int shiftNum = IF_INTERNAL_PREC - g_bitDepthY;
    196   Int shift   = wp0[0].shift + shiftNum;
    197   Int round   = shift?(1<<(shift-1)):0;
    198   UInt  iSrc0Stride = pcYuvSrc0->getStride();
    199   UInt  iDstStride  = rpcYuvDst->getStride();
    200  
    201   for ( y = iHeight-1; y >= 0; y-- )
    202   {
    203     for ( x = iWidth-1; x >= 0; )
    204     {
    205       // note: luma min width is 4
    206       pDstY[x] = weightUnidirY(w0,pSrcY0[x], round, shift, offset); x--;
    207       pDstY[x] = weightUnidirY(w0,pSrcY0[x], round, shift, offset); x--;
    208       pDstY[x] = weightUnidirY(w0,pSrcY0[x], round, shift, offset); x--;
    209       pDstY[x] = weightUnidirY(w0,pSrcY0[x], round, shift, offset); x--;
    210     }
    211     pSrcY0 += iSrc0Stride;
    212     pDstY  += iDstStride;
    213   }
    214  
    215   // Chroma U : --------------------------------------------
    216   w0      = wp0[1].w;
    217   offset  = wp0[1].offset;
    218   shiftNum = IF_INTERNAL_PREC - g_bitDepthC;
    219   shift   = wp0[1].shift + shiftNum;
    220   round   = shift?(1<<(shift-1)):0;
    221 
    222   iSrc0Stride = pcYuvSrc0->getCStride();
    223   iDstStride  = rpcYuvDst->getCStride();
    224  
    225   iWidth  >>=1;
    226   iHeight >>=1;
    227  
    228   for ( y = iHeight-1; y >= 0; y-- )
    229   {
    230     for ( x = iWidth-1; x >= 0; )
    231     {
    232       // note: chroma min width is 2
    233       pDstU[x] = weightUnidirC(w0,pSrcU0[x], round, shift, offset); x--;
    234       pDstU[x] = weightUnidirC(w0,pSrcU0[x], round, shift, offset); x--;
    235     }
    236     pSrcU0 += iSrc0Stride;
    237     pDstU  += iDstStride;
    238   }
    239 
    240   // Chroma V : --------------------------------------------
    241   w0      = wp0[2].w;
    242   offset  = wp0[2].offset;
    243   shift   = wp0[2].shift + shiftNum;
    244   round   = shift?(1<<(shift-1)):0;
    245 
    246   for ( y = iHeight-1; y >= 0; y-- )
    247   {
    248     for ( x = iWidth-1; x >= 0; )
    249     {
    250       // note: chroma min width is 2
    251       pDstV[x] = weightUnidirC(w0,pSrcV0[x], round, shift, offset); x--;
    252       pDstV[x] = weightUnidirC(w0,pSrcV0[x], round, shift, offset); x--;
    253     }
    254     pSrcV0 += iSrc0Stride;
    255     pDstV  += iDstStride;
    256   }
    257 }
     148Void TComWeightPrediction::addWeightUni( const TComYuv        *const pcYuvSrc0,
     149                                         const UInt                  iPartUnitIdx,
     150                                         const UInt                  uiWidth,
     151                                         const UInt                  uiHeight,
     152                                         const WPScalingParam *const wp0,
     153                                               TComYuv        *const pcYuvDst )
     154{
     155  const UInt numValidComponent = pcYuvSrc0->getNumberValidComponents();
     156
     157  for(Int componentIndex=0; componentIndex<numValidComponent; componentIndex++)
     158  {
     159    const ComponentID compID=ComponentID(componentIndex);
     160
     161    const Pel* pSrc0       = pcYuvSrc0->getAddr( compID,  iPartUnitIdx );
     162          Pel* pDst        = pcYuvDst->getAddr( compID,  iPartUnitIdx );
     163
     164    // Luma : --------------------------------------------
     165    const Int  w0          = wp0[compID].w;
     166    const Int  offset      = wp0[compID].offset;
     167    const Int  clipBD      = g_bitDepth[toChannelType(compID)];
     168    const Int  shiftNum    = std::max<Int>(2, (IF_INTERNAL_PREC - clipBD));
     169    const Int  shift       = wp0[compID].shift + shiftNum;
     170    const Int  round       = (shift > 0) ? (1<<(shift-1)) : 0;
     171    const UInt iSrc0Stride = pcYuvSrc0->getStride(compID);
     172    const UInt iDstStride  = pcYuvDst->getStride(compID);
     173    const UInt csx         = pcYuvSrc0->getComponentScaleX(compID);
     174    const UInt csy         = pcYuvSrc0->getComponentScaleY(compID);
     175    const Int  iHeight     = uiHeight>>csy;
     176    const Int  iWidth      = uiWidth>>csx;
     177
     178    for (Int y = iHeight-1; y >= 0; y-- )
     179    {
     180      Int x = iWidth-1;
     181      for ( ; x >= 3; )
     182      {
     183        pDst[x] = weightUnidir(w0, pSrc0[x], round, shift, offset, clipBD); x--;
     184        pDst[x] = weightUnidir(w0, pSrc0[x], round, shift, offset, clipBD); x--;
     185        pDst[x] = weightUnidir(w0, pSrc0[x], round, shift, offset, clipBD); x--;
     186        pDst[x] = weightUnidir(w0, pSrc0[x], round, shift, offset, clipBD); x--;
     187      }
     188      for( ; x >= 0; x--)
     189      {
     190        pDst[x] = weightUnidir(w0, pSrc0[x], round, shift, offset, clipBD);
     191      }
     192      pSrc0 += iSrc0Stride;
     193      pDst  += iDstStride;
     194    }
     195  }
     196}
     197
    258198
    259199//=======================================================
    … …  
    264204 * \param iRefIdx0
    265205 * \param iRefIdx1
    266  * \param wpScalingParam *&wp0
    267  * \param wpScalingParam *&wp1
     206 * \param WPScalingParam *&wp0
     207 * \param WPScalingParam *&wp1
    268208 * \param ibdi
    269209 * \returns Void
    270210 */
    271 Void TComWeightPrediction::getWpScaling( TComDataCU* pcCU, Int iRefIdx0, Int iRefIdx1, wpScalingParam *&wp0, wpScalingParam *&wp1)
     211Void TComWeightPrediction::getWpScaling(       TComDataCU *const pcCU,
     212                                         const Int               iRefIdx0,
     213                                         const Int               iRefIdx1,
     214                                               WPScalingParam  *&wp0,
     215                                               WPScalingParam  *&wp1)
    272216{
    273217  assert(iRefIdx0 >= 0 || iRefIdx1 >= 0);
    274  
    275   TComSlice*      pcSlice       = pcCU->getSlice();
    276   TComPPS*        pps           = pcCU->getSlice()->getPPS();
    277   Bool            wpBiPred = pps->getWPBiPred();
    278   wpScalingParam* pwp;
    279   Bool            bBiDir        = (iRefIdx0>=0 && iRefIdx1>=0);
    280   Bool            bUniDir       = !bBiDir;
     218
     219        TComSlice *const pcSlice  = pcCU->getSlice();
     220  const Bool             wpBiPred = pcCU->getSlice()->getPPS()->getWPBiPred();
     221  const Bool             bBiDir   = (iRefIdx0>=0 && iRefIdx1>=0);
     222  const Bool             bUniDir  = !bBiDir;
    281223
    282224  if ( bUniDir || wpBiPred )
    … …  
    305247  }
    306248
     249  const UInt numValidComponent                    = pcCU->getPic()->getNumberValidComponents();
     250  const Bool bUseHighPrecisionPredictionWeighting = pcSlice->getSPS()->getUseHighPrecisionPredictionWeighting();
     251
    307252  if ( bBiDir )
    308253  { // Bi-Dir case
    309     for ( Int yuv=0 ; yuv<3 ; yuv++ )
    310     {
    311       Int bitDepth = yuv ? g_bitDepthC : g_bitDepthY;
     254    for ( Int yuv=0 ; yuv<numValidComponent ; yuv++ )
     255    {
     256      const Int bitDepth            = g_bitDepth[toChannelType(ComponentID(yuv))];
     257      const Int offsetScalingFactor = bUseHighPrecisionPredictionWeighting ? 1 : (1 << (bitDepth-8));
     258
    312259      wp0[yuv].w      = wp0[yuv].iWeight;
    313       wp0[yuv].o      = wp0[yuv].iOffset * (1 << (bitDepth-8));
    314260      wp1[yuv].w      = wp1[yuv].iWeight;
    315       wp1[yuv].o      = wp1[yuv].iOffset * (1 << (bitDepth-8));
     261      wp0[yuv].o      = wp0[yuv].iOffset * offsetScalingFactor;
     262      wp1[yuv].o      = wp1[yuv].iOffset * offsetScalingFactor;
    316263      wp0[yuv].offset = wp0[yuv].o + wp1[yuv].o;
    317264      wp0[yuv].shift  = wp0[yuv].uiLog2WeightDenom + 1;
    … …  
    324271  else
    325272  {  // Unidir
    326     pwp = (iRefIdx0>=0) ? wp0 : wp1 ;
    327     for ( Int yuv=0 ; yuv<3 ; yuv++ )
    328     {
    329       Int bitDepth = yuv ? g_bitDepthC : g_bitDepthY;
     273    WPScalingParam *const pwp = (iRefIdx0>=0) ? wp0 : wp1 ;
     274
     275    for ( Int yuv=0 ; yuv<numValidComponent ; yuv++ )
     276    {
     277      const Int bitDepth            = g_bitDepth[toChannelType(ComponentID(yuv))];
     278      const Int offsetScalingFactor = bUseHighPrecisionPredictionWeighting ? 1 : (1 << (bitDepth-8));
     279
    330280      pwp[yuv].w      = pwp[yuv].iWeight;
    331       pwp[yuv].offset = pwp[yuv].iOffset * (1 << (bitDepth-8));
     281      pwp[yuv].offset = pwp[yuv].iOffset * offsetScalingFactor;
    332282      pwp[yuv].shift  = pwp[yuv].uiLog2WeightDenom;
    333283      pwp[yuv].round  = (pwp[yuv].uiLog2WeightDenom>=1) ? (1 << (pwp[yuv].uiLog2WeightDenom-1)) : (0);
    … …  
    335285  }
    336286}
     287
    337288
    338289/** weighted prediction for bi-pred
    … …  
    348299 * \returns Void
    349300 */
    350 Void TComWeightPrediction::xWeightedPredictionBi( TComDataCU* pcCU, TComYuv* pcYuvSrc0, TComYuv* pcYuvSrc1, Int iRefIdx0, Int iRefIdx1, UInt uiPartIdx, Int iWidth, Int iHeight, TComYuv* rpcYuvDst )
    351 {
    352   wpScalingParam  *pwp0, *pwp1;
    353   TComPPS         *pps = pcCU->getSlice()->getPPS();
    354   assert( pps->getWPBiPred());
     301Void TComWeightPrediction::xWeightedPredictionBi(       TComDataCU *const pcCU,
     302                                                  const TComYuv    *const pcYuvSrc0,
     303                                                  const TComYuv    *const pcYuvSrc1,
     304                                                  const Int               iRefIdx0,
     305                                                  const Int               iRefIdx1,
     306                                                  const UInt              uiPartIdx,
     307                                                  const Int               iWidth,
     308                                                  const Int               iHeight,
     309                                                        TComYuv          *rpcYuvDst )
     310{
     311  WPScalingParam  *pwp0;
     312  WPScalingParam  *pwp1;
     313
     314  assert(pcCU->getSlice()->getPPS()->getWPBiPred());
    355315
    356316  getWpScaling(pcCU, iRefIdx0, iRefIdx1, pwp0, pwp1);
    … …  
    373333  }
    374334}
     335
    375336
    376337/** weighted prediction for uni-pred
    … …  
    381342 * \param iHeight
    382343 * \param eRefPicList
    383  * \param TComYuv*& rpcYuvPred
     344 * \param TComYuv* pcYuvPred
    384345 * \param iPartIdx
    385346 * \param iRefIdx
    386347 * \returns Void
    387348 */
    388 Void TComWeightPrediction::xWeightedPredictionUni( TComDataCU* pcCU, TComYuv* pcYuvSrc, UInt uiPartAddr, Int iWidth, Int iHeight, RefPicList eRefPicList, TComYuv*& rpcYuvPred, Int iRefIdx)
    389 {
    390   wpScalingParam  *pwp, *pwpTmp;
     349Void TComWeightPrediction::xWeightedPredictionUni(       TComDataCU *const pcCU,
     350                                                   const TComYuv    *const pcYuvSrc,
     351                                                   const UInt              uiPartAddr,
     352                                                   const Int               iWidth,
     353                                                   const Int               iHeight,
     354                                                   const RefPicList        eRefPicList,
     355                                                         TComYuv          *pcYuvPred,
     356                                                   const Int               iRefIdx_input)
     357{
     358  WPScalingParam  *pwp, *pwpTmp;
     359
     360  Int iRefIdx=iRefIdx_input;
    391361  if ( iRefIdx < 0 )
    392362  {
    … …  
    403373    getWpScaling(pcCU, -1, iRefIdx, pwpTmp, pwp);
    404374  }
    405   addWeightUni( pcYuvSrc, uiPartAddr, iWidth, iHeight, pwp, rpcYuvPred );
    406 }
    407 
    408 
     375  addWeightUni( pcYuvSrc, uiPartAddr, iWidth, iHeight, pwp, pcYuvPred );
     376}
Note: See TracChangeset for help on using the changeset viewer.