Changeset 5 in 3DVCSoftware for trunk/source/Lib/TLibCommon/TComRdCost.cpp


Ignore:
Timestamp:
12 Dec 2011, 18:35:44 (13 years ago)
Author:
hhi
Message:

Clean version with cfg-files

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/source/Lib/TLibCommon/TComRdCost.cpp

    r2 r5  
     1/* The copyright in this software is being made available under the BSD
     2 * License, included below. This software may be subject to other third party
     3 * and contributor rights, including patent rights, and no such rights are
     4 * granted under this license.
     5 *
     6 * Copyright (c) 2010-2011, ISO/IEC
     7 * All rights reserved.
     8 *
     9 * Redistribution and use in source and binary forms, with or without
     10 * modification, are permitted provided that the following conditions are met:
     11 *
     12 *  * Redistributions of source code must retain the above copyright notice,
     13 *    this list of conditions and the following disclaimer.
     14 *  * Redistributions in binary form must reproduce the above copyright notice,
     15 *    this list of conditions and the following disclaimer in the documentation
     16 *    and/or other materials provided with the distribution.
     17 *  * Neither the name of the ISO/IEC nor the names of its contributors may
     18 *    be used to endorse or promote products derived from this software without
     19 *    specific prior written permission.
     20 *
     21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
     22 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     23 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     24 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS
     25 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
     26 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
     27 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
     28 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
     29 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
     30 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
     31 * THE POSSIBILITY OF SUCH DAMAGE.
     32 */
     33
    134
    235
     
    4679  }
    4780 
    48 #if SB_INTERVIEW_SKIP_LAMBDA_SCALE
     81#if HHI_INTERVIEW_SKIP_LAMBDA_SCALE
    4982  dLambda = m_dLambdaScale * dLambda ;
    5083#endif
     
    125158}
    126159
     160#if HHI_INTER_VIEW_MOTION_PRED
    127161Void
    128162TComRdCost::setLambdaMVReg( Double dLambda )
     
    131165  m_uiLambdaMVRegSSE = (UInt)floor( 65536.0 *       dLambda   );
    132166}
     167#endif
    133168
    134169
     
    223258  m_puiMultiviewRegCostVer      = 0;
    224259
    225 //GT VSO
     260#if HHI_VSO
    226261  m_apRefPics               = NULL;
    227262  m_paaiShiftLUTs           = NULL;
     
    231266  m_fpDistortFuncVSO        = NULL;
    232267  m_pcRenModel              = NULL;
    233 
    234 //GT VSO end
    235 #if SB_INTERVIEW_SKIP_LAMBDA_SCALE
     268#endif
     269
     270#if HHI_INTERVIEW_SKIP_LAMBDA_SCALE
    236271  m_dLambdaScale            = 1;
    237272#endif
     
    287322  }
    288323
    289   //GT VSO
     324#if HHI_VSO
    290325  if ( m_apRefPics != NULL )
    291326  {
     
    298333    m_paaiShiftLUTs = NULL;
    299334  };
    300   //GT VSO end
     335#endif
    301336}
    302337
     
    378413  // initialize
    379414  rcDistParam.iSubShift  = 0;
    380 #if SB_INTERVIEW_SKIP
     415#if HHI_INTERVIEW_SKIP
    381416  rcDistParam.pUsed       = 0;
    382417  rcDistParam.iStrideUsed = 0;
     
    401436  // initialize
    402437  rcDistParam.iSubShift  = 0;
    403 #if SB_INTERVIEW_SKIP
     438#if HHI_INTERVIEW_SKIP
    404439  rcDistParam.pUsed       = 0;
    405440  rcDistParam.iStrideUsed = 0;
     
    436471  // initialize
    437472  rcDistParam.iSubShift  = 0;
    438 #if SB_INTERVIEW_SKIP
     473#if HHI_INTERVIEW_SKIP
    439474  rcDistParam.pUsed       = 0;
    440475  rcDistParam.iStrideUsed = 0;
     
    454489  rcDP.iSubShift  = 0;
    455490  rcDP.DistFunc   = m_afpDistortFunc[ ( bHadamard ? DF_HADS : DF_SADS ) + g_aucConvertToBit[ iWidth ] + 1 ];
    456 #if SB_INTERVIEW_SKIP
     491#if HHI_INTERVIEW_SKIP
    457492  rcDP.pUsed       = 0;
    458493  rcDP.iStrideUsed = 0;
     
    504539  return ( uiSum >> g_uiBitIncrement );
    505540}
    506 #if SB_INTERVIEW_SKIP
     541#if HHI_INTERVIEW_SKIP
    507542UInt TComRdCost::getDistPart( Pel* piCur, Int iCurStride,  Pel* piOrg, Int iOrgStride, Pel* piUsed, Int iUsedStride, UInt uiBlkWidth, UInt uiBlkHeight, DFunc eDFunc )
    508543{
     
    33673402  Int iTemp;
    33683403 
    3369 #if SB_INTERVIEW_SKIP
     3404#if HHI_INTERVIEW_SKIP
    33703405  if( pcDtParam->pUsed )
    33713406  {
     
    34003435    piCur += iStrideCur;
    34013436  }
    3402 #if SB_INTERVIEW_SKIP
     3437#if HHI_INTERVIEW_SKIP
    34033438  }
    34043439#endif
     
    34273462  Int  iTemp;
    34283463 
    3429 #if SB_INTERVIEW_SKIP
     3464#if HHI_INTERVIEW_SKIP
    34303465  if( pcDtParam->pUsed )
    34313466  {
     
    34583493    piCur += iStrideCur;
    34593494  }
    3460 #if SB_INTERVIEW_SKIP
     3495#if HHI_INTERVIEW_SKIP
    34613496  }
    34623497#endif
     
    34853520  Int  iTemp;
    34863521 
    3487 #if SB_INTERVIEW_SKIP
     3522#if HHI_INTERVIEW_SKIP
    34883523  if( pcDtParam->pUsed )
    34893524  {
     
    35233558    piCur += iStrideCur;
    35243559  }
    3525 #if SB_INTERVIEW_SKIP
     3560#if HHI_INTERVIEW_SKIP
    35263561  }
    35273562#endif
     
    35503585  Int  iTemp;
    35513586 
    3552 #if SB_INTERVIEW_SKIP
     3587#if HHI_INTERVIEW_SKIP
    35533588  if( pcDtParam->pUsed )
    35543589  {
     
    36053640    piCur += iStrideCur;
    36063641  }
    3607 #if SB_INTERVIEW_SKIP
     3642#if HHI_INTERVIEW_SKIP
    36083643  }
    36093644#endif
     
    36313666  Int  iTemp;
    36323667 
    3633 #if SB_INTERVIEW_SKIP
     3668#if HHI_INTERVIEW_SKIP
    36343669  if( pcDtParam->pUsed )
    36353670  {
     
    36913726    piCur += iStrideCur;
    36923727  }
    3693 #if SB_INTERVIEW_SKIP
     3728#if HHI_INTERVIEW_SKIP
    36943729  }
    36953730#endif
     
    37173752  Int  iTemp;
    37183753 
    3719 #if SB_INTERVIEW_SKIP
     3754#if HHI_INTERVIEW_SKIP
    37203755  if( pcDtParam->pUsed )
    37213756  {
     
    38043839    piCur += iStrideCur;
    38053840  }
    3806 #if SB_INTERVIEW_SKIP
     3841#if HHI_INTERVIEW_SKIP
    38073842  }
    38083843#endif
     
    38303865  Int  iTemp;
    38313866 
    3832 #if SB_INTERVIEW_SKIP
     3867#if HHI_INTERVIEW_SKIP
    38333868  if( pcDtParam->pUsed )
    38343869  {
     
    39804015    piCur += iStrideCur;
    39814016  }
    3982 #if SB_INTERVIEW_SKIP
     4017#if HHI_INTERVIEW_SKIP
    39834018  }
    39844019#endif
     
    47114746
    47124747
    4713 //GT VSO
    4714 
     4748#if HHI_VSO
    47154749Void TComRdCost::setLambdaVSO( Double dLambdaVSO )
    47164750{
     
    47214755}
    47224756
    4723 Dist TComRdCost::xGetDistVSOMode1( Int iStartPosX, Int iStartPosY, Pel* piCur, Int iCurStride, Pel* piOrg, Int iOrgStride, UInt uiBlkWidth, UInt uiBlkHeight, Bool bSAD )
    4724 {
    4725  
    4726   assert( m_uiVSOMode == 1 );     
    4727   UInt uiShift = g_uiBitIncrement << 1;
    4728 
    4729   UInt uiPlane = 0;
    4730 
    4731   Int iRefWidth = m_pcVideoPicYuv->getWidth();
    4732   Int iStrideOrgVid;
    4733   UInt uiErr = 0;
    4734 
    4735   if (uiPlane > 0)
    4736   {
    4737     iStartPosX = iStartPosX >> 1;
    4738     iStartPosY = iStartPosY >> 1;
    4739     iRefWidth  = iRefWidth  >> 1;
    4740     iStrideOrgVid = m_pcVideoPicYuv ->getCStride();
    4741   }
    4742   else
    4743   {
    4744     iStrideOrgVid = m_pcVideoPicYuv ->getStride();
    4745   }
    4746  
    4747   UInt uiReferenceNumber  = 0;
    4748   for (UInt uiReference = 0; uiReference < 3; uiReference+=2 )
    4749   {
    4750     if ( m_paaiShiftLUTs[uiReference] == 0 )
    4751       continue;
    4752 
    4753     uiReferenceNumber++;
    4754    
    4755     Pel* piOrgVid;
    4756 
    4757     if (uiPlane == 0)
    4758     {     
    4759       piOrgVid = m_pcVideoPicYuv ->getLumaAddr();     
    4760     }
    4761     else
    4762     {
    4763       if (uiPlane == 1)
    4764       {       
    4765         piOrgVid = m_pcVideoPicYuv ->getCbAddr();
    4766       }
    4767       else
    4768       {       
    4769         piOrgVid = m_pcVideoPicYuv ->getCrAddr();
    4770       }     
    4771     }
    4772    
    4773     piOrgVid += iStartPosY * iStrideOrgVid;
    4774 
    4775     for ( Int iY = 0; iY < uiBlkHeight; iY++ )
    4776     {
    4777       Int iPos = iStartPosX;
    4778 
    4779       for  (Int iX = 0; iX < uiBlkWidth; iX++ )
    4780       {
    4781         Int iTargetPos;       
    4782 
    4783         assert( RemoveBitIncrement(piCur[iX]) >= 0 && RemoveBitIncrement(piCur[iX]) <= 256);         
    4784         assert( RemoveBitIncrement(piOrg[iX]) >= 0 && RemoveBitIncrement(piOrg[iX]) <= 256);         
    4785 
    4786         iTargetPos = iPos - m_paaiShiftLUTs[uiReference][0][RemoveBitIncrement(piCur[iX])] + m_paaiShiftLUTs[uiReference][0][RemoveBitIncrement(piOrg[iX])];         
    4787         iTargetPos = iTargetPos >  0         ? iTargetPos  : 0;
    4788         iTargetPos = iTargetPos <  iRefWidth ? iTargetPos  : iRefWidth-1;
    4789         Int iDiff = piOrgVid[iTargetPos] - piOrgVid[iPos];
    4790 
    4791         if ( bSAD )
    4792         {
    4793           uiErr     += abs(iDiff);         
    4794         }
    4795         else
    4796         {
    4797           uiErr     += ((iDiff * iDiff) >> uiShift );         
    4798         }
    4799 
    4800         iPos++;
    4801       }
    4802 
    4803       piOrgVid   += iStrideOrgVid;       
    4804 
    4805       piCur      += iCurStride;                 
    4806       piOrg      += iOrgStride;
    4807 
    4808     }
    4809     piCur        -= iCurStride * uiBlkHeight;                   
    4810     piOrg        -= iOrgStride * uiBlkHeight;
    4811   }
    4812 
    4813   if ( bSAD )
    4814   {
    4815     uiErr = uiErr >> g_uiBitIncrement;
    4816   }
    4817 
    4818   return ( uiErr + ( uiReferenceNumber >> 1 )) / uiReferenceNumber;
    4819 }
    4820 
    4821 Dist TComRdCost::xGetDistVSOMode2( Int iStartPosX, Int iStartPosY, Pel* piCur, Int iCurStride, Pel* piOrg, Int iOrgStride, UInt uiBlkWidth, UInt uiBlkHeight, Bool bSAD )
    4822 {
    4823   assert( m_uiVSOMode == 2 );     
    4824   UInt uiShift = g_uiBitIncrement << 1;
    4825   UInt uiPlane = 0;
    4826 
    4827   Int iRefWidth = m_pcVideoPicYuv->getWidth();
    4828   Int iStrideOrgVid;
    4829  
    4830   UInt uiErr = 0;
    4831 
    4832   if (uiPlane > 0)
    4833   {
    4834     iStartPosX = iStartPosX >> 1;
    4835     iStartPosY = iStartPosY >> 1;
    4836     iRefWidth  = iRefWidth  >> 1;
    4837     iStrideOrgVid = m_pcVideoPicYuv ->getCStride();
    4838   }
    4839   else
    4840   {
    4841     iStrideOrgVid = m_pcVideoPicYuv ->getStride();
    4842   }
    4843 
    4844   for (UInt uiRefPic = 0; uiRefPic < m_uiNumberRefPics; uiRefPic++ )
    4845   {
    4846     Pel* piRefVid;
    4847     Pel* piOrgVid;
    4848     Int  iStrideRefVid;         
    4849 
    4850     if (uiPlane == 0)
    4851     {
    4852       piRefVid = m_apRefPics[uiRefPic]->getLumaAddr();
    4853       piOrgVid = m_pcVideoPicYuv ->getLumaAddr();
    4854       iStrideRefVid = m_apRefPics[uiRefPic]->getStride(); 
    4855     }
    4856     else
    4857     {
    4858       if (uiPlane == 1)
    4859       {
    4860         piRefVid = m_apRefPics[uiRefPic]->getCbAddr();
    4861         piOrgVid = m_pcVideoPicYuv ->getCbAddr();
    4862       }
    4863       else
    4864       {
    4865         piRefVid = m_apRefPics[uiRefPic]->getCrAddr();
    4866         piOrgVid = m_pcVideoPicYuv ->getCrAddr();
    4867       }
    4868       iStrideRefVid = m_apRefPics[uiRefPic]->getCStride();     
    4869     }
    4870 
    4871     piRefVid += iStartPosY * iStrideRefVid;
    4872     piOrgVid += iStartPosY * iStrideOrgVid;
    4873 
    4874     for  (Int iY = 0; iY < uiBlkHeight; iY++ )
    4875     {
    4876       Int iPos = iStartPosX;
    4877 
    4878       for  (Int iX = 0; iX < uiBlkWidth; iX++ )
    4879       {
    4880         int iTargetPos;
    4881 
    4882         AOF( RemoveBitIncrement(piCur[iX]) >= 0 && RemoveBitIncrement(piCur[iX]) <= 255);         
    4883         iTargetPos = iPos - m_paaiShiftLUTs[uiRefPic][0][RemoveBitIncrement(piCur[iX])];
    4884         iTargetPos = iTargetPos >  0         ? iTargetPos  : 0;
    4885         iTargetPos = iTargetPos <  iRefWidth ? iTargetPos  : iRefWidth-1;
    4886 
    4887         Int iDiff = piRefVid[iTargetPos] - piOrgVid[iPos];
    4888 
    4889         if ( bSAD )
    4890         {
    4891           uiErr     += abs(iDiff);         
    4892         }
    4893         else
    4894         {
    4895           uiErr     += ((iDiff * iDiff) >> uiShift );         
    4896         }
    4897 
    4898         iPos++;
    4899       }
    4900 
    4901       piRefVid   += iStrideRefVid;
    4902       piOrgVid   += iStrideOrgVid;       
    4903     }
    4904     piCur        -= iCurStride * uiBlkHeight;                   
    4905     piOrg        -= iOrgStride * uiBlkHeight;
    4906   }
    4907 
    4908   if ( bSAD )
    4909   {
    4910     uiErr = uiErr >> g_uiBitIncrement;
    4911   }
    4912 
    4913 
    4914   return ( uiErr + (m_uiNumberRefPics >> 1)) / m_uiNumberRefPics;
    4915 }
    4916 
    4917 Dist TComRdCost::xGetDistVSOMode3( Int iStartPosX, Int iStartPosY, Pel* piCur, Int iCurStride, Pel* piOrg, Int iOrgStride, UInt uiBlkWidth, UInt uiBlkHeight, Bool bSAD )
    4918 {
    4919   assert( m_uiVSOMode == 3 );     
    4920   UInt uiShift = g_uiBitIncrement << 1;
    4921 
    4922   UInt uiPlane = 0;
    4923 
    4924   Int iRefWidth = m_pcVideoPicYuv->getWidth();
    4925   Int iStrideOrgVid;
    4926 
    4927   UInt uiErr = 0;
    4928 
    4929   if (uiPlane > 0)
    4930   {
    4931     iStartPosX = iStartPosX >> 1;
    4932     iStartPosY = iStartPosY >> 1;
    4933     iRefWidth  = iRefWidth  >> 1;
    4934     iStrideOrgVid = m_pcVideoPicYuv ->getCStride();
    4935   }
    4936   else
    4937   {
    4938     iStrideOrgVid = m_pcVideoPicYuv ->getStride();
    4939   }
    4940 
    4941   for (UInt uiRefPicNum = 0; uiRefPicNum < m_uiNumberRefPics; uiRefPicNum++ )
    4942   {
    4943     Pel* piRefVid;
    4944     Pel* piOrgVid;
    4945     Int  iStrideRefVid;         
    4946 
    4947     if (uiPlane == 0)
    4948     {
    4949       piRefVid = m_apRefPics[uiRefPicNum]->getLumaAddr();
    4950       piOrgVid = m_pcVideoPicYuv ->getLumaAddr();
    4951       iStrideRefVid = m_apRefPics[uiRefPicNum]->getStride(); 
    4952     }
    4953     else
    4954     {
    4955       if (uiPlane == 1)
    4956       {
    4957         piRefVid = m_apRefPics[uiRefPicNum]->getCbAddr();
    4958         piOrgVid = m_pcVideoPicYuv ->getCbAddr();
    4959       }
    4960       else
    4961       {
    4962         piRefVid = m_apRefPics[uiRefPicNum]->getCrAddr();
    4963         piOrgVid = m_pcVideoPicYuv ->getCrAddr();
    4964       }
    4965       iStrideRefVid = m_apRefPics[uiRefPicNum]->getCStride();     
    4966     }
    4967 
    4968 
    4969     piRefVid += iStartPosY * iStrideRefVid;
    4970     piOrgVid += iStartPosY * iStrideOrgVid;
    4971 
    4972     for ( Int iY = 0; iY < uiBlkHeight; iY++ )
    4973     {
    4974       Int iPos = iStartPosX;
    4975 
    4976       for  (Int iX = 0; iX < uiBlkWidth; iX++ )
    4977       {
    4978         int iTargetPos;
    4979 
    4980 
    4981         assert( RemoveBitIncrement(piCur[iX]) >= 0 && RemoveBitIncrement(piCur[iX]) <= 256 );
    4982         iTargetPos = iPos - m_paaiShiftLUTs[uiRefPicNum][0][RemoveBitIncrement(piCur[iX])];
    4983         iTargetPos = iTargetPos >  0         ? iTargetPos : 0;
    4984         iTargetPos = iTargetPos <  iRefWidth ? iTargetPos : iRefWidth-1;
    4985 
    4986         int iSourcePos;
    4987 
    4988         assert( RemoveBitIncrement(piOrg[iX]) >= 0 && RemoveBitIncrement(piOrg[iX]) <= 256 );
    4989         iSourcePos = iPos - m_paaiShiftLUTs[uiRefPicNum][0][RemoveBitIncrement(piOrg[iX])];
    4990         iSourcePos = iSourcePos >  0         ? iSourcePos : 0;
    4991         iSourcePos = iSourcePos <  iRefWidth ? iSourcePos : iRefWidth-1;
    4992 
    4993         Int iDiff = piRefVid[iTargetPos] - piRefVid[iSourcePos];
    4994 
    4995         if ( bSAD )
    4996         {
    4997             uiErr     += abs(iDiff);         
    4998         }
    4999         else
    5000         {
    5001           uiErr     += ((iDiff * iDiff)  >> uiShift) ;         
    5002         }   
    5003         iPos++;
    5004       }
    5005 
    5006       piRefVid   += iStrideRefVid;
    5007       piOrgVid   += iStrideOrgVid;       
    5008 
    5009       piCur      += iCurStride;                 
    5010       piOrg      += iOrgStride;
    5011     }
    5012     piCur        -= iCurStride * uiBlkHeight;                   
    5013     piOrg        -= iOrgStride * uiBlkHeight;
    5014   }
    5015 
    5016   if ( bSAD )
    5017   {
    5018     uiErr = uiErr >> g_uiBitIncrement;
    5019   }
    5020   UInt uiNumRef = Max( 1, m_uiNumberRefPics );
    5021   return ( uiErr + (uiNumRef >> 1) ) / uiNumRef;
    5022 }
    5023 
    5024 
    5025 
    5026 
    5027 #if GERHARD_VQM_XCHECK
    5028 UInt TComRdCost::xGetDistXCheck(  Int iStartPosX, Int iStartPosY, Pel* piCur, Int iCurStride, Pel* piOrg, Int iOrgStride, UInt uiBlkWidth, UInt uiBlkHeight, Bool bSAD )
    5029 {
    5030   UInt uiShift = g_uiBitIncrement << 1;
    5031 
    5032   UInt uiPlane = 0;
    5033   UInt uiErr = 0;
    5034   Int iStrideOrgVid = m_pcVideoPicYuv ->getStride();
    5035 
    5036   Pel* piRefOrg = m_pcVideoPicYuv->getLumaAddr() + iStartPosX + iStrideOrgVid * iStartPosY;
    5037 
    5038   for ( Int iY = 0; iY < uiBlkHeight; iY++ )
    5039   {
    5040     for  (Int iX = 0; iX < uiBlkWidth; iX++ )
    5041     {   
    5042       Int iDiff;
    5043       if (uiPlane != 0)
    5044       {     
    5045        
    5046         iDiff = piCur[iX] - piOrg[iX];
    5047       }
    5048       else
    5049       {
    5050  //     assert( piOrg[iX] == piRefOrg[iX] );
    5051         iDiff = piCur[iX] - piRefOrg[iX];
    5052       }
    5053      
    5054 
    5055       if ( bSAD )
    5056       {
    5057         uiErr     += abs(iDiff);         
    5058       }
    5059       else
    5060       {
    5061         uiErr     += ((iDiff * iDiff)  >> uiShift) ;         
    5062       }               
    5063     }
    5064     piRefOrg   += iStrideOrgVid;
    5065     piCur      += iCurStride;
    5066     piOrg      += iOrgStride;
    5067   }
    5068 
    5069   if ( bSAD )     
    5070   {
    5071     uiErr >>= g_uiBitIncrement;
    5072   }
    5073   return uiErr;
    5074 }
    5075  
    5076 
    5077 #endif
    5078 
    50794757Dist TComRdCost::xGetDistVSOMode4( Int iStartPosX, Int iStartPosY, Pel* piCur, Int iCurStride, Pel* piOrg, Int iOrgStride, UInt uiBlkWidth, UInt uiBlkHeight, Bool bSAD )
    50804758{
     
    50834761
    50844762  RMDist iDistMin = (RMDist) RDO_DIST_MIN;
    5085 #if RDO_DIST_INT
     4763#if HHI_VSO_DIST_INT
    50864764  iDistMin = m_bAllowNegDist ? RDO_DIST_MIN : 0;
    50874765#endif
     
    51324810    pRefInfo->getRefPicYuvAndLUT(m_apRefPics, m_paaiShiftLUTs);
    51334811  }
    5134  
    5135 
    51364812  m_pcVideoPicYuv = pRefInfo->getPicYuvVideo();
    5137 
    5138 #if GERHARD_VQM_XCHECK
    5139   m_pcVideoPicYuv = pRefInfo->getPicYuvOrgDepth(CURRVIEW);
    5140 #endif
    5141 
    51424813}
    51434814
     
    51474818  switch (m_uiVSOMode )
    51484819  {
    5149   case   1:
    5150     m_fpDistortFuncVSO = &TComRdCost::xGetDistVSOMode1;
    5151     break;
    5152   case   2:
    5153     m_fpDistortFuncVSO = &TComRdCost::xGetDistVSOMode2;
    5154     break;
    5155   case   3:
    5156     m_fpDistortFuncVSO = &TComRdCost::xGetDistVSOMode3;
    5157     break;
    51584820  case   4:
    51594821    m_fpDistortFuncVSO = &TComRdCost::xGetDistVSOMode4;
     
    51634825    break;
    51644826  }
    5165 #if GERHARD_VQM_XCHECK
    5166   m_fpDistortFuncVSO = &TComRdCost::xGetDistXCheck;
    5167 #endif
    51684827}
    51694828
     
    52284887}
    52294888
    5230 #if RDO_DIST_INT
     4889#if HHI_VSO_DIST_INT
    52314890Void TComRdCost::setAllowNegDist( Bool bAllowNegDist )
    52324891{
     
    52354894#endif
    52364895
    5237 //GT VSO end
     4896#endif
Note: See TracChangeset for help on using the changeset viewer.