Changeset 537 in 3DVCSoftware for branches/HTM-DEV-0.3-dev2/source/Lib


Ignore:
Timestamp:
13 Jul 2013, 15:51:26 (12 years ago)
Author:
tech
Message:

Update to HM 11.0.

Location:
branches/HTM-DEV-0.3-dev2/source/Lib
Files:
42 edited

Legend:

Unmodified
Added
Removed

  • branches/HTM-DEV-0.3-dev2/source/Lib/TLibCommon/CommonDef.h

    r479 r537  
    115115#define MAX_NUM_REF_PICS            16          ///< max. number of pictures used for reference
    116116#define MAX_NUM_REF                 16          ///< max. number of entries in picture reference list
    117 #if !L0034_COMBINED_LIST_CLEANUP
    118 #define MAX_NUM_REF_LC              MAX_NUM_REF_PICS  // TODO: remove this macro definition (leftover from combined list concept)
    119 #endif
    120117
    121118#define MAX_UINT                    0xFFFFFFFFU ///< max. value of unsigned 32-bit integer

  • branches/HTM-DEV-0.3-dev2/source/Lib/TLibCommon/NAL.h

    r446 r537  
    9494        || m_nalUnitType == NAL_UNIT_CODED_SLICE_RASL_R;
    9595  }
    96 #if L0045_NON_NESTED_SEI_RESTRICTIONS
    9796  Bool isSei()
    9897  {
    … …  
    105104    return ( (UInt)m_nalUnitType < 32 );
    106105  }
    107 #endif
    108106};
    109107

  • branches/HTM-DEV-0.3-dev2/source/Lib/TLibCommon/SEI.cpp

    r446 r537  
    3939#include "SEI.h"
    4040
    41 #if J0149_TONE_MAPPING_SEI
    4241//Table D-7 Meaning of camera iso sensitivity indicator and exposure index rating indicator
    4342Int  Table_exp_indicator[32] = {0, 10, 12, 16, 20, 25, 32, 40, 50, 64, 80, 100, 125, 160, 200, 250, 320, 400, 500, 640, 800, 1000, 1250, 1600, 2000, 2500, 3200, 4000, 5000, 6400, 8000, -1};
    44 #endif
    4543
    4644SEIMessages getSeisByType(SEIMessages &seiList, SEI::PayloadType seiType)

  • branches/HTM-DEV-0.3-dev2/source/Lib/TLibCommon/SEI.h

    r446 r537  
    124124
    125125  SEIActiveParameterSets()
    126 #if !L0047_APS_FLAGS
    127     :numSpsIdsMinus1(0)
    128 #else
    129126    : activeVPSId            (0)
    130127    , m_fullRandomAccessFlag (false)
    131128    , m_noParamSetUpdateFlag (false)
    132129    , numSpsIdsMinus1        (0)
    133 #endif
    134130  {}
    135131  virtual ~SEIActiveParameterSets() {}
    136132
    137133  Int activeVPSId;
    138 #if L0047_APS_FLAGS
    139134  Bool m_fullRandomAccessFlag;
    140135  Bool m_noParamSetUpdateFlag;
    141 #endif
    142136  Int numSpsIdsMinus1;
    143137  std::vector<Int> activeSeqParamSetId;
    … …  
    150144
    151145  SEIBufferingPeriod()
    152 #if L0044_CPB_DPB_DELAY_OFFSET
    153146  : m_bpSeqParameterSetId (0)
    154147  , m_rapCpbParamsPresentFlag (false)
    … …  
    161154    ::memset(m_initialAltCpbRemovalDelayOffset, 0, sizeof(m_initialAltCpbRemovalDelayOffset));
    162155  }
    163 #else
    164   {}
    165 #endif
    166156  virtual ~SEIBufferingPeriod() {}
    167157
    168158  UInt m_bpSeqParameterSetId;
    169159  Bool m_rapCpbParamsPresentFlag;
    170 #if L0044_CPB_DPB_DELAY_OFFSET
    171160  Bool m_cpbDelayOffset;
    172161  Bool m_dpbDelayOffset;
    173 #endif
    174162  UInt m_initialCpbRemovalDelay         [MAX_CPB_CNT][2];
    175163  UInt m_initialCpbRemovalDelayOffset   [MAX_CPB_CNT][2];
    176164  UInt m_initialAltCpbRemovalDelay      [MAX_CPB_CNT][2];
    177165  UInt m_initialAltCpbRemovalDelayOffset[MAX_CPB_CNT][2];
    178 #if L0328_SPLICING
    179166  Bool m_concatenationFlag;
    180167  UInt m_auCpbRemovalDelayDelta;
    181 #endif
    182168};
    183169class SEIPictureTiming : public SEI
    … …  
    188174  SEIPictureTiming()
    189175  : m_picStruct               (0)
    190 #if L0046_RENAME_PROG_SRC_IDC
    191176  , m_sourceScanType          (0)
    192 #else
    193   , m_progressiveSourceIdc    (0)
    194 #endif
    195177  , m_duplicateFlag           (false)
    196 #if L0044_DU_DPB_OUTPUT_DELAY_HRD
    197178  , m_picDpbOutputDuDelay     (0)
    198 #endif
    199179  , m_numNalusInDuMinus1      (NULL)
    200180  , m_duCpbRemovalDelayMinus1 (NULL)
    … …  
    213193
    214194  UInt  m_picStruct;
    215 #if L0046_RENAME_PROG_SRC_IDC
    216195  UInt  m_sourceScanType;
    217 #else
    218   UInt  m_progressiveSourceIdc;
    219 #endif
    220196  Bool  m_duplicateFlag;
    221197
    222198  UInt  m_auCpbRemovalDelay;
    223199  UInt  m_picDpbOutputDelay;
    224 #if L0044_DU_DPB_OUTPUT_DELAY_HRD
    225200  UInt  m_picDpbOutputDuDelay;
    226 #endif
    227201  UInt  m_numDecodingUnitsMinus1;
    228202  Bool  m_duCommonCpbRemovalDelayFlag;
    … …  
    240214    : m_decodingUnitIdx(0)
    241215    , m_duSptCpbRemovalDelay(0)
    242 #if L0044_DU_DPB_OUTPUT_DELAY_HRD
    243216    , m_dpbOutputDuDelayPresentFlag(false)
    244217    , m_picSptDpbOutputDuDelay(0)
    245 #endif
    246218  {}
    247219  virtual ~SEIDecodingUnitInfo() {}
    248220  Int m_decodingUnitIdx;
    249221  Int m_duSptCpbRemovalDelay;
    250 #if L0044_DU_DPB_OUTPUT_DELAY_HRD
    251222  Bool m_dpbOutputDuDelayPresentFlag;
    252223  Int m_picSptDpbOutputDuDelay;
    253 #endif
    254224};
    255225
    … …  
    290260  Int  m_frame1GridPositionY;
    291261  Int  m_arrangementReservedByte;
    292 #if L0045_PERSISTENCE_FLAGS
    293262  Bool m_arrangementPersistenceFlag;
    294 #else
    295   Int  m_arrangementRepetetionPeriod;
    296 #endif
    297263  Bool m_upsampledAspectRatio;
    298264};
    … …  
    305271  SEIDisplayOrientation()
    306272    : cancelFlag(true)
    307 #if L0045_PERSISTENCE_FLAGS
    308273    , persistenceFlag(0)
    309 #else
    310     , repetitionPeriod(1)
    311 #endif
    312274    , extensionFlag(false)
    313275    {}
    … …  
    319281
    320282  UInt anticlockwiseRotation;
    321 #if L0045_PERSISTENCE_FLAGS
    322283  Bool persistenceFlag;
    323 #else
    324   UInt repetitionPeriod;
    325 #endif
    326284  Bool extensionFlag;
    327285};
    … …  
    355313};
    356314
    357 #if L0208_SOP_DESCRIPTION_SEI
    358315class SEISOPDescription : public SEI
    359316{
    … …  
    372329  Int m_sopDescPocDelta[MAX_NUM_PICS_IN_SOP];
    373330};
    374 #endif
    375 
    376 #if J0149_TONE_MAPPING_SEI
     331
    377332class SEIToneMappingInfo : public SEI
    378333{
    … …  
    407362  Int    m_extendedWhiteLevelLumaCodeValue;
    408363};
    409 #endif
    410364
    411365typedef std::list<SEI*> SEIMessages;
    … …  
    420374Void deleteSEIs (SEIMessages &seiList);
    421375
    422 #if K0180_SCALABLE_NESTING_SEI
    423376class SEIScalableNesting : public SEI
    424377{
    … …  
    450403  SEIMessages m_nestedSEIs;
    451404};
    452 #endif
    453405
    454406//! \}

  • branches/HTM-DEV-0.3-dev2/source/Lib/TLibCommon/TComBitStream.h

    r446 r537  
    193193  }
    194194
     195  Void        peekPreviousByte( UInt &byte )
     196  {
     197    assert(m_fifo_idx > 0);
     198    byte = (*m_fifo)[m_fifo_idx - 1];
     199  }
     200 
    195201  Void        readOutTrailingBits ();
    196202  UChar getHeldBits  ()          { return m_held_bits;          }

  • branches/HTM-DEV-0.3-dev2/source/Lib/TLibCommon/TComDataCU.cpp

    r534 r537  
    136136#endif
    137137#endif
    138 
    139138  m_bDecSubCu          = false;
    140139  m_sliceStartCU        = 0;
    … …  
    143142  m_pDvInfo              = NULL;
    144143#endif
    145 
    146144#if H_3D_VSP
    147145  m_piVSPFlag            = NULL;
    148146#endif
    149 
    150147#if H_3D_ARP
    151148  m_puhARPW              = NULL;
    152149#endif
    153 
    154150#if H_3D_IC
    155151  m_pbICFlag             = NULL;
    … …  
    783779  }
    784780
    785   UInt uiTmp = uhWidth*uhHeight;
    786 
    787781  if(getPic()->getPicSym()->getInverseCUOrderMap(getAddr())*m_pcPic->getNumPartInCU()+m_uiAbsIdxInLCU >= getSlice()->getSliceSegmentCurStartCUAddr())
    788782  {
    789783    m_acCUMvField[0].clearMvField();
    790784    m_acCUMvField[1].clearMvField();
    791     uiTmp = uhWidth*uhHeight;
     785    UInt uiTmp = uhWidth*uhHeight;
    792786   
    793787    memset( m_pcTrCoeffY,    0, uiTmp * sizeof( *m_pcTrCoeffY    ) );
    … …  
    10561050  m_uiCUPelY           = pcCU->getCUPelY() + g_auiRasterToPelY[ g_auiZscanToRaster[uiAbsPartIdx] ];
    10571051 
    1058   UInt uiWidth         = g_uiMaxCUWidth  >> uiDepth;
    1059   UInt uiHeight        = g_uiMaxCUHeight >> uiDepth;
    1060  
    10611052  m_skipFlag=pcCU->getSkipFlag()          + uiPart;
    10621053
    … …  
    11391130  m_apcCUColocated[1] = pcCU->getCUColocated(REF_PIC_LIST_1);
    11401131 
    1141   UInt uiTmp = uiWidth*uiHeight;
    11421132  UInt uiMaxCuWidth=pcCU->getSlice()->getSPS()->getMaxCUWidth();
    11431133  UInt uiMaxCuHeight=pcCU->getSlice()->getSPS()->getMaxCUHeight();
    … …  
    11511141  m_pcIPCMSampleY = pcCU->getPCMSampleY() + uiCoffOffset;
    11521142
    1153   uiTmp >>= 2;
    11541143  uiCoffOffset >>=2;
    11551144  m_pcTrCoeffCb=pcCU->getCoeffCb() + uiCoffOffset;
    … …  
    13521341  memcpy( m_sliceStartCU        + uiOffset, pcCU->m_sliceStartCU,        sizeof( UInt ) * uiNumPartition  );
    13531342  memcpy( m_sliceSegmentStartCU + uiOffset, pcCU->m_sliceSegmentStartCU, sizeof( UInt ) * uiNumPartition  );
    1354 
    13551343#if H_3D_ARP
    13561344  memcpy( m_puhARPW             + uiOffset, pcCU->getARPW(),              iSizeInUchar );
    … …  
    14301418#endif
    14311419#endif
    1432 
    14331420  memcpy( rpcCU->getDepth()  + m_uiAbsIdxInLCU, m_puhDepth,  iSizeInUchar );
    14341421  memcpy( rpcCU->getWidth()  + m_uiAbsIdxInLCU, m_puhWidth,  iSizeInUchar );
    … …  
    14651452  memcpy( rpcCU->m_sliceStartCU        + m_uiAbsIdxInLCU, m_sliceStartCU,        sizeof( UInt ) * m_uiNumPartition  );
    14661453  memcpy( rpcCU->m_sliceSegmentStartCU + m_uiAbsIdxInLCU, m_sliceSegmentStartCU, sizeof( UInt ) * m_uiNumPartition  );
    1467 
    14681454#if H_3D_ARP
    14691455  memcpy( rpcCU->getARPW()             + m_uiAbsIdxInLCU, m_puhARPW,             iSizeInUchar );
    … …  
    15391525#endif
    15401526#endif
    1541 
    15421527  memcpy( rpcCU->getDepth()  + uiPartOffset, m_puhDepth,  iSizeInUchar );
    15431528  memcpy( rpcCU->getWidth()  + uiPartOffset, m_puhWidth,  iSizeInUchar );
    … …  
    15751560  memcpy( rpcCU->m_sliceStartCU        + uiPartOffset, m_sliceStartCU,        sizeof( UInt ) * uiQNumPart  );
    15761561  memcpy( rpcCU->m_sliceSegmentStartCU + uiPartOffset, m_sliceSegmentStartCU, sizeof( UInt ) * uiQNumPart  );
    1577 
    15781562#if H_3D_ARP
    15791563  memcpy( rpcCU->getARPW()             + uiPartOffset, m_puhARPW,             iSizeInUchar );
    … …  
    20272011    return getSlice()->getSliceQp();
    20282012  }
    2029   else
    2030   if ( iLastValidPartIdx >= 0 )
     2013  else if ( iLastValidPartIdx >= 0 )
    20312014  {
    20322015    return getQP( iLastValidPartIdx );
    … …  
    22552238}
    22562239#endif
    2257 
    22582240UInt TComDataCU::getCtxInterDir( UInt uiAbsPartIdx )
    22592241{
    … …  
    24922474}
    24932475#endif
    2494 
    24952476Void TComDataCU::setMergeFlagSubParts ( Bool bMergeFlag, UInt uiAbsPartIdx, UInt uiPartIdx, UInt uiDepth )
    24962477{
    … …  
    25092490}
    25102491#endif
    2511 
    25122492Void TComDataCU::setChromIntraDirSubParts( UInt uiDir, UInt uiAbsPartIdx, UInt uiDepth )
    25132493{
    … …  
    30303010
    30313011#endif
    3032 
    30333012/** Constructs a list of merging candidates
    30343013 * \param uiAbsPartIdx
    … …  
    31393118          pcTextureCU->getMvField( pcTextureCU, uiPartIdxCenter, REF_PIC_LIST_1, pcMvFieldNeighbours[(iCount<<1)+1] );
    31403119          TComMv cMvPred = pcMvFieldNeighbours[(iCount<<1)+1].getMv();
    3141 
    31423120#if H_3D_IC
    31433121          const TComMv cAdd( 1 << ( 2 - 1 ), 1 << ( 2 - 1 ) );
    … …  
    35683546    //>> MTK colocated-RightBottom
    35693547    UInt uiPartIdxRB;
    3570     Int uiLCUIdx = getAddr();
    35713548
    35723549    deriveRightBottomIdx( uiPUIdx, uiPartIdxRB ); 
    … …  
    35773554    TComMv cColMv;
    35783555    Int iRefIdx;
     3556    Int uiLCUIdx = -1;
    35793557
    35803558    if      ( ( m_pcPic->getCU(m_uiCUAddr)->getCUPelX() + g_auiRasterToPelX[uiAbsPartIdxTmp] + m_pcPic->getMinCUWidth() ) >= m_pcSlice->getSPS()->getPicWidthInLumaSamples() )  // image boundary check
    35813559    {
    3582       uiLCUIdx = -1;
    35833560    }
    35843561    else if ( ( m_pcPic->getCU(m_uiCUAddr)->getCUPelY() + g_auiRasterToPelY[uiAbsPartIdxTmp] + m_pcPic->getMinCUHeight() ) >= m_pcSlice->getSPS()->getPicHeightInLumaSamples() )
    35853562    {
    3586       uiLCUIdx = -1;
    35873563    }
    35883564    else
    … …  
    35973573      {
    35983574        uiAbsPartAddr = g_auiRasterToZscan[ (uiAbsPartIdxTmp + uiNumPartInCUWidth + 1) % m_pcPic->getNumPartInCU() ];
    3599         uiLCUIdx = -1 ;
    36003575      }
    36013576      else if ( uiAbsPartIdxTmp / uiNumPartInCUWidth < m_pcPic->getNumPartInHeight() - 1 ) // is not at the last row of LCU But is last column of LCU
    … …  
    36073582      {
    36083583        uiAbsPartAddr = 0;
    3609         uiLCUIdx = -1 ;
    36103584      }
    36113585    }
    … …  
    38853859    if (!bAdded)
    38863860    {
    3887       bAdded = xAddMVPCandOrder( pInfo, eRefPicList, iRefIdx, uiPartIdxLB, MD_LEFT );
     3861      xAddMVPCandOrder( pInfo, eRefPicList, iRefIdx, uiPartIdxLB, MD_LEFT );
    38883862    }
    38893863  }
    … …  
    38983872  if(!bAdded)
    38993873  {
    3900     bAdded = xAddMVPCand( pInfo, eRefPicList, iRefIdx, uiPartIdxLT, MD_ABOVE_LEFT);
     3874    xAddMVPCand( pInfo, eRefPicList, iRefIdx, uiPartIdxLT, MD_ABOVE_LEFT);
    39013875  }
    39023876  bAdded = bAddedSmvp;
    … …  
    39133887    if(!bAdded)
    39143888    {
    3915       bAdded = xAddMVPCandOrder( pInfo, eRefPicList, iRefIdx, uiPartIdxLT, MD_ABOVE_LEFT);
     3889      xAddMVPCandOrder( pInfo, eRefPicList, iRefIdx, uiPartIdxLT, MD_ABOVE_LEFT);
    39163890    }
    39173891  }
    … …  
    39333907    UInt uiAbsPartIdx; 
    39343908    UInt uiAbsPartAddr;
    3935     Int uiLCUIdx = getAddr();
    39363909
    39373910    deriveRightBottomIdx( uiPartIdx, uiPartIdxRB );
    … …  
    39403913    //----  co-located RightBottom Temporal Predictor (H) ---//
    39413914    uiAbsPartIdx = g_auiZscanToRaster[uiPartIdxRB];
     3915    Int uiLCUIdx = -1;
    39423916    if ( ( m_pcPic->getCU(m_uiCUAddr)->getCUPelX() + g_auiRasterToPelX[uiAbsPartIdx] + m_pcPic->getMinCUWidth() ) >= m_pcSlice->getSPS()->getPicWidthInLumaSamples() )  // image boundary check
    39433917    {
    3944       uiLCUIdx = -1;
    39453918    }
    39463919    else if ( ( m_pcPic->getCU(m_uiCUAddr)->getCUPelY() + g_auiRasterToPelY[uiAbsPartIdx] + m_pcPic->getMinCUHeight() ) >= m_pcSlice->getSPS()->getPicHeightInLumaSamples() )
    39473920    {
    3948       uiLCUIdx = -1;
    39493921    }
    39503922    else
    … …  
    39593931      {
    39603932        uiAbsPartAddr = g_auiRasterToZscan[ (uiAbsPartIdx + uiNumPartInCUWidth + 1) % m_pcPic->getNumPartInCU() ];
    3961         uiLCUIdx      = -1 ;
    39623933      }
    39633934      else if ( uiAbsPartIdx / uiNumPartInCUWidth < m_pcPic->getNumPartInHeight() - 1 ) // is not at the last row of LCU But is last column of LCU
    … …  
    39693940      {
    39703941        uiAbsPartAddr = 0;
    3971         uiLCUIdx      = -1 ;
    39723942      }
    39733943    }
    … …  
    40434013UInt TComDataCU::getIntraSizeIdx(UInt uiAbsPartIdx)
    40444014{
    4045   UInt uiShift = ( (m_puhTrIdx[uiAbsPartIdx]==0) && (m_pePartSize[uiAbsPartIdx]==SIZE_NxN) ) ? m_puhTrIdx[uiAbsPartIdx]+1 : m_puhTrIdx[uiAbsPartIdx];
    4046   uiShift = ( m_pePartSize[uiAbsPartIdx]==SIZE_NxN ? 1 : 0 );
     4015  UInt uiShift = ( m_pePartSize[uiAbsPartIdx]==SIZE_NxN ? 1 : 0 );
    40474016 
    40484017  UChar uiWidth = m_puhWidth[uiAbsPartIdx]>>uiShift;
    … …  
    41304099  }
    41314100 
    4132 #if L0363_MVP_POC
    41334101  if ( pcTmpCU->getCUMvField(eRefPicList)->getRefIdx(uiIdx) >= 0 && m_pcSlice->getRefPic( eRefPicList, iRefIdx)->getPOC() == pcTmpCU->getSlice()->getRefPOC( eRefPicList, pcTmpCU->getCUMvField(eRefPicList)->getRefIdx(uiIdx) ))
    4134 #else
    4135   if ( m_pcSlice->isEqualRef(eRefPicList, pcTmpCU->getCUMvField(eRefPicList)->getRefIdx(uiIdx), iRefIdx) )
    4136 #endif
    41374102  {
    41384103    TComMv cMvPred = pcTmpCU->getCUMvField(eRefPicList)->getMv(uiIdx);
    … …  
    43404305  }
    43414306  iCurrPOC = m_pcSlice->getPOC();   
    4342   iCurrRefPOC = m_pcSlice->getRefPic(eRefPicList, riRefIdx)->getPOC();
    43434307  iColPOC = pColCU->getSlice()->getPOC(); 
    43444308

  • branches/HTM-DEV-0.3-dev2/source/Lib/TLibCommon/TComLoopFilter.cpp

    r446 r537  
    461461        if ( ((piRefP0==piRefQ0)&&(piRefP1==piRefQ1)) || ((piRefP0==piRefQ1)&&(piRefP1==piRefQ0)) )
    462462        {
    463           uiBs = 0;
    464463          if ( piRefP0 != piRefP1 )   // Different L0 & L1
    465464          {
    … …  
    694693  for ( UInt iIdx = 0; iIdx < uiNumParts; iIdx++ )
    695694  {
    696     ucBs = 0;
    697    
    698695    uiBsAbsIdx = xCalcBsIdx( pcCU, uiAbsZorderIdx, iDir, iEdge, iIdx);
    699696    ucBs = m_aapucBS[iDir][uiBsAbsIdx];

  • branches/HTM-DEV-0.3-dev2/source/Lib/TLibCommon/TComPrediction.cpp

    r532 r537  
    7676  m_acYuvPredBase[1].destroy();
    7777#endif
    78 
    7978  if( m_pLumaRecBuffer )
    8079  {
    … …  
    146145Pel TComPrediction::predIntraGetPredValDC( Int* pSrc, Int iSrcStride, UInt iWidth, UInt iHeight, Bool bAbove, Bool bLeft )
    147146{
     147  assert(iWidth > 0 && iHeight > 0);
    148148  Int iInd, iSum = 0;
    149149  Pel pDcVal;
    … …  
    934934  }
    935935#endif
    936 
    937936  if ( yFrac == 0 )
    938937  {
    … …  
    12461245  return;
    12471246}
    1248 
    12491247#if H_3D_IC
    12501248/** Function for deriving the position of first non-zero binary bit of a value

  • branches/HTM-DEV-0.3-dev2/source/Lib/TLibCommon/TComRdCost.cpp

    r531 r537  
    570570#endif
    571571
    572 #if RATE_CONTROL_LAMBDA_DOMAIN
     572#if RATE_CONTROL_LAMBDA_DOMAIN && !M0036_RC_IMPROVEMENT
    573573UInt TComRdCost::getSADPart ( Int bitDepth, Pel* pelCur, Int curStride,  Pel* pelOrg, Int orgStride, UInt width, UInt height )
    574574{
    … …  
    636636    return xGetSADw( pcDtParam );
    637637  }
    638 
    639638#if H_3D_IC
    640639  if( pcDtParam->bUseIC )
    … …  
    643642  }
    644643#endif
    645 
    646644  Pel* piOrg   = pcDtParam->pOrg;
    647645  Pel* piCur   = pcDtParam->pCur;
    … …  
    675673    return xGetSADw( pcDtParam );
    676674  }
    677 
    678675#if H_3D_IC
    679676  if( pcDtParam->bUseIC )
    … …  
    682679  }
    683680#endif
    684 
    685681  Pel* piOrg      = pcDtParam->pOrg;
    686682  Pel* piCur      = pcDtParam->pCur;
    … …  
    718714    return xGetSADw( pcDtParam );
    719715  }
    720 
    721716#if H_3D_IC
    722717  if( pcDtParam->bUseIC )
    … …  
    725720  }
    726721#endif
    727 
    728722  Pel* piOrg   = pcDtParam->pOrg;
    729723  Pel* piCur   = pcDtParam->pCur;
    … …  
    770764    return xGetSADw( pcDtParam );
    771765  }
    772 
    773766#if H_3D_IC
    774767  if( pcDtParam->bUseIC )
    … …  
    777770  }
    778771#endif
    779 
    780772  Pel* piOrg   = pcDtParam->pOrg;
    781773  Pel* piCur   = pcDtParam->pCur;
    … …  
    820812  }
    821813#endif
    822 
    823814  Pel* piOrg   = pcDtParam->pOrg;
    824815  Pel* piCur   = pcDtParam->pCur;
    … …  
    867858    return xGetSADw( pcDtParam );
    868859  }
    869 
    870860#if H_3D_IC
    871861  if( pcDtParam->bUseIC )
    … …  
    874864  }
    875865#endif
    876 
    877866  Pel* piOrg   = pcDtParam->pOrg;
    878867  Pel* piCur   = pcDtParam->pCur;
    … …  
    935924    return xGetSADw( pcDtParam );
    936925  }
    937 
    938926#if H_3D_IC
    939927  if( pcDtParam->bUseIC )
    … …  
    942930  }
    943931#endif
    944 
    945932  Pel* piOrg   = pcDtParam->pOrg;
    946933  Pel* piCur   = pcDtParam->pCur;
    … …  
    996983    return xGetSADw( pcDtParam );
    997984  }
    998 
    999985#if H_3D_IC
    1000986  if( pcDtParam->bUseIC )
    … …  
    1003989  }
    1004990#endif
    1005 
    1006991  Pel* piOrg   = pcDtParam->pOrg;
    1007992  Pel* piCur   = pcDtParam->pCur;
    … …  
    10961081    return xGetSADw( pcDtParam );
    10971082  }
    1098 
    10991083#if H_3D_IC
    11001084  if( pcDtParam->bUseIC )
    … …  
    11031087  }
    11041088#endif
    1105 
    11061089  Pel* piOrg   = pcDtParam->pOrg;
    11071090  Pel* piCur   = pcDtParam->pCur;
    … …  
    34203403    return xGetHADsw( pcDtParam );
    34213404  }
    3422 
    34233405#if H_3D_IC
    34243406  if( pcDtParam->bUseIC )
    … …  
    34273409  }
    34283410#endif
    3429 
    34303411  Pel* piOrg   = pcDtParam->pOrg;
    34313412  Pel* piCur   = pcDtParam->pCur;

  • branches/HTM-DEV-0.3-dev2/source/Lib/TLibCommon/TComRdCost.h

    r504 r537  
    209209#if RATE_CONTROL_LAMBDA_DOMAIN
    210210  Double  getLambda() { return m_dLambda; }
     211#if M0036_RC_IMPROVEMENT
     212  Double  getChromaWeight () {return((m_cbDistortionWeight+m_crDistortionWeight)/2.0);}
     213#endif
    211214#endif
    212215 
    … …  
    331334#endif
    332335
    333 #if RATE_CONTROL_LAMBDA_DOMAIN
     336#if RATE_CONTROL_LAMBDA_DOMAIN && !M0036_RC_IMPROVEMENT
    334337  UInt   getSADPart ( Int bitDepth, Pel* pelCur, Int curStride,  Pel* pelOrg, Int orgStride, UInt width, UInt height );
    335338#endif

  • branches/HTM-DEV-0.3-dev2/source/Lib/TLibCommon/TComSlice.cpp

    r534 r537  
    6060, m_deblockingFilterBetaOffsetDiv2 ( 0 )
    6161, m_deblockingFilterTcOffsetDiv2   ( 0 )
    62 #if !L0034_COMBINED_LIST_CLEANUP
    63 , m_bRefPicListModificationFlagLC ( false )
    64 , m_bRefPicListCombinationFlag    ( false )
    65 #endif
    6662, m_bCheckLDC                     ( false )
    6763, m_iSliceQpDelta                 ( 0 )
    … …  
    8076#else
    8177, m_dLambda                       ( 0.0 )
    82 #endif
    83 #if !L0034_COMBINED_LIST_CLEANUP
    84 , m_bNoBackPredFlag               ( false )
    8578#endif
    8679, m_uiTLayer                      ( 0 )
    … …  
    131124#endif
    132125{
    133 #if L0034_COMBINED_LIST_CLEANUP
    134126  m_aiNumRefIdx[0] = m_aiNumRefIdx[1] = 0;
    135 #else
    136   m_aiNumRefIdx[0] = m_aiNumRefIdx[1] = m_aiNumRefIdx[2] = 0;
    137 #endif
    138127 
    139128  initEqualRef();
    140129 
    141 #if L0034_COMBINED_LIST_CLEANUP
    142130  for ( Int idx = 0; idx < MAX_NUM_REF; idx++ )
    143131  {
    144132    m_list1IdxToList0Idx[idx] = -1;
    145133  }
    146 #else
    147   for(Int iNumCount = 0; iNumCount < MAX_NUM_REF_LC; iNumCount++)
    148   {
    149     m_iRefIdxOfLC[REF_PIC_LIST_0][iNumCount]=-1;
    150     m_iRefIdxOfLC[REF_PIC_LIST_1][iNumCount]=-1;
    151     m_eListIdFromIdxOfLC[iNumCount]=0;
    152     m_iRefIdxFromIdxOfLC[iNumCount]=0;
    153     m_iRefIdxOfL0FromRefIdxOfL1[iNumCount] = -1;
    154     m_iRefIdxOfL1FromRefIdxOfL0[iNumCount] = -1;
    155   }   
    156 #endif
    157134  for(Int iNumCount = 0; iNumCount < MAX_NUM_REF; iNumCount++)
    158135  {
    … …  
    213190  m_colRefIdx = 0;
    214191  initEqualRef();
    215 #if !L0034_COMBINED_LIST_CLEANUP
    216   m_bNoBackPredFlag = false;
    217   m_bRefPicListCombinationFlag = false;
    218   m_bRefPicListModificationFlagLC = false;
    219 #endif
    220192  m_bCheckLDC = false;
    221193  m_iSliceQpDeltaCb = 0;
    222194  m_iSliceQpDeltaCr = 0;
    223 
    224 #if !L0034_COMBINED_LIST_CLEANUP
    225   m_aiNumRefIdx[REF_PIC_LIST_C]      = 0;
    226 #endif
    227195
    228196#if H_3D_IV_MERGE
    … …  
    378346}
    379347
    380 #if L0034_COMBINED_LIST_CLEANUP
    381348Void TComSlice::setList1IdxToList0Idx()
    382349{
    … …  
    395362  }
    396363}
    397 #else
    398 Void TComSlice::generateCombinedList()
    399 {
    400   if(m_aiNumRefIdx[REF_PIC_LIST_C] > 0)
    401   {
    402     m_aiNumRefIdx[REF_PIC_LIST_C]=0;
    403     for(Int iNumCount = 0; iNumCount < MAX_NUM_REF_LC; iNumCount++)
    404     {
    405       m_iRefIdxOfLC[REF_PIC_LIST_0][iNumCount]=-1;
    406       m_iRefIdxOfLC[REF_PIC_LIST_1][iNumCount]=-1;
    407       m_eListIdFromIdxOfLC[iNumCount]=0;
    408       m_iRefIdxFromIdxOfLC[iNumCount]=0;
    409       m_iRefIdxOfL0FromRefIdxOfL1[iNumCount] = -1;
    410       m_iRefIdxOfL1FromRefIdxOfL0[iNumCount] = -1;
    411     }
    412 
    413     for (Int iNumRefIdx = 0; iNumRefIdx < MAX_NUM_REF; iNumRefIdx++)
    414     {
    415       if(iNumRefIdx < m_aiNumRefIdx[REF_PIC_LIST_0])
    416       {
    417         Bool bTempRefIdxInL2 = true;
    418         for ( Int iRefIdxLC = 0; iRefIdxLC < m_aiNumRefIdx[REF_PIC_LIST_C]; iRefIdxLC++ )
    419         {
    420 #if H_MV
    421           if ( m_apcRefPicList[REF_PIC_LIST_0][iNumRefIdx]->getPOC() == m_apcRefPicList[m_eListIdFromIdxOfLC[iRefIdxLC]][m_iRefIdxFromIdxOfLC[iRefIdxLC]]->getPOC() &&
    422                m_apcRefPicList[REF_PIC_LIST_0][iNumRefIdx]->getLayerId() == m_apcRefPicList[m_eListIdFromIdxOfLC[iRefIdxLC]][m_iRefIdxFromIdxOfLC[iRefIdxLC]]->getLayerId() )
    423 #else
    424           if ( m_apcRefPicList[REF_PIC_LIST_0][iNumRefIdx]->getPOC() == m_apcRefPicList[m_eListIdFromIdxOfLC[iRefIdxLC]][m_iRefIdxFromIdxOfLC[iRefIdxLC]]->getPOC() )
    425 #endif
    426           {
    427             m_iRefIdxOfL1FromRefIdxOfL0[iNumRefIdx] = m_iRefIdxFromIdxOfLC[iRefIdxLC];
    428             m_iRefIdxOfL0FromRefIdxOfL1[m_iRefIdxFromIdxOfLC[iRefIdxLC]] = iNumRefIdx;
    429             bTempRefIdxInL2 = false;
    430             break;
    431           }
    432         }
    433 
    434         if(bTempRefIdxInL2 == true)
    435         {
    436           m_eListIdFromIdxOfLC[m_aiNumRefIdx[REF_PIC_LIST_C]] = REF_PIC_LIST_0;
    437           m_iRefIdxFromIdxOfLC[m_aiNumRefIdx[REF_PIC_LIST_C]] = iNumRefIdx;
    438           m_iRefIdxOfLC[REF_PIC_LIST_0][iNumRefIdx] = m_aiNumRefIdx[REF_PIC_LIST_C]++;
    439         }
    440       }
    441 
    442       if(iNumRefIdx < m_aiNumRefIdx[REF_PIC_LIST_1])
    443       {
    444         Bool bTempRefIdxInL2 = true;
    445         for ( Int iRefIdxLC = 0; iRefIdxLC < m_aiNumRefIdx[REF_PIC_LIST_C]; iRefIdxLC++ )
    446         {
    447 #if H_MV
    448           if ( m_apcRefPicList[REF_PIC_LIST_1][iNumRefIdx]->getPOC() == m_apcRefPicList[m_eListIdFromIdxOfLC[iRefIdxLC]][m_iRefIdxFromIdxOfLC[iRefIdxLC]]->getPOC() &&
    449                m_apcRefPicList[REF_PIC_LIST_1][iNumRefIdx]->getLayerId() == m_apcRefPicList[m_eListIdFromIdxOfLC[iRefIdxLC]][m_iRefIdxFromIdxOfLC[iRefIdxLC]]->getLayerId() )
    450 #else
    451           if ( m_apcRefPicList[REF_PIC_LIST_1][iNumRefIdx]->getPOC() == m_apcRefPicList[m_eListIdFromIdxOfLC[iRefIdxLC]][m_iRefIdxFromIdxOfLC[iRefIdxLC]]->getPOC() )
    452 #endif
    453           {
    454             m_iRefIdxOfL0FromRefIdxOfL1[iNumRefIdx] = m_iRefIdxFromIdxOfLC[iRefIdxLC];
    455             m_iRefIdxOfL1FromRefIdxOfL0[m_iRefIdxFromIdxOfLC[iRefIdxLC]] = iNumRefIdx;
    456             bTempRefIdxInL2 = false;
    457             break;
    458           }
    459         }
    460         if(bTempRefIdxInL2 == true)
    461         {
    462           m_eListIdFromIdxOfLC[m_aiNumRefIdx[REF_PIC_LIST_C]] = REF_PIC_LIST_1;
    463           m_iRefIdxFromIdxOfLC[m_aiNumRefIdx[REF_PIC_LIST_C]] = iNumRefIdx;
    464           m_iRefIdxOfLC[REF_PIC_LIST_1][iNumRefIdx] = m_aiNumRefIdx[REF_PIC_LIST_C]++;
    465         }
    466       }
    467     }
    468   }
    469 }
    470 #endif
    471 
    472364#if H_MV
    473365Void TComSlice::setRefPicList( TComList<TComPic*>& rcListPic, std::vector<TComPic*>& refPicSetInterLayer , Bool checkNumPocTotalCurr)
    … …  
    506398  UInt NumPocLtCurr = 0;
    507399  Int i;
     400
    508401  for(i=0; i < m_pcRPS->getNumberOfNegativePictures(); i++)
    509402  {
    … …  
    585478    }
    586479   
    587     assert(numPocTotalCurr != 0);
     480    assert(numPocTotalCurr > 0);
    588481   
    589482    m_aiNumRefIdx[0] = getNumRefIdx(REF_PIC_LIST_0);
    … …  
    617510    }
    618511#endif
     512  assert(cIdx == numPocTotalCurr);
    619513
    620514  if (m_eSliceType==B_SLICE)
    … …  
    645539      }
    646540#endif
     541    assert(cIdx == numPocTotalCurr);
    647542  }
    648543
    … …  
    673568  }
    674569#else
    675 
    676   for (Int rIdx = 0; rIdx <= (m_aiNumRefIdx[0]-1); rIdx ++)
    677   {
    678     m_apcRefPicList[0][rIdx] = m_RefPicListModification.getRefPicListModificationFlagL0() ? rpsCurrList0[ m_RefPicListModification.getRefPicSetIdxL0(rIdx) ] : rpsCurrList0[rIdx % numPocTotalCurr];
    679     m_bIsUsedAsLongTerm[0][rIdx] = m_RefPicListModification.getRefPicListModificationFlagL0() ? (m_RefPicListModification.getRefPicSetIdxL0(rIdx) >= (NumPocStCurr0 + NumPocStCurr1))
    680                                   : ((rIdx % numPocTotalCurr) >= (NumPocStCurr0 + NumPocStCurr1));
    681   }
    682   if ( m_eSliceType == P_SLICE )
     570  for (Int rIdx = 0; rIdx < m_aiNumRefIdx[0]; rIdx ++)
     571  {
     572    cIdx = m_RefPicListModification.getRefPicListModificationFlagL0() ? m_RefPicListModification.getRefPicSetIdxL0(rIdx) : rIdx % numPocTotalCurr;
     573    assert(cIdx >= 0 && cIdx < numPocTotalCurr);
     574    m_apcRefPicList[0][rIdx] = rpsCurrList0[ cIdx ];
     575    m_bIsUsedAsLongTerm[0][rIdx] = ( cIdx >= NumPocStCurr0 + NumPocStCurr1 );
     576  }
     577  if ( m_eSliceType != B_SLICE )
    683578  {
    684579    m_aiNumRefIdx[1] = 0;
    … …  
    687582  else
    688583  {
    689     for (Int rIdx = 0; rIdx <= (m_aiNumRefIdx[1]-1); rIdx ++)
    690     {
    691       m_apcRefPicList[1][rIdx] = m_RefPicListModification.getRefPicListModificationFlagL1() ? rpsCurrList1[ m_RefPicListModification.getRefPicSetIdxL1(rIdx) ] : rpsCurrList1[rIdx % numPocTotalCurr];
    692       m_bIsUsedAsLongTerm[1][rIdx] = m_RefPicListModification.getRefPicListModificationFlagL1() ?
    693                                   (m_RefPicListModification.getRefPicSetIdxL1(rIdx) >= (NumPocStCurr0 + NumPocStCurr1)): ((rIdx % numPocTotalCurr) >= (NumPocStCurr0 + NumPocStCurr1));
    694     }
    695   }
    696 #endif
    697 }
    698 
    699 #if H_MV && !H_MV_FIX1071
    700 // Temporary fix for FIX1071 should be removed later
    701 Int TComSlice::getNumRpsCurrTempList( TComReferencePictureSet* rps /* = 0 */)
    702 #else
     584    for (Int rIdx = 0; rIdx < m_aiNumRefIdx[1]; rIdx ++)
     585    {
     586      cIdx = m_RefPicListModification.getRefPicListModificationFlagL1() ? m_RefPicListModification.getRefPicSetIdxL1(rIdx) : rIdx % numPocTotalCurr;
     587      assert(cIdx >= 0 && cIdx < numPocTotalCurr);
     588      m_apcRefPicList[1][rIdx] = rpsCurrList1[ cIdx ];
     589      m_bIsUsedAsLongTerm[1][rIdx] = ( cIdx >= NumPocStCurr0 + NumPocStCurr1 );
     590    }
     591  }
     592#endif
     593}
     594
    703595Int TComSlice::getNumRpsCurrTempList()
    704 #endif
    705596{
    706597  Int numRpsCurrTempList = 0;
    … …  
    710601    return 0;
    711602  }
    712 #if H_MV && !H_MV_FIX1071
    713 // Temporary fix for FIX1071 should be removed later
    714   if (rps == NULL)
    715   {
    716     rps = m_pcRPS;
    717   }
    718 
    719   for(UInt i=0; i < rps->getNumberOfNegativePictures()+ rps->getNumberOfPositivePictures() + rps->getNumberOfLongtermPictures(); i++)
    720   {
    721     if(rps->getUsed(i))
    722 #else
    723603  for(UInt i=0; i < m_pcRPS->getNumberOfNegativePictures()+ m_pcRPS->getNumberOfPositivePictures() + m_pcRPS->getNumberOfLongtermPictures(); i++)
    724604  {
    725605    if(m_pcRPS->getUsed(i))
    726 #endif
    727606    {
    728607      numRpsCurrTempList++;
    … …  
    945824  m_deblockingFilterTcOffsetDiv2 = pSrc->m_deblockingFilterTcOffsetDiv2;
    946825 
    947 #if L0034_COMBINED_LIST_CLEANUP
    948826  for (i = 0; i < 2; i++)
    949 #else
    950   for (i = 0; i < 3; i++)
    951 #endif
    952827  {
    953828    m_aiNumRefIdx[i]     = pSrc->m_aiNumRefIdx[i];
    954829  }
    955830
    956 #if L0034_COMBINED_LIST_CLEANUP
    957831  for (i = 0; i < MAX_NUM_REF; i++)
    958832  {
    959833    m_list1IdxToList0Idx[i] = pSrc->m_list1IdxToList0Idx[i];
    960834  }
    961 #else
    962   for (i = 0; i < 2; i++)
    963   {
    964     for (j = 0; j < MAX_NUM_REF_LC; j++)
    965     {
    966        m_iRefIdxOfLC[i][j]  = pSrc->m_iRefIdxOfLC[i][j];
    967     }
    968   }
    969   for (i = 0; i < MAX_NUM_REF_LC; i++)
    970   {
    971     m_eListIdFromIdxOfLC[i] = pSrc->m_eListIdFromIdxOfLC[i];
    972     m_iRefIdxFromIdxOfLC[i] = pSrc->m_iRefIdxFromIdxOfLC[i];
    973     m_iRefIdxOfL1FromRefIdxOfL0[i] = pSrc->m_iRefIdxOfL1FromRefIdxOfL0[i];
    974     m_iRefIdxOfL0FromRefIdxOfL1[i] = pSrc->m_iRefIdxOfL0FromRefIdxOfL1[i];
    975   }
    976   m_bRefPicListModificationFlagLC = pSrc->m_bRefPicListModificationFlagLC;
    977   m_bRefPicListCombinationFlag    = pSrc->m_bRefPicListCombinationFlag;
    978 #endif
    979835  m_bCheckLDC             = pSrc->m_bCheckLDC;
    980836  m_iSliceQpDelta        = pSrc->m_iSliceQpDelta;
    … …  
    1014870
    1015871  m_pcPic                = pSrc->m_pcPic;
     872
    1016873  m_colFromL0Flag        = pSrc->m_colFromL0Flag;
    1017874  m_colRefIdx            = pSrc->m_colRefIdx;
    … …  
    1033890  }
    1034891
    1035 #if !L0034_COMBINED_LIST_CLEANUP
    1036   m_bNoBackPredFlag      = pSrc->m_bNoBackPredFlag;
    1037 #endif
    1038892  m_uiTLayer                      = pSrc->m_uiTLayer;
    1039893  m_bTLayerSwitchingFlag          = pSrc->m_bTLayerSwitchingFlag;
    … …  
    13661220/** Function for constructing an explicit Reference Picture Set out of the available pictures in a referenced Reference Picture Set
    13671221*/
    1368 #if FIX1071 && H_MV_FIX1071
     1222#if FIX1071
    13691223Void TComSlice::createExplicitReferencePictureSetFromReference( TComList<TComPic*>& rcListPic, TComReferencePictureSet *pReferencePictureSet, Bool isRAP)
    13701224#else
    … …  
    13951249        // and should be added to the explicit Reference Picture Set
    13961250        pcRPS->setDeltaPOC(k, pReferencePictureSet->getDeltaPOC(i));
    1397 #if FIX1071 && H_MV_FIX1071
     1251#if FIX1071
    13981252        pcRPS->setUsed(k, pReferencePictureSet->getUsed(i) && (!isRAP));
    13991253#else
    … …  
    15661420  {
    15671421    m_numReorderPics[i] = 0;
    1568 #if L0323_DPB
    15691422    m_uiMaxDecPicBuffering[i] = 1;
    1570 #else
    1571     m_uiMaxDecPicBuffering[i] = 0;
    1572 #endif
    15731423    m_uiMaxLatencyIncrease[i] = 0;
    15741424  }
    … …  
    20051855, m_pcmLog2MaxSize            (  5)
    20061856, m_uiPCMLog2MinSize          (  7)
    2007 #if !L0034_COMBINED_LIST_CLEANUP
    2008 , m_bUseLComb                 (false)
    2009 #endif
    20101857, m_bitDepthY                 (  8)
    20111858, m_bitDepthC                 (  8)
    … …  
    20371884  {
    20381885    m_uiMaxLatencyIncrease[i] = 0;
    2039 #if L0323_DPB
    20401886    m_uiMaxDecPicBuffering[i] = 1;
    2041 #else
    2042     m_uiMaxDecPicBuffering[i] = 0;
    2043 #endif
    20441887    m_numReorderPics[i]       = 0;
    20451888  }
    … …  
    20791922  TComHRD *hrd = vui->getHrdParameters();
    20801923
    2081 #if L0043_TIMING_INFO
    20821924  TimingInfo *timingInfo = vui->getTimingInfo();
    20831925  timingInfo->setTimingInfoPresentFlag( true );
    … …  
    21031945    break;
    21041946  }
    2105 #else
    2106   hrd->setTimingInfoPresentFlag( true );
    2107   switch( frameRate )
    2108   {
    2109   case 24:
    2110     hrd->setNumUnitsInTick( 1125000 );    hrd->setTimeScale    ( 27000000 );
    2111     break;
    2112   case 25:
    2113     hrd->setNumUnitsInTick( 1080000 );    hrd->setTimeScale    ( 27000000 );
    2114     break;
    2115   case 30:
    2116     hrd->setNumUnitsInTick( 900900 );     hrd->setTimeScale    ( 27000000 );
    2117     break;
    2118   case 50:
    2119     hrd->setNumUnitsInTick( 540000 );     hrd->setTimeScale    ( 27000000 );
    2120     break;
    2121   case 60:
    2122     hrd->setNumUnitsInTick( 450450 );     hrd->setTimeScale    ( 27000000 );
    2123     break;
    2124   default:
    2125     hrd->setNumUnitsInTick( 1001 );       hrd->setTimeScale    ( 60000 );
    2126     break;
    2127   }
    2128 #endif
    21291947
    21301948  Bool rateCnt = ( bitRate > 0 );
    … …  
    21391957    hrd->setDuCpbRemovalDelayLengthMinus1( 7 );                    // 8-bit precision ( plus 1 for last DU in AU )
    21401958    hrd->setSubPicCpbParamsInPicTimingSEIFlag( true );
    2141 #if L0044_DU_DPB_OUTPUT_DELAY_HRD
    21421959    hrd->setDpbOutputDelayDuLengthMinus1( 5 + 7 );                 // With sub-clock tick factor of 100, at least 7 bits to have the same value as AU dpb delay
    2143 #endif
    21441960  }
    21451961  else
    … …  
    21701986  UInt birateValue, cpbSizeValue;
    21711987  UInt ducpbSizeValue;
    2172 #if L0363_DU_BIT_RATE
    21731988  UInt duBitRateValue = 0;
    2174 #endif
    21751989
    21761990  for( i = 0; i < MAX_TLAYER; i ++ )
    … …  
    21841998    cpbSizeValue = bitRate;                                     // 1 second
    21851999    ducpbSizeValue = bitRate/numDU;
    2186 #if L0363_DU_BIT_RATE
    21872000    duBitRateValue = bitRate;
    2188 #endif
    21892001    for( j = 0; j < ( hrd->getCpbCntMinus1( i ) + 1 ); j ++ )
    21902002    {
    … …  
    21972009      hrd->setCpbSizeValueMinus1( i, j, 1, ( cpbSizeValue - 1 ) );
    21982010      hrd->setDuCpbSizeValueMinus1( i, j, 1, ( ducpbSizeValue - 1 ) );
    2199 #if L0363_DU_BIT_RATE
    22002011      hrd->setDuBitRateValueMinus1( i, j, 1, ( duBitRateValue - 1 ) );
    2201 #endif
    22022012      hrd->setCbrFlag( i, j, 1, ( j == 0 ) );
    22032013    }
    … …  
    22822092}
    22832093#endif
    2284 
    22852094TComReferencePictureSet::TComReferencePictureSet()
    22862095: m_numberOfPictures (0)
    … …  
    31672976  , m_profileIdc      (0)
    31682977  , m_levelIdc        (0)
    3169 #if L0046_CONSTRAINT_FLAGS
    31702978, m_progressiveSourceFlag  (false)
    31712979, m_interlacedSourceFlag   (false)
    31722980, m_nonPackedConstraintFlag(false)
    31732981, m_frameOnlyConstraintFlag(false)
    3174 #endif
    31752982{
    31762983  ::memset(m_profileCompatibilityFlag, 0, sizeof(m_profileCompatibilityFlag));
    … …  
    32053012}
    32063013#endif
    3207 
    32083014//! \}

  • branches/HTM-DEV-0.3-dev2/source/Lib/TLibCommon/TComSlice.h

    r535 r537  
    190190  Int     m_levelIdc;
    191191
    192 #if L0046_CONSTRAINT_FLAGS
    193192  Bool m_progressiveSourceFlag;
    194193  Bool m_interlacedSourceFlag;
    195194  Bool m_nonPackedConstraintFlag;
    196195  Bool m_frameOnlyConstraintFlag;
    197 #endif
    198196 
    199197public:
    … …  
    215213  Void  setLevelIdc(Int x)      { m_levelIdc = x; }
    216214 
    217 #if L0046_CONSTRAINT_FLAGS
    218215  Bool getProgressiveSourceFlag() const { return m_progressiveSourceFlag; }
    219216  Void setProgressiveSourceFlag(Bool b) { m_progressiveSourceFlag = b; }
    … …  
    227224  Bool getFrameOnlyConstraintFlag() const { return m_frameOnlyConstraintFlag; }
    228225  Void setFrameOnlyConstraintFlag(Bool b) { m_frameOnlyConstraintFlag = b; }
    229 #endif
    230226};
    231227
    … …  
    253249};
    254250/// VPS class
    255 
    256 #if SIGNAL_BITRATE_PICRATE_IN_VPS
    257 class TComBitRatePicRateInfo
    258 {
    259   Bool        m_bitRateInfoPresentFlag[MAX_TLAYER];
    260   Bool        m_picRateInfoPresentFlag[MAX_TLAYER];
    261   Int         m_avgBitRate[MAX_TLAYER];
    262   Int         m_maxBitRate[MAX_TLAYER];
    263   Int         m_constantPicRateIdc[MAX_TLAYER];
    264   Int         m_avgPicRate[MAX_TLAYER];
    265 public:
    266   TComBitRatePicRateInfo();
    267   Bool        getBitRateInfoPresentFlag(Int i) {return m_bitRateInfoPresentFlag[i];}
    268   Void        setBitRateInfoPresentFlag(Int i, Bool x) {m_bitRateInfoPresentFlag[i] = x;}
    269 
    270   Bool        getPicRateInfoPresentFlag(Int i) {return m_picRateInfoPresentFlag[i];}
    271   Void        setPicRateInfoPresentFlag(Int i, Bool x) {m_picRateInfoPresentFlag[i] = x;}
    272 
    273   Int         getAvgBitRate(Int i) {return m_avgBitRate[i];}
    274   Void        setAvgBitRate(Int i, Int x) {m_avgBitRate[i] = x;}
    275 
    276   Int         getMaxBitRate(Int i) {return m_maxBitRate[i];}
    277   Void        setMaxBitRate(Int i, Int x) {m_maxBitRate[i] = x;}
    278 
    279   Int         getConstantPicRateIdc(Int i) {return m_constantPicRateIdc[i];}
    280   Void        setConstantPicRateIdc(Int i, Int x) {m_constantPicRateIdc[i] = x;}
    281 
    282   Int         getAvgPicRate(Int i) {return m_avgPicRate[i];}
    283   Void        setAvgPicRate(Int i, Int x) {m_avgPicRate[i] = x;}
    284 };
    285 #endif
    286251
    287252struct HrdSubLayerInfo
    … …  
    296261  UInt ducpbSizeValue    [MAX_CPB_CNT][2];
    297262  UInt cbrFlag           [MAX_CPB_CNT][2];
    298 #if L0363_DU_BIT_RATE
    299263  UInt duBitRateValue    [MAX_CPB_CNT][2];
    300 #endif
    301264};
    302265
    … …  
    304267{
    305268private:
    306 #if !L0043_TIMING_INFO
    307   Bool m_timingInfoPresentFlag;
    308   UInt m_numUnitsInTick;
    309   UInt m_timeScale;
    310 #endif
    311269  Bool m_nalHrdParametersPresentFlag;
    312270  Bool m_vclHrdParametersPresentFlag;
    … …  
    315273  UInt m_duCpbRemovalDelayLengthMinus1;
    316274  Bool m_subPicCpbParamsInPicTimingSEIFlag;
    317 #if L0044_DU_DPB_OUTPUT_DELAY_HRD
    318275  UInt m_dpbOutputDelayDuLengthMinus1;
    319 #endif
    320276  UInt m_bitRateScale;
    321277  UInt m_cpbSizeScale;
    … …  
    329285public:
    330286  TComHRD()
    331 #if !L0043_TIMING_INFO
    332   :m_timingInfoPresentFlag(false)
    333   ,m_numUnitsInTick(1001)
    334   ,m_timeScale(60000)
    335   ,m_nalHrdParametersPresentFlag(0)
    336 #else
    337287  :m_nalHrdParametersPresentFlag(0)
    338 #endif
    339288  ,m_vclHrdParametersPresentFlag(0)
    340289  ,m_subPicCpbParamsPresentFlag(false)
    … …  
    342291  ,m_duCpbRemovalDelayLengthMinus1(0)
    343292  ,m_subPicCpbParamsInPicTimingSEIFlag(false)
    344 #if L0044_DU_DPB_OUTPUT_DELAY_HRD
    345293  ,m_dpbOutputDelayDuLengthMinus1(0)
    346 #endif
    347294  ,m_bitRateScale(0)
    348295  ,m_cpbSizeScale(0)
    … …  
    353300
    354301  virtual ~TComHRD() {}
    355 #if !L0043_TIMING_INFO
    356   Void setTimingInfoPresentFlag             ( Bool flag )  { m_timingInfoPresentFlag = flag;               }
    357   Bool getTimingInfoPresentFlag             ( )            { return m_timingInfoPresentFlag;               }
    358 
    359   Void setNumUnitsInTick                    ( UInt value ) { m_numUnitsInTick = value;                     }
    360   UInt getNumUnitsInTick                    ( )            { return m_numUnitsInTick;                      }
    361 
    362   Void setTimeScale                         ( UInt value ) { m_timeScale = value;                          }
    363   UInt getTimeScale                         ( )            { return m_timeScale;                           }
    364 #endif
    365302
    366303  Void setNalHrdParametersPresentFlag       ( Bool flag )  { m_nalHrdParametersPresentFlag = flag;         }
    … …  
    382319  Bool getSubPicCpbParamsInPicTimingSEIFlag ()             { return m_subPicCpbParamsInPicTimingSEIFlag;   }
    383320
    384 #if L0044_DU_DPB_OUTPUT_DELAY_HRD
    385321  Void setDpbOutputDelayDuLengthMinus1      (UInt value )  { m_dpbOutputDelayDuLengthMinus1 = value;       }
    386322  UInt getDpbOutputDelayDuLengthMinus1      ()             { return m_dpbOutputDelayDuLengthMinus1;        }
    387 #endif
    388323
    389324  Void setBitRateScale                      ( UInt value ) { m_bitRateScale = value;                       }
    … …  
    426361  Void setDuCpbSizeValueMinus1     ( Int layer, Int cpbcnt, Int nalOrVcl, UInt value ) { m_HRD[layer].ducpbSizeValue[cpbcnt][nalOrVcl] = value;       }
    427362  UInt getDuCpbSizeValueMinus1     ( Int layer, Int cpbcnt, Int nalOrVcl            )  { return m_HRD[layer].ducpbSizeValue[cpbcnt][nalOrVcl];        }
    428 #if L0363_DU_BIT_RATE
    429363  Void setDuBitRateValueMinus1     ( Int layer, Int cpbcnt, Int nalOrVcl, UInt value ) { m_HRD[layer].duBitRateValue[cpbcnt][nalOrVcl] = value;       }
    430364  UInt getDuBitRateValueMinus1     (Int layer, Int cpbcnt, Int nalOrVcl )              { return m_HRD[layer].duBitRateValue[cpbcnt][nalOrVcl];        }
    431 #endif
    432365  Void setCbrFlag                ( Int layer, Int cpbcnt, Int nalOrVcl, UInt value ) { m_HRD[layer].cbrFlag[cpbcnt][nalOrVcl] = value;            }
    433366  Bool getCbrFlag                ( Int layer, Int cpbcnt, Int nalOrVcl             ) { return m_HRD[layer].cbrFlag[cpbcnt][nalOrVcl];             }
    … …  
    435368  Void setNumDU                              ( UInt value ) { m_numDU = value;                            }
    436369  UInt getNumDU                              ( )            { return m_numDU;          }
    437 #if L0045_CONDITION_SIGNALLING
    438370  Bool getCpbDpbDelaysPresentFlag() { return getNalHrdParametersPresentFlag() || getVclHrdParametersPresentFlag(); }
    439 #endif
    440371};
    441372
    442 #if L0043_TIMING_INFO
    443373class TimingInfo
    444374{
    … …  
    471401  Void setNumTicksPocDiffOneMinus1          (Int x       ) { m_numTicksPocDiffOneMinus1 = x;               }
    472402};
    473 #endif
    474403
    475404class TComVPS
    … …  
    483412  UInt        m_numReorderPics[MAX_TLAYER];
    484413  UInt        m_uiMaxDecPicBuffering[MAX_TLAYER];
    485   UInt        m_uiMaxLatencyIncrease[MAX_TLAYER];
     414  UInt        m_uiMaxLatencyIncrease[MAX_TLAYER]; // Really max latency increase plus 1 (value 0 expresses no limit)
    486415
    487416  UInt        m_numHrdParameters;
    … …  
    507436  TComPTL     m_pcPTL;
    508437#endif
    509 #if SIGNAL_BITRATE_PICRATE_IN_VPS
    510   TComBitRatePicRateInfo    m_bitRatePicRateInfo;
    511 #endif
    512 #if L0043_TIMING_INFO
    513438  TimingInfo  m_timingInfo;
    514 #endif
    515 
    516439#if H_MV
    517440  /// VPS EXTENSION SYNTAX ELEMENTS
    … …  
    648571  TComPTL* getPTL() { return &m_pcPTL; }
    649572#endif
    650 #if SIGNAL_BITRATE_PICRATE_IN_VPS
    651   TComBitRatePicRateInfo *getBitratePicrateInfo() { return &m_bitRatePicRateInfo; }
    652 #endif
    653 #if L0043_TIMING_INFO
    654573  TimingInfo* getTimingInfo() { return &m_timingInfo; }
    655 #endif
    656574#if H_MV
    657575  Void    setAvcBaseLayerFlag( Bool val )                                  { m_avcBaseLayerFlag = val;  }
    … …  
    878796  Int  m_log2MaxMvLengthVertical;
    879797  TComHRD m_hrdParameters;
    880 #if L0043_TIMING_INFO
    881798  TimingInfo m_timingInfo;
    882 #else
    883   Bool m_pocProportionalToTimingFlag;
    884   Int  m_numTicksPocDiffOneMinus1;
    885 #endif
    886799#if H_MV
    887800  Bool m_tileBoundariesAlignedFlag;
    888801#endif
     802
    889803public:
    890804  TComVUI()
    … …  
    918832    ,m_log2MaxMvLengthHorizontal(15)
    919833    ,m_log2MaxMvLengthVertical(15)
    920 #if !L0043_TIMING_INFO 
    921     ,m_pocProportionalToTimingFlag(false)
    922     ,m_numTicksPocDiffOneMinus1(0)
    923 #endif
    924834#if H_MV
    925835    ,m_tileBoundariesAlignedFlag(true)
    … …  
    1019929
    1020930  TComHRD* getHrdParameters                 ()             { return &m_hrdParameters; }
    1021 #if L0043_TIMING_INFO
    1022931  TimingInfo* getTimingInfo() { return &m_timingInfo; }
    1023 #else
    1024   Bool getPocProportionalToTimingFlag() {return m_pocProportionalToTimingFlag; }
    1025   Void setPocProportionalToTimingFlag(Bool x) {m_pocProportionalToTimingFlag = x;}
    1026   Int  getNumTicksPocDiffOneMinus1() {return m_numTicksPocDiffOneMinus1;}
    1027   Void setNumTicksPocDiffOneMinus1(Int x) { m_numTicksPocDiffOneMinus1 = x;}
    1028 #endif
    1029 #if H_MV
    1030   Bool getTileBoundariesAlignedFlag(  ) { return m_tileBoundariesAlignedFlag; }
     932#if H_MV
     933Bool getTileBoundariesAlignedFlag(  ) { return m_tileBoundariesAlignedFlag; }
    1031934  Void setTileBoundariesAlignedFlag( Bool flag ) { m_tileBoundariesAlignedFlag = flag; }
    1032935#endif
    … …  
    1070973  Bool        m_useAMP;
    1071974
    1072 #if !L0034_COMBINED_LIST_CLEANUP
    1073   Bool        m_bUseLComb;
    1074 #endif
    1075  
    1076975  // Parameter
    1077976  Int         m_bitDepthY;
    … …  
    11021001  TComScalingList*     m_scalingList;   //!< ScalingList class pointer
    11031002  UInt        m_uiMaxDecPicBuffering[MAX_TLAYER];
    1104   UInt        m_uiMaxLatencyIncrease[MAX_TLAYER];
     1003  UInt        m_uiMaxLatencyIncrease[MAX_TLAYER];  // Really max latency increase plus 1 (value 0 expresses no limit)
    11051004
    11061005  Bool        m_useDF;
    … …  
    12031102 
    12041103  // Tool list
    1205 #if !L0034_COMBINED_LIST_CLEANUP
    1206   Void setUseLComb    (Bool b)   { m_bUseLComb = b;         }
    1207   Bool getUseLComb    ()         { return m_bUseLComb;      }
    1208 #endif
    1209 
    12101104  Bool getUseLossless ()         { return m_useLossless; }
    12111105  Void setUseLossless ( Bool b ) { m_useLossless  = b; }
    … …  
    15541448  Int         m_deblockingFilterBetaOffsetDiv2;    //< beta offset for deblocking filter
    15551449  Int         m_deblockingFilterTcOffsetDiv2;      //< tc offset for deblocking filter
    1556 #if L0034_COMBINED_LIST_CLEANUP
    15571450  Int         m_list1IdxToList0Idx[MAX_NUM_REF];
    15581451  Int         m_aiNumRefIdx   [2];    //  for multiple reference of current slice
    1559 #else
    1560   Int         m_aiNumRefIdx   [3];    //  for multiple reference of current slice
    1561 
    1562   Int         m_iRefIdxOfLC[2][MAX_NUM_REF_LC];
    1563   Int         m_eListIdFromIdxOfLC[MAX_NUM_REF_LC];
    1564   Int         m_iRefIdxFromIdxOfLC[MAX_NUM_REF_LC];
    1565   Int         m_iRefIdxOfL1FromRefIdxOfL0[MAX_NUM_REF_LC];
    1566   Int         m_iRefIdxOfL0FromRefIdxOfL1[MAX_NUM_REF_LC];
    1567   Bool        m_bRefPicListModificationFlagLC;
    1568   Bool        m_bRefPicListCombinationFlag;
    1569 #endif
    15701452
    15711453  Bool        m_bCheckLDC;
    … …  
    16081490
    16091491  Bool        m_abEqualRef  [2][MAX_NUM_REF][MAX_NUM_REF];
    1610 #if !L0034_COMBINED_LIST_CLEANUP
    1611   Bool        m_bNoBackPredFlag;
    1612 #endif
    16131492  UInt        m_uiTLayer;
    16141493  Bool        m_bTLayerSwitchingFlag;
    … …  
    16851564#endif
    16861565#endif
    1687 
    16881566public:
    16891567  TComSlice();
    … …  
    17611639  UInt      getARPStepNum( )                                                         { return m_nARPStepNum;                                         } 
    17621640#endif
    1763 
    17641641  Int       getDepth            ()                              { return  m_iDepth;                     }
    17651642  UInt      getColFromL0Flag    ()                              { return  m_colFromL0Flag;              }
    … …  
    17691646  Bool      getCheckLDC     ()                                  { return m_bCheckLDC; }
    17701647  Bool      getMvdL1ZeroFlag ()                                  { return m_bLMvdL1Zero;    }
    1771 #if H_MV && !H_MV_FIX1071  // This is a temporary fix of the temporary fix L0177
    1772   Int       getNumRpsCurrTempList( TComReferencePictureSet* rps = NULL );
    1773 #else
    17741648  Int       getNumRpsCurrTempList();
    1775 #endif
    1776 #if L0034_COMBINED_LIST_CLEANUP
    17771649  Int       getList1IdxToList0Idx ( Int list1Idx )               { return m_list1IdxToList0Idx[list1Idx]; }
    1778 #else
    1779   Int       getRefIdxOfLC       (RefPicList e, Int iRefIdx)     { return m_iRefIdxOfLC[e][iRefIdx];           }
    1780   Int       getListIdFromIdxOfLC(Int iRefIdx)                   { return m_eListIdFromIdxOfLC[iRefIdx];       }
    1781   Int       getRefIdxFromIdxOfLC(Int iRefIdx)                   { return m_iRefIdxFromIdxOfLC[iRefIdx];       }
    1782   Int       getRefIdxOfL0FromRefIdxOfL1(Int iRefIdx)            { return m_iRefIdxOfL0FromRefIdxOfL1[iRefIdx];}
    1783   Int       getRefIdxOfL1FromRefIdxOfL0(Int iRefIdx)            { return m_iRefIdxOfL1FromRefIdxOfL0[iRefIdx];}
    1784   Bool      getRefPicListModificationFlagLC()                   {return m_bRefPicListModificationFlagLC;}
    1785   Void      setRefPicListModificationFlagLC(Bool bflag)         {m_bRefPicListModificationFlagLC=bflag;}     
    1786   Bool      getRefPicListCombinationFlag()                      {return m_bRefPicListCombinationFlag;}
    1787   Void      setRefPicListCombinationFlag(Bool bflag)            {m_bRefPicListCombinationFlag=bflag;}   
    1788 #endif
    17891650  Void      setReferenced(Bool b)                               { m_bRefenced = b; }
    17901651  Bool      isReferenced()                                      { return m_bRefenced; }
    … …  
    18611722 
    18621723  static Void      sortPicList         ( TComList<TComPic*>& rcListPic );
    1863 #if L0034_COMBINED_LIST_CLEANUP
    18641724  Void setList1IdxToList0Idx();
    1865 #else
    1866   Bool getNoBackPredFlag() { return m_bNoBackPredFlag; }
    1867   Void setNoBackPredFlag( Bool b ) { m_bNoBackPredFlag = b; }
    1868   Void generateCombinedList       ();
    1869 #endif
    18701725
    18711726  UInt getTLayer             ()                            { return m_uiTLayer;                      }
    … …  
    18801735  static Void markCurrPic                 ( TComPic* currPic );;
    18811736  static Void markIvRefPicsAsUnused       ( TComPicLists* ivPicLists, std::vector<Int> targetDecLayerIdSet, TComVPS* vps, Int curLayerId, Int curPoc  );
    1882 
    1883 
    1884   Void xPrintRefPicList();
     1737  Void        xPrintRefPicList();
    18851738#endif
    18861739  Bool isTemporalLayerSwitchingPoint( TComList<TComPic*>& rcListPic );
    18871740  Bool isStepwiseTemporalLayerSwitchingPointCandidate( TComList<TComPic*>& rcListPic );
    18881741  Int       checkThatAllRefPicsAreAvailable( TComList<TComPic*>& rcListPic, TComReferencePictureSet *pReferencePictureSet, Bool printErrors, Int pocRandomAccess = 0);
    1889 #if FIX1071 && H_MV_FIX1071
     1742#if FIX1071
    18901743  Void      createExplicitReferencePictureSetFromReference( TComList<TComPic*>& rcListPic, TComReferencePictureSet *pReferencePictureSet, Bool isRAP);
    18911744#else
    … …  
    20361889
    20371890#endif
    2038 
    20391891protected:
    20401892  TComPic*  xGetRefPic  (TComList<TComPic*>& rcListPic,

  • branches/HTM-DEV-0.3-dev2/source/Lib/TLibCommon/TComTrQuant.cpp

    r446 r537  
    10751075    Int iTransformShift = MAX_TR_DYNAMIC_RANGE - uiBitDepth - uiLog2TrSize;  // Represents scaling through forward transform
    10761076
    1077     Int iQBits = QUANT_SHIFT + m_cQP.m_iPer + iTransformShift;                // Right shift of non-RDOQ quantizer;  level = (coeff*uiQ + offset)>>q_bits
    1078 
    1079     iAdd = (pcCU->getSlice()->getSliceType()==I_SLICE ? 171 : 85) << (iQBits-9);
    1080 
    10811077#if ADAPTIVE_QP_SELECTION
    1082     iQBits = QUANT_SHIFT + cQpBase.m_iPer + iTransformShift;
     1078    Int iQBits = QUANT_SHIFT + cQpBase.m_iPer + iTransformShift;
    10831079    iAdd = (pcCU->getSlice()->getSliceType()==I_SLICE ? 171 : 85) << (iQBits-9);
    10841080    Int iQBitsC = QUANT_SHIFT + cQpBase.m_iPer + iTransformShift - ARL_C_PRECISION; 
    10851081    Int iAddC   = 1 << (iQBitsC-1);
     1082#else
     1083    Int iQBits = QUANT_SHIFT + m_cQP.m_iPer + iTransformShift;                // Right shift of non-RDOQ quantizer;  level = (coeff*uiQ + offset)>>q_bits
     1084    iAdd = (pcCU->getSlice()->getSliceType()==I_SLICE ? 171 : 85) << (iQBits-9);
    10861085#endif
    10871086
    … …  
    13471346#else
    13481347  Int j;
    1349   {
    1350     Short block[ 64 * 64 ];
    1351     Short coeff[ 64 * 64 ];
    1352     {
     1348  Short block[ 32 * 32 ];
     1349  Short coeff[ 32 * 32 ];
    13531350      for (j = 0; j < iHeight; j++)
    13541351      {   
    13551352        memcpy( block + j * iWidth, piBlkResi + j * uiStride, iWidth * sizeof( Short ) );
    13561353      }
    1357     }
    13581354    xTrMxN(bitDepth, block, coeff, iWidth, iHeight, uiMode );
    13591355    for ( j = 0; j < iHeight * iWidth; j++ )
    … …  
    13611357      psCoeff[ j ] = coeff[ j ];
    13621358    }
    1363     return ;
    1364   }
    13651359#endif 
    13661360}
    … …  
    13821376  Int j;
    13831377  {
    1384     Short block[ 64 * 64 ];
    1385     Short coeff[ 64 * 64 ];
     1378    Short block[ 32 * 32 ];
     1379    Short coeff[ 32 * 32 ];
    13861380    for ( j = 0; j < iHeight * iWidth; j++ )
    13871381    {   
    … …  
    15051499                                                      UInt                            uiAbsPartIdx )
    15061500{
    1507   Int    iQBits      = m_cQP.m_iBits;
    1508   Double dTemp       = 0;
    15091501  UInt uiLog2TrSize = g_aucConvertToBit[ uiWidth ] + 2;
    1510   Int uiQ = g_quantScales[m_cQP.rem()];
    15111502 
    15121503  UInt uiBitDepth = eTType == TEXT_LUMA ? g_bitDepthY : g_bitDepthC;
    … …  
    15191510  assert(scalingListType < 6);
    15201511 
    1521   iQBits = QUANT_SHIFT + m_cQP.m_iPer + iTransformShift;                   // Right shift of non-RDOQ quantizer;  level = (coeff*uiQ + offset)>>q_bits
    1522   Double dErrScale   = 0;
     1512  Int iQBits = QUANT_SHIFT + m_cQP.m_iPer + iTransformShift;                   // Right shift of non-RDOQ quantizer;  level = (coeff*uiQ + offset)>>q_bits
    15231513  Double *pdErrScaleOrg = getErrScaleCoeff(scalingListType,uiLog2TrSize-2,m_cQP.m_iRem);
    15241514  Int *piQCoefOrg = getQuantCoeff(scalingListType,m_cQP.m_iRem,uiLog2TrSize-2);
    … …  
    15721562  Double  d64BaseCost         = 0;
    15731563  Int     iLastScanPos        = -1;
    1574   dTemp                       = dErrScale;
    15751564 
    15761565  UInt    c1Idx     = 0;
    … …  
    16011590      UInt    uiBlkPos          = scan[iScanPos];
    16021591      // set coeff
    1603       uiQ  = piQCoef[uiBlkPos];
    1604       dTemp = pdErrScale[uiBlkPos];
     1592      Int uiQ  = piQCoef[uiBlkPos];
     1593      Double dTemp = pdErrScale[uiBlkPos];
    16051594      Int lLevelDouble          = plSrcCoeff[ uiBlkPos ];
    16061595      lLevelDouble              = (Int)min<Int64>((Int64)abs((Int)lLevelDouble) * uiQ , MAX_INT - (1 << (iQBits - 1)));

  • branches/HTM-DEV-0.3-dev2/source/Lib/TLibCommon/TComWeightPrediction.cpp

    r324 r537  
    271271Void TComWeightPrediction::getWpScaling( TComDataCU* pcCU, Int iRefIdx0, Int iRefIdx1, wpScalingParam *&wp0, wpScalingParam *&wp1)
    272272{
     273  assert(iRefIdx0 >= 0 || iRefIdx1 >= 0);
     274 
    273275  TComSlice*      pcSlice       = pcCU->getSlice();
    274276  TComPPS*        pps           = pcCU->getSlice()->getPPS();

  • branches/HTM-DEV-0.3-dev2/source/Lib/TLibCommon/TypeDef.h

    r534 r537  
    4141//! \ingroup TLibCommon
    4242//! \{
    43 
    4443/////////////////////////////////////////////////////////////////////////////////////////
    4544///////////////////////////////// EXTENSION SELECTION /////////////////////////////////// 
    … …  
    204203/////////////////////////////////////////////////////////////////////////////////////////
    205204
    206 #define FIX1071 1 ///< Temporary fix for issue #1071
    207 
    208 #define L0208_SOP_DESCRIPTION_SEI     1 ///< L0208: add SOP descrioption SEI
     205#define FIX1071 1 ///< fix for issue #1071
     206
    209207#define MAX_NUM_PICS_IN_SOP           1024
    210208
    211 #define K0180_SCALABLE_NESTING_SEI  1   ///JCTVC-K0180 scalable nesting sei message
    212209#define MAX_NESTING_NUM_OPS         1024
    213210#define MAX_NESTING_NUM_LAYER       64
    214 
    215 #define J0149_TONE_MAPPING_SEI        1 ///< J0149: Tone mapping information SEI
    216 #define L0363_DU_BIT_RATE             1 ///< L0363: add bit_rate_du_value_minus1 to HRD parameters
    217 #define L0328_SPLICING                1 ///< L0328: splicing support in HRD
    218 #define L0044_DU_DPB_OUTPUT_DELAY_HRD 1 ///< L0044: Include dpb_output_delay_du_length_minus1 in hrd_parameters(), dpb_output_du_delay in
    219                                         ///<        picture timing SEI and DU information SEI
    220 #define L0045_PERSISTENCE_FLAGS  1      ///< L0045: Replace "repetition_period" syntax elements in SEI with "persistence_flag"
    221 #define L0045_NON_NESTED_SEI_RESTRICTIONS 1 ///< L0045; Include restriction on the order of APS and non-nested BP, PT and DU info SEI messages
    222 #define L0044_CPB_DPB_DELAY_OFFSET 1  ///< L0044: Include syntax elements cpb_delay_offset and dpb_delay_offset in the BP SEI message
    223 #define L0047_APS_FLAGS            1  ///< L0047: Include full_random_access_flag and no_param_set_update_flag in the active parameter set SEI message
    224 #define L0043_TIMING_INFO          1  ///< L0043: Timing information is signalled in VUI outside hrd_parameters()
    225 #define L0046_RENAME_PROG_SRC_IDC  1  ///< L0046: Rename progressive_source_idc to source_scan_type
    226 #define L0045_CONDITION_SIGNALLING 1  ///< L0045: Condition the signaling of some syntax elements in picture timing SEI message
    227 #define L0043_MSS_IDC 1
    228 #define L0116_ENTRY_POINT 1
    229 #define L0363_MORE_BITS 1
    230 #define L0363_MVP_POC 1
    231 #define L0363_BYTE_ALIGN 1
    232 #define L0363_SEI_ALLOW_SUFFIX 1
    233 #define L0323_LIMIT_DEFAULT_LIST_SIZE 1
    234 #define L0046_CONSTRAINT_FLAGS 1
    235 #define L0255_MOVE_PPS_FLAGS       1  ///< move some flags to earlier positions in the PPS
    236 #define L0444_FPA_TYPE             1  ///< allow only FPA types 3, 4 and 5
    237 #define L0372 1
    238 #define SIGNAL_BITRATE_PICRATE_IN_VPS               0  ///< K0125: Signal bit_rate and pic_rate in VPS
    239 #define L0232_RD_PENALTY           1  ///< L0232: RD-penalty for 32x32 TU for intra in non-intra slices
    240 #define L0386_DB_METRIC            1  ///< L0386: non-normative blockiness metric (automatically configures deblocking parameters in bitstream)
    241 #define L0323_DPB                     1 ///< L0323: Specification of active reference indices and decoded picture buffer
    242 
    243 #define L0034_COMBINED_LIST_CLEANUP 1
    244211
    245212#define MAX_VPS_NUM_HRD_PARAMETERS                1
    … …  
    254221
    255222#define RATE_CONTROL_LAMBDA_DOMAIN                  1  ///< JCTVC-K0103, rate control by R-lambda model
    256 #define L0033_RC_BUGFIX                             1  ///< JCTVC-L0033, bug fix for R-lambda model based rate control
     223#define M0036_RC_IMPROVEMENT                        1  ///< JCTVC-M0036, improvement for R-lambda model based rate control
     224#define TICKET_1090_FIX                             1
     225
     226#define RC_FIX                                      1  /// suggested fix for M0036
     227#define RATE_CONTROL_INTRA                          1  ///< JCTVC-M0257, rate control for intra
    257228
    258229#define MAX_CPB_CNT                     32  ///< Upper bound of (cpb_cnt_minus1 + 1)
    … …  
    281252
    282253#define REMOVE_SAO_LCU_ENC_CONSTRAINTS_3 1  ///< disable the encoder constraint that conditionally disable SAO for chroma for entire slice in interleaved mode
    283 
    284 #define REMOVE_SINGLE_SEI_EXTENSION_FLAGS 1 ///< remove display orientation SEI extension flag (there is a generic SEI extension mechanism now)
    285254
    286255#define SAO_ENCODING_CHOICE              1  ///< I0184: picture early termination
    … …  
    601570  REF_PIC_LIST_0 = 0,   ///< reference list 0
    602571  REF_PIC_LIST_1 = 1,   ///< reference list 1
    603 #if !L0034_COMBINED_LIST_CLEANUP
    604   REF_PIC_LIST_C = 2,   ///< combined reference list for uni-prediction in B-Slices
    605 #endif
    606572  REF_PIC_LIST_X = 100  ///< special mark
    607573};

  • branches/HTM-DEV-0.3-dev2/source/Lib/TLibDecoder/SEIread.cpp

    r446 r537  
    9090    fprintf( g_hTrace, "=========== Decoding Unit Information SEI message ===========\n");
    9191    break;
    92 #if J0149_TONE_MAPPING_SEI
    9392  case SEI::TONE_MAPPING_INFO:
    9493    fprintf( g_hTrace, "===========Tone Mapping Info SEI message ===========\n");
    9594    break;
    96 #endif
    97 #if L0208_SOP_DESCRIPTION_SEI
    9895  case SEI::SOP_DESCRIPTION:
    9996    fprintf( g_hTrace, "=========== SOP Description SEI message ===========\n");
    10097    break;
    101 #endif
    102 #if K0180_SCALABLE_NESTING_SEI
    10398  case SEI::SCALABLE_NESTING:
    10499    fprintf( g_hTrace, "=========== Scalable Nesting SEI message ===========\n");
    105100    break;
    106 #endif
    107101  default:
    108102    fprintf( g_hTrace, "=========== Unknown SEI message ===========\n");
    … …  
    234228      xParseSEIGradualDecodingRefreshInfo((SEIGradualDecodingRefreshInfo&) *sei, payloadSize);
    235229      break;
    236 #if J0149_TONE_MAPPING_SEI
    237230    case SEI::TONE_MAPPING_INFO:
    238231      sei = new SEIToneMappingInfo;
    239232      xParseSEIToneMappingInfo((SEIToneMappingInfo&) *sei, payloadSize);
    240233      break;
    241 #endif
    242 #if L0208_SOP_DESCRIPTION_SEI
    243234    case SEI::SOP_DESCRIPTION:
    244235      sei = new SEISOPDescription;
    245236      xParseSEISOPDescription((SEISOPDescription&) *sei, payloadSize);
    246237      break;
    247 #endif
    248 #if K0180_SCALABLE_NESTING_SEI
    249238    case SEI::SCALABLE_NESTING:
    250239      sei = new SEIScalableNesting;
    251240      xParseSEIScalableNesting((SEIScalableNesting&) *sei, nalUnitType, payloadSize, sps);
    252241      break;
    253 #endif
    254242    default:
    255243      for (UInt i = 0; i < payloadSize; i++)
    … …  
    265253    switch (payloadType)
    266254    {
    267 #if L0363_SEI_ALLOW_SUFFIX
    268255      case SEI::USER_DATA_UNREGISTERED:
    269256        sei = new SEIuserDataUnregistered;
    270257        xParseSEIuserDataUnregistered((SEIuserDataUnregistered&) *sei, payloadSize);
    271258        break;
    272 #endif
    273259      case SEI::DECODED_PICTURE_HASH:
    274260        sei = new SEIDecodedPictureHash;
    … …  
    402388  UInt val;
    403389  READ_CODE(4, val, "active_vps_id");      sei.activeVPSId = val;
    404 #if L0047_APS_FLAGS
    405390  READ_FLAG( val, "full_random_access_flag");  sei.m_fullRandomAccessFlag = val ? true : false;
    406391  READ_FLAG( val, "no_param_set_update_flag"); sei.m_noParamSetUpdateFlag = val ? true : false;
    407 #endif
    408392  READ_UVLC(   val, "num_sps_ids_minus1"); sei.numSpsIdsMinus1 = val;
    409393
    … …  
    438422    sei.m_duSptCpbRemovalDelay = 0;
    439423  }
    440 #if L0044_DU_DPB_OUTPUT_DELAY_HRD
    441424  READ_FLAG( val, "dpb_output_du_delay_present_flag"); sei.m_dpbOutputDuDelayPresentFlag = val ? true : false;
    442425  if(sei.m_dpbOutputDuDelayPresentFlag)
    … …  
    445428    sei.m_picSptDpbOutputDuDelay = val;
    446429  }
    447 #endif
    448430  xParseByteAlign();
    449431}
    … …  
    462444    READ_FLAG( code, "rap_cpb_params_present_flag" );                   sei.m_rapCpbParamsPresentFlag = code;
    463445  }
    464 #if L0328_SPLICING
    465446  //read splicing flag and cpb_removal_delay_delta
    466447  READ_FLAG( code, "concatenation_flag");
    … …  
    468449  READ_CODE( ( pHRD->getCpbRemovalDelayLengthMinus1() + 1 ), code, "au_cpb_removal_delay_delta_minus1" );
    469450  sei.m_auCpbRemovalDelayDelta = code + 1;
    470 #endif
    471 #if L0044_CPB_DPB_DELAY_OFFSET
    472451  if( sei.m_rapCpbParamsPresentFlag )
    473452  {
    … …  
    475454    READ_CODE( pHRD->getDpbOutputDelayLengthMinus1()  + 1, code, "dpb_delay_offset" );      sei.m_dpbDelayOffset = code;
    476455  }
    477 #endif
    478456  for( nalOrVcl = 0; nalOrVcl < 2; nalOrVcl ++ )
    479457  {
    … …  
    507485  TComHRD *hrd = vui->getHrdParameters();
    508486
    509 #if !L0045_CONDITION_SIGNALLING
    510   // This condition was probably OK before the pic_struct, progressive_source_idc, duplicate_flag were added
    511   if( !hrd->getNalHrdParametersPresentFlag() && !hrd->getVclHrdParametersPresentFlag() )
    512   {
    513     return;
    514   }
    515 #endif
    516 
    517487  if( vui->getFrameFieldInfoPresentFlag() )
    518488  {
    519489    READ_CODE( 4, code, "pic_struct" );             sei.m_picStruct            = code;
    520 #if L0046_RENAME_PROG_SRC_IDC
    521490    READ_CODE( 2, code, "source_scan_type" );       sei.m_sourceScanType = code;
    522 #else
    523     READ_CODE( 2, code, "progressive_source_idc" ); sei.m_progressiveSourceIdc = code;
    524 #endif
    525491    READ_FLAG(    code, "duplicate_flag" );         sei.m_duplicateFlag        = ( code == 1 ? true : false );
    526492  }
    527493
    528 #if L0045_CONDITION_SIGNALLING
    529494  if( hrd->getCpbDpbDelaysPresentFlag())
    530495  {
    531 #endif
    532496    READ_CODE( ( hrd->getCpbRemovalDelayLengthMinus1() + 1 ), code, "au_cpb_removal_delay_minus1" );
    533497    sei.m_auCpbRemovalDelay = code + 1;
    … …  
    535499    sei.m_picDpbOutputDelay = code;
    536500
    537 #if L0044_DU_DPB_OUTPUT_DELAY_HRD
    538501    if(hrd->getSubPicCpbParamsPresentFlag())
    539502    {
    … …  
    541504      sei.m_picDpbOutputDuDelay = code;
    542505    }
    543 #endif
    544506    if( hrd->getSubPicCpbParamsPresentFlag() && hrd->getSubPicCpbParamsInPicTimingSEIFlag() )
    545507    {
    … …  
    575537      }
    576538    }
    577 #if L0045_CONDITION_SIGNALLING
    578   }
    579 #endif
     539  }
    580540  xParseByteAlign();
    581541}
    … …  
    598558  {
    599559    READ_CODE( 7, val, "frame_packing_arrangement_type" );          sei.m_arrangementType = val;
    600 #if L0444_FPA_TYPE
    601560    assert((sei.m_arrangementType > 2) && (sei.m_arrangementType < 6) );
    602 #endif
    603561    READ_FLAG( val, "quincunx_sampling_flag" );                     sei.m_quincunxSamplingFlag = val;
    604562
    … …  
    620578
    621579    READ_CODE( 8, val, "frame_packing_arrangement_reserved_byte" );   sei.m_arrangementReservedByte = val;
    622 #if L0045_PERSISTENCE_FLAGS
    623580    READ_FLAG( val,  "frame_packing_arrangement_persistence_flag" );  sei.m_arrangementPersistenceFlag = val ? true : false;
    624 #else
    625     READ_UVLC( val, "frame_packing_arrangement_repetition_period" );  sei.m_arrangementRepetetionPeriod = val;
    626 #endif
    627581  }
    628582  READ_FLAG( val, "upsampled_aspect_ratio" );                       sei.m_upsampledAspectRatio = val;
    … …  
    640594    READ_FLAG( val,     "ver_flip" );                              sei.verFlip               = val;
    641595    READ_CODE( 16, val, "anticlockwise_rotation" );                sei.anticlockwiseRotation = val;
    642 #if L0045_PERSISTENCE_FLAGS
    643596    READ_FLAG( val,     "display_orientation_persistence_flag" );  sei.persistenceFlag       = val;
    644 #else
    645     READ_UVLC( val,     "display_orientation_repetition_period" ); sei.repetitionPeriod      = val;
    646 #endif
    647 #if !REMOVE_SINGLE_SEI_EXTENSION_FLAGS
    648     READ_FLAG( val,     "display_orientation_extension_flag" );    sei.extensionFlag         = val;
    649     assert( !sei.extensionFlag );
    650 #endif
    651597  }
    652598  xParseByteAlign();
    … …  
    668614}
    669615
    670 #if J0149_TONE_MAPPING_SEI
    671616Void SEIReader::xParseSEIToneMappingInfo(SEIToneMappingInfo& sei, UInt /*payloadSize*/)
    672617{
    … …  
    749694  xParseByteAlign();
    750695}
    751 #endif
    752 
    753 #if L0208_SOP_DESCRIPTION_SEI
     696
    754697Void SEIReader::xParseSEISOPDescription(SEISOPDescription &sei, UInt payloadSize)
    755698{
    … …  
    775718  xParseByteAlign();
    776719}
    777 #endif
    778 
    779 #if K0180_SCALABLE_NESTING_SEI
     720
    780721Void SEIReader::xParseSEIScalableNesting(SEIScalableNesting& sei, const NalUnitType nalUnitType, UInt payloadSize, TComSPS *sps)
    781722{
    … …  
    824765
    825766}
    826 #endif
    827767
    828768Void SEIReader::xParseByteAlign()

  • branches/HTM-DEV-0.3-dev2/source/Lib/TLibDecoder/SEIread.h

    r446 r537  
    7070  Void xParseSEITemporalLevel0Index   (SEITemporalLevel0Index &sei, UInt payloadSize);
    7171  Void xParseSEIGradualDecodingRefreshInfo (SEIGradualDecodingRefreshInfo &sei, UInt payloadSize);
    72 #if J0149_TONE_MAPPING_SEI
    7372  Void xParseSEIToneMappingInfo       (SEIToneMappingInfo& sei, UInt payloadSize);
    74 #endif
    75 #if L0208_SOP_DESCRIPTION_SEI
    7673  Void xParseSEISOPDescription        (SEISOPDescription &sei, UInt payloadSize);
    77 #endif
    78 #if K0180_SCALABLE_NESTING_SEI
    7974  Void xParseSEIScalableNesting       (SEIScalableNesting& sei, const NalUnitType nalUnitType, UInt payloadSize, TComSPS *sps);
    80 #endif
    8175  Void xParseByteAlign();
    8276};

  • branches/HTM-DEV-0.3-dev2/source/Lib/TLibDecoder/TDecBinCoder.h

    r324 r537  
    5454  virtual Void  start             ()                                          = 0;
    5555  virtual Void  finish            ()                                          = 0;
    56   virtual Void  flush            ()                                           = 0;
    5756
    5857  virtual Void  decodeBin         ( UInt& ruiBin, ContextModel& rcCtxModel )  = 0;
    … …  
    6160  virtual Void  decodeBinTrm      ( UInt& ruiBin                           )  = 0;
    6261 
    63   virtual Void  resetBac          ()                                          = 0;
    64   virtual Void  decodePCMAlignBits()                                          = 0;
    6562  virtual Void  xReadPCMCode      ( UInt uiLength, UInt& ruiCode)              = 0;
    6663

  • branches/HTM-DEV-0.3-dev2/source/Lib/TLibDecoder/TDecBinCoderCABAC.cpp

    r521 r537  
    7676TDecBinCABAC::finish()
    7777{
    78 }
    79 
    80 Void
    81 TDecBinCABAC::flush()
    82 {
    83   while (m_pcTComBitstream->getNumBitsLeft() > 0 && m_pcTComBitstream->getNumBitsUntilByteAligned() != 0)
    84   {
    85     UInt uiBits;
    86     m_pcTComBitstream->read ( 1, uiBits );
    87   }
    88   start();
     78  UInt lastByte;
     79
     80  m_pcTComBitstream->peekPreviousByte( lastByte );
     81  // Check for proper stop/alignment pattern
     82  assert( ((lastByte << (8 + m_bitsNeeded)) & 0xff) == 0x80 );
    8983}
    9084
    … …  
    242236}
    243237
    244 /** Reset BAC register values.
    245  * \returns Void
    246  */
    247 Void TDecBinCABAC::resetBac()
    248 {
    249   m_uiRange    = 510;
    250   m_bitsNeeded = -8;
    251   m_uiValue    = m_pcTComBitstream->read( 16 );
    252 }
    253 
    254 /** Decode PCM alignment zero bits.
    255  * \returns Void
    256  */
    257 Void TDecBinCABAC::decodePCMAlignBits()
    258 {
    259   Int iNum = m_pcTComBitstream->getNumBitsUntilByteAligned();
    260  
    261   UInt uiBit = 0;
    262   m_pcTComBitstream->read( iNum, uiBit );
    263 #if H_MV_ENC_DEC_TRAC         
    264   DTRACE_CU("Number of pcm_alignment_zero_bit", iNum)
    265 #endif
    266 }
    267 
    268238/** Read a PCM code.
    269239 * \param uiLength code bit-depth

  • branches/HTM-DEV-0.3-dev2/source/Lib/TLibDecoder/TDecBinCoderCABAC.h

    r324 r537  
    5656  Void  start             ();
    5757  Void  finish            ();
    58   Void  flush             ();
    5958 
    6059  Void  decodeBin         ( UInt& ruiBin, ContextModel& rcCtxModel );
    … …  
    6362  Void  decodeBinTrm      ( UInt& ruiBin                           );
    6463 
    65   Void  resetBac          ();
    66   Void  decodePCMAlignBits();
    6764  Void  xReadPCMCode      ( UInt uiLength, UInt& ruiCode );
    6865 

  • branches/HTM-DEV-0.3-dev2/source/Lib/TLibDecoder/TDecCAVLC.cpp

    r536 r537  
    224224  Int   iCode;
    225225
    226   READ_UVLC( uiCode, "pps_pic_parameter_set_id");                     pcPPS->setPPSId (uiCode);
    227   READ_UVLC( uiCode, "pps_seq_parameter_set_id");                     pcPPS->setSPSId (uiCode);
     226  READ_UVLC( uiCode, "pps_pic_parameter_set_id");
     227  assert(uiCode <= 63);
     228  pcPPS->setPPSId (uiCode);
     229 
     230  READ_UVLC( uiCode, "pps_seq_parameter_set_id");
     231  assert(uiCode <= 15);
     232  pcPPS->setSPSId (uiCode);
     233 
    228234  READ_FLAG( uiCode, "dependent_slice_segments_enabled_flag"    );    pcPPS->setDependentSliceSegmentsEnabledFlag   ( uiCode == 1 );
    229 #if L0255_MOVE_PPS_FLAGS
    230235  READ_FLAG( uiCode, "output_flag_present_flag" );                    pcPPS->setOutputFlagPresentFlag( uiCode==1 );
    231236
    232237  READ_CODE(3, uiCode, "num_extra_slice_header_bits");                pcPPS->setNumExtraSliceHeaderBits(uiCode);
    233 #endif
    234238  READ_FLAG ( uiCode, "sign_data_hiding_flag" ); pcPPS->setSignHideFlag( uiCode );
    235239
    236240  READ_FLAG( uiCode,   "cabac_init_present_flag" );            pcPPS->setCabacInitPresentFlag( uiCode ? true : false );
    237241
    238 #if L0323_LIMIT_DEFAULT_LIST_SIZE
    239242  READ_UVLC(uiCode, "num_ref_idx_l0_default_active_minus1");
    240243  assert(uiCode <= 14);
    … …  
    244247  assert(uiCode <= 14);
    245248  pcPPS->setNumRefIdxL1DefaultActive(uiCode+1);
    246 #else
    247   READ_UVLC(uiCode, "num_ref_idx_l0_default_active_minus1");       pcPPS->setNumRefIdxL0DefaultActive(uiCode+1);
    248   READ_UVLC(uiCode, "num_ref_idx_l1_default_active_minus1");       pcPPS->setNumRefIdxL1DefaultActive(uiCode+1);
    249 #endif
    250249 
    251250  READ_SVLC(iCode, "init_qp_minus26" );                            pcPPS->setPicInitQPMinus26(iCode);
    … …  
    282281  pcPPS->setWPBiPred( uiCode==1 );
    283282
    284 #if !L0255_MOVE_PPS_FLAGS
    285   READ_FLAG( uiCode, "output_flag_present_flag" );
    286   pcPPS->setOutputFlagPresentFlag( uiCode==1 );
    287 #endif
    288283  READ_FLAG( uiCode, "transquant_bypass_enable_flag");
    289284  pcPPS->setTransquantBypassEnableFlag(uiCode ? true : false);
    … …  
    347342  pcPPS->setLog2ParallelMergeLevelMinus2 (uiCode);
    348343
    349 #if !L0255_MOVE_PPS_FLAGS
    350   READ_CODE(3, uiCode, "num_extra_slice_header_bits");
    351   pcPPS->setNumExtraSliceHeaderBits(uiCode);
    352 #endif
    353344  READ_FLAG( uiCode, "slice_segment_header_extension_present_flag");
    354345  pcPPS->setSliceHeaderExtensionPresentFlag(uiCode);
    … …  
    424415    READ_UVLC(   uiCode, "def_disp_win_bottom_offset" );              defDisp.setWindowBottomOffset( uiCode * TComSPS::getWinUnitY( pcSPS->getChromaFormatIdc()) );
    425416  }
    426 #if L0043_TIMING_INFO
    427417  TimingInfo *timingInfo = pcVUI->getTimingInfo();
    428418  READ_FLAG(       uiCode, "vui_timing_info_present_flag");         timingInfo->setTimingInfoPresentFlag      (uiCode ? true : false);
    … …  
    436426      READ_UVLC(   uiCode, "vui_num_ticks_poc_diff_one_minus1");    timingInfo->setNumTicksPocDiffOneMinus1   (uiCode);
    437427    }
    438 #endif 
    439428  READ_FLAG(     uiCode, "hrd_parameters_present_flag");              pcVUI->setHrdParametersPresentFlag(uiCode);
    440429  if( pcVUI->getHrdParametersPresentFlag() )
    … …  
    442431    parseHrdParameters( pcVUI->getHrdParameters(), 1, pcSPS->getMaxTLayers() - 1 );
    443432  }
    444 #if L0043_TIMING_INFO
    445   }
    446 #endif
    447 #if !L0043_TIMING_INFO
    448   READ_FLAG( uiCode, "poc_proportional_to_timing_flag" ); pcVUI->setPocProportionalToTimingFlag(uiCode ? true : false);
    449   if( pcVUI->getPocProportionalToTimingFlag() && pcVUI->getHrdParameters()->getTimingInfoPresentFlag() )
    450   {
    451     READ_UVLC( uiCode, "num_ticks_poc_diff_one_minus1" ); pcVUI->setNumTicksPocDiffOneMinus1(uiCode);
    452   }
    453 #endif
     433  }
    454434  READ_FLAG(     uiCode, "bitstream_restriction_flag");               pcVUI->setBitstreamRestrictionFlag(uiCode);
    455435  if (pcVUI->getBitstreamRestrictionFlag())
    … …  
    464444    READ_FLAG(   uiCode, "motion_vectors_over_pic_boundaries_flag");  pcVUI->setMotionVectorsOverPicBoundariesFlag(uiCode);
    465445    READ_FLAG(   uiCode, "restricted_ref_pic_lists_flag");            pcVUI->setRestrictedRefPicListsFlag(uiCode);
    466 #if L0043_MSS_IDC
    467446    READ_UVLC( uiCode, "min_spatial_segmentation_idc");            pcVUI->setMinSpatialSegmentationIdc(uiCode);
    468447    assert(uiCode < 4096);
    469 #else
    470     READ_CODE( 8, uiCode, "min_spatial_segmentation_idc");            pcVUI->setMinSpatialSegmentationIdc(uiCode);
    471 #endif
    472448    READ_UVLC(   uiCode, "max_bytes_per_pic_denom" );                 pcVUI->setMaxBytesPerPicDenom(uiCode);
    473449    READ_UVLC(   uiCode, "max_bits_per_mincu_denom" );                pcVUI->setMaxBitsPerMinCuDenom(uiCode);
    … …  
    482458  if( commonInfPresentFlag )
    483459  {
    484 #if !L0043_TIMING_INFO
    485     READ_FLAG( uiCode, "timing_info_present_flag" );                  hrd->setTimingInfoPresentFlag( uiCode == 1 ? true : false );
    486     if( hrd->getTimingInfoPresentFlag() )
    487     {
    488       READ_CODE( 32, uiCode, "num_units_in_tick" );                   hrd->setNumUnitsInTick( uiCode );
    489       READ_CODE( 32, uiCode, "time_scale" );                          hrd->setTimeScale( uiCode );
    490     }
    491 #endif
    492460    READ_FLAG( uiCode, "nal_hrd_parameters_present_flag" );           hrd->setNalHrdParametersPresentFlag( uiCode == 1 ? true : false );
    493461    READ_FLAG( uiCode, "vcl_hrd_parameters_present_flag" );           hrd->setVclHrdParametersPresentFlag( uiCode == 1 ? true : false );
    … …  
    500468        READ_CODE( 5, uiCode, "du_cpb_removal_delay_length_minus1" ); hrd->setDuCpbRemovalDelayLengthMinus1( uiCode );
    501469        READ_FLAG( uiCode, "sub_pic_cpb_params_in_pic_timing_sei_flag" ); hrd->setSubPicCpbParamsInPicTimingSEIFlag( uiCode == 1 ? true : false );
    502 #if L0044_DU_DPB_OUTPUT_DELAY_HRD
    503470        READ_CODE( 5, uiCode, "dpb_output_delay_du_length_minus1"  ); hrd->setDpbOutputDelayDuLengthMinus1( uiCode );
    504 #endif
    505471      }
    506472      READ_CODE( 4, uiCode, "bit_rate_scale" );                       hrd->setBitRateScale( uiCode );
    … …  
    527493      hrd->setFixedPicRateWithinCvsFlag( i, true );
    528494    }
    529 #if L0372
    530495    hrd->setLowDelayHrdFlag( i, 0 ); // Infered to be 0 when not present
    531496    hrd->setCpbCntMinus1   ( i, 0 ); // Infered to be 0 when not present
    532 #endif
    533497    if( hrd->getFixedPicRateWithinCvsFlag( i ) )
    534498    {
    535499      READ_UVLC( uiCode, "elemental_duration_in_tc_minus1" );             hrd->setPicDurationInTcMinus1( i, uiCode );
    536500    }
    537 #if L0372
    538501    else
    539502    {     
    … …  
    544507      READ_UVLC( uiCode, "cpb_cnt_minus1" );                          hrd->setCpbCntMinus1( i, uiCode );     
    545508    }
    546 #else
    547     READ_FLAG( uiCode, "low_delay_hrd_flag" );                      hrd->setLowDelayHrdFlag( i, uiCode == 1 ? true : false  );
    548     READ_UVLC( uiCode, "cpb_cnt_minus1" );                          hrd->setCpbCntMinus1( i, uiCode );
    549 #endif
    550509    for( nalOrVcl = 0; nalOrVcl < 2; nalOrVcl ++ )
    551510    {
    … …  
    559518          if( hrd->getSubPicCpbParamsPresentFlag() )
    560519          {
    561 #if L0363_DU_BIT_RATE
     520            READ_UVLC( uiCode, "cpb_size_du_value_minus1" );       hrd->setDuCpbSizeValueMinus1( i, j, nalOrVcl, uiCode );
    562521            READ_UVLC( uiCode, "bit_rate_du_value_minus1" );       hrd->setDuBitRateValueMinus1( i, j, nalOrVcl, uiCode );
    563 #endif
    564             READ_UVLC( uiCode, "cpb_size_du_value_minus1" );       hrd->setDuCpbSizeValueMinus1( i, j, nalOrVcl, uiCode );
    565522          }
    566523          READ_FLAG( uiCode, "cbr_flag" );                          hrd->setCbrFlag( i, j, nalOrVcl, uiCode == 1 ? true : false  );
    … …  
    588545#endif
    589546  READ_CODE( 3,  uiCode, "sps_max_sub_layers_minus1" );          pcSPS->setMaxTLayers   ( uiCode+1 );
     547  assert(uiCode <= 6);
     548 
    590549  READ_FLAG( uiCode, "sps_temporal_id_nesting_flag" );               pcSPS->setTemporalIdNestingFlag ( uiCode > 0 ? true : false );
    591550  if ( pcSPS->getMaxTLayers() == 1 )
    … …  
    594553    assert( uiCode == 1 );
    595554  }
     555 
    596556  parsePTL(pcSPS->getPTL(), 1, pcSPS->getMaxTLayers() - 1);
    597557#if H_MV
    … …  
    599559#endif
    600560  READ_UVLC(     uiCode, "sps_seq_parameter_set_id" );           pcSPS->setSPSId( uiCode );
     561  assert(uiCode <= 15);
     562 
    601563  READ_UVLC(     uiCode, "chroma_format_idc" );                  pcSPS->setChromaFormatIdc( uiCode );
     564  assert(uiCode <= 3);
    602565  // in the first version we only support chroma_format_idc equal to 1 (4:2:0), so separate_colour_plane_flag cannot appear in the bitstream
    603566  assert (uiCode == 1);
    … …  
    620583
    621584  READ_UVLC(     uiCode, "bit_depth_luma_minus8" );
     585  assert(uiCode <= 6);
    622586  pcSPS->setBitDepthY( uiCode + 8 );
    623587  pcSPS->setQpBDOffsetY( (Int) (6*uiCode) );
    624588
    625589  READ_UVLC( uiCode,    "bit_depth_chroma_minus8" );
     590  assert(uiCode <= 6);
    626591  pcSPS->setBitDepthC( uiCode + 8 );
    627592  pcSPS->setQpBDOffsetC( (Int) (6*uiCode) );
    628593
    629594  READ_UVLC( uiCode,    "log2_max_pic_order_cnt_lsb_minus4" );   pcSPS->setBitsForPOC( 4 + uiCode );
     595  assert(uiCode <= 12);
    630596
    631597  UInt subLayerOrderingInfoPresentFlag;
    632598  READ_FLAG(subLayerOrderingInfoPresentFlag, "sps_sub_layer_ordering_info_present_flag");
     599 
    633600  for(UInt i=0; i <= pcSPS->getMaxTLayers()-1; i++)
    634601  {
    635 #if L0323_DPB
    636602#if H_MV
    637603    READ_UVLC ( uiCode, "sps_max_dec_pic_buffering_minus1[i]");
    … …  
    640606#endif
    641607    pcSPS->setMaxDecPicBuffering( uiCode + 1, i);
    642 #else
    643     READ_UVLC ( uiCode, "sps_max_dec_pic_buffering");
    644     pcSPS->setMaxDecPicBuffering( uiCode, i);
    645 #endif
    646608#if H_MV
    647609    READ_UVLC ( uiCode, "sps_num_reorder_pics[i]" );
    … …  
    711673
    712674  READ_UVLC( uiCode, "num_short_term_ref_pic_sets" );
     675  assert(uiCode <= 64);
    713676  pcSPS->createRPSList(uiCode);
    714677
    … …  
    838801#endif
    839802  parsePTL ( pcVPS->getPTL(), true, pcVPS->getMaxTLayers()-1);
    840 #if SIGNAL_BITRATE_PICRATE_IN_VPS
    841   parseBitratePicRateInfo( pcVPS->getBitratePicrateInfo(), 0, pcVPS->getMaxTLayers() - 1);
    842 #endif
    843803  UInt subLayerOrderingInfoPresentFlag;
    844804  READ_FLAG(subLayerOrderingInfoPresentFlag, "vps_sub_layer_ordering_info_present_flag");
    845805  for(UInt i = 0; i <= pcVPS->getMaxTLayers()-1; i++)
    846806  {
    847 #if L0323_DPB
    848807    READ_UVLC( uiCode,  "vps_max_dec_pic_buffering_minus1[i]" );     pcVPS->setMaxDecPicBuffering( uiCode + 1, i );
    849 #else
    850     READ_UVLC( uiCode,  "vps_max_dec_pic_buffering[i]" );     pcVPS->setMaxDecPicBuffering( uiCode, i );
    851 #endif
    852808    READ_UVLC( uiCode,  "vps_num_reorder_pics[i]" );          pcVPS->setNumReorderPics( uiCode, i );
    853     READ_UVLC( uiCode,  "vps_max_latency_increase[i]" );      pcVPS->setMaxLatencyIncrease( uiCode, i );
     809    READ_UVLC( uiCode,  "vps_max_latency_increase_plus1[i]" );      pcVPS->setMaxLatencyIncrease( uiCode, i );
    854810
    855811    if (!subLayerOrderingInfoPresentFlag)
    … …  
    887843    }
    888844  }
    889 #if L0043_TIMING_INFO
    890845  TimingInfo *timingInfo = pcVPS->getTimingInfo();
    891846  READ_FLAG(       uiCode, "vps_timing_info_present_flag");         timingInfo->setTimingInfoPresentFlag      (uiCode ? true : false);
    … …  
    899854      READ_UVLC(   uiCode, "vps_num_ticks_poc_diff_one_minus1");    timingInfo->setNumTicksPocDiffOneMinus1   (uiCode);
    900855    }
    901 #endif
    902856    READ_UVLC( uiCode, "vps_num_hrd_parameters" );                  pcVPS->setNumHrdParameters( uiCode );
    903857
    … …  
    915869      parseHrdParameters(pcVPS->getHrdParameters(i), pcVPS->getCprmsPresentFlag( i ), pcVPS->getMaxTLayers() - 1);
    916870    }
    917 #if L0043_TIMING_INFO
    918   }
    919 #endif
     871  }
    920872  READ_FLAG( uiCode,  "vps_extension_flag" );
    921873  if (uiCode)
    … …  
    13111263          uiCode = 0;
    13121264        }
    1313         memcpy(rps,sps->getRPSList()->getReferencePictureSet(uiCode),sizeof(TComReferencePictureSet));
     1265        *rps = *(sps->getRPSList()->getReferencePictureSet(uiCode));
    13141266      }
    13151267      if(sps->getLongTermRefsPresent())
    … …  
    17361688    for (UInt idx=0; idx<numEntryPointOffsets; idx++)
    17371689    {
    1738 #if L0116_ENTRY_POINT
    17391690      READ_CODE(offsetLenMinus1+1, uiCode, "entry_point_offset_minus1");
    17401691      entryPointOffset[ idx ] = uiCode + 1;
    1741 #else
    1742       READ_CODE(offsetLenMinus1+1, uiCode, "entry_point_offset");
    1743       entryPointOffset[ idx ] = uiCode;
    1744 #endif
    17451692    }
    17461693  }
    … …  
    17911738  {
    17921739    Int endOfSliceHeaderLocation = m_pcBitstream->getByteLocation();
     1740   
     1741    // Adjust endOfSliceHeaderLocation to account for emulation prevention bytes in the slice segment header
     1742    for ( UInt curByteIdx  = 0; curByteIdx<m_pcBitstream->numEmulationPreventionBytesRead(); curByteIdx++ )
     1743    {
     1744      if ( m_pcBitstream->getEmulationPreventionByteLocation( curByteIdx ) < endOfSliceHeaderLocation )
     1745      {
     1746        endOfSliceHeaderLocation++;
     1747      }
     1748    }
     1749
    17931750    Int  curEntryPointOffset     = 0;
    17941751    Int  prevEntryPointOffset    = 0;
    … …  
    18581815  READ_CODE( 8, uiCode, "general_level_idc" );    rpcPTL->getGeneralPTL()->setLevelIdc(uiCode);
    18591816
    1860 #if L0363_BYTE_ALIGN
    18611817  for (Int i = 0; i < maxNumSubLayersMinus1; i++)
    18621818  {
    … …  
    18821838    }
    18831839  }
    1884 #endif
    18851840 
    18861841  for(Int i = 0; i < maxNumSubLayersMinus1; i++)
    18871842  {
    1888 #if !L0363_BYTE_ALIGN
    1889     if(profilePresentFlag)
    1890     {
    1891       READ_FLAG( uiCode, "sub_layer_profile_present_flag[i]" ); rpcPTL->setSubLayerProfilePresentFlag(i, uiCode);
    1892     }
    1893     READ_FLAG( uiCode, "sub_layer_level_present_flag[i]"   ); rpcPTL->setSubLayerLevelPresentFlag  (i, uiCode);
    1894 #endif
    18951843    if( profilePresentFlag && rpcPTL->getSubLayerProfilePresentFlag(i) )
    18961844    {
    … …  
    19141862    READ_FLAG(  uiCode, "XXX_profile_compatibility_flag[][j]");   ptl->setProfileCompatibilityFlag(j, uiCode ? 1 : 0);
    19151863  }
    1916 #if L0046_CONSTRAINT_FLAGS
    19171864  READ_FLAG(uiCode, "general_progressive_source_flag");
    19181865  ptl->setProgressiveSourceFlag(uiCode ? true : false);
    … …  
    19301877  READ_CODE(16, uiCode, "XXX_reserved_zero_44bits[16..31]");
    19311878  READ_CODE(12, uiCode, "XXX_reserved_zero_44bits[32..43]");
    1932 #elif L0363_MORE_BITS
    1933   READ_CODE(16, uiCode, "XXX_reserved_zero_48bits[0..15]");
    1934   READ_CODE(16, uiCode, "XXX_reserved_zero_48bits[16..31]");
    1935   READ_CODE(16, uiCode, "XXX_reserved_zero_48bits[32..47]");
    1936 #else
    1937   READ_CODE(16, uiCode, "XXX_reserved_zero_16bits[]");  assert( uiCode == 0 );
    1938 #endif
    1939 }
    1940 #if SIGNAL_BITRATE_PICRATE_IN_VPS
    1941 Void TDecCavlc::parseBitratePicRateInfo(TComBitRatePicRateInfo *info, Int tempLevelLow, Int tempLevelHigh)
    1942 {
    1943   UInt uiCode;
    1944   for(Int i = tempLevelLow; i <= tempLevelHigh; i++)
    1945   {
    1946     READ_FLAG( uiCode, "bit_rate_info_present_flag[i]" ); info->setBitRateInfoPresentFlag(i, uiCode ? true : false);
    1947     READ_FLAG( uiCode, "pic_rate_info_present_flag[i]" ); info->setPicRateInfoPresentFlag(i, uiCode ? true : false);
    1948     if(info->getBitRateInfoPresentFlag(i))
    1949     {
    1950       READ_CODE( 16, uiCode, "avg_bit_rate[i]" ); info->setAvgBitRate(i, uiCode);
    1951       READ_CODE( 16, uiCode, "max_bit_rate[i]" ); info->setMaxBitRate(i, uiCode);
    1952     }
    1953     if(info->getPicRateInfoPresentFlag(i))
    1954     {
    1955       READ_CODE(  2, uiCode,  "constant_pic_rate_idc[i]" ); info->setConstantPicRateIdc(i, uiCode);
    1956       READ_CODE( 16, uiCode,  "avg_pic_rate[i]"          ); info->setAvgPicRate(i, uiCode);
    1957     }
    1958   }
    1959 }
    1960 #endif 
     1879}
     1880
    19611881Void TDecCavlc::parseTerminatingBit( UInt& ruiBit )
    19621882{

  • branches/HTM-DEV-0.3-dev2/source/Lib/TLibDecoder/TDecCAVLC.h

    r504 r537  
    8686  Void  parsePTL            ( TComPTL *rpcPTL, Bool profilePresentFlag, Int maxNumSubLayersMinus1 );
    8787  Void  parseProfileTier    (ProfileTierLevel *ptl);
    88 #if SIGNAL_BITRATE_PICRATE_IN_VPS
    89   Void  parseBitratePicRateInfo(TComBitRatePicRateInfo *info, Int tempLevelLow, Int tempLevelHigh);
    90 #endif
    9188  Void  parseHrdParameters  (TComHRD *hrd, Bool cprms_present_flag, UInt tempLevelHigh);
    9289  Void  parseSliceHeader    ( TComSlice*& rpcSlice, ParameterSetManagerDecoder *parameterSetManager);

  • branches/HTM-DEV-0.3-dev2/source/Lib/TLibDecoder/TDecSbac.cpp

    r531 r537  
    166166  m_cTransformSkipSCModel.initBuffer     ( sliceType, qp, (UChar*)INIT_TRANSFORMSKIP_FLAG );
    167167  m_CUTransquantBypassFlagSCModel.initBuffer( sliceType, qp, (UChar*)INIT_CU_TRANSQUANT_BYPASS_FLAG );
    168 
    169168#if H_3D_DIM
    170169  m_cDepthIntraModeSCModel.initBuffer    ( sliceType, qp, (UChar*)INIT_DEPTH_INTRA_MODE );
    … …  
    184183#endif
    185184#endif
    186 
    187185  m_uiLastDQpNonZero  = 0;
    188186 
    … …  
    200198  UInt uiBit;
    201199  m_pcTDecBinIf->decodeBinTrm(uiBit);
     200  assert(uiBit); // end_of_sub_stream_one_bit must be equal to 1
    202201  m_pcTDecBinIf->finish(); 
    203202  m_pcBitstream->readOutTrailingBits();
    … …  
    259258{
    260259  m_pcTDecBinIf->decodeBinTrm( ruiBit );
     260  if ( ruiBit )
     261  {
     262    m_pcTDecBinIf->finish();
     263  }
    261264}
    262265
    … …  
    613616{
    614617  UInt uiSymbol;
    615   Bool readPCMSampleFlag = false;
    616618
    617619    m_pcTDecBinIf->decodeBinTrm(uiSymbol);
    … …  
    622624    if (uiSymbol)
    623625    {
    624       readPCMSampleFlag = true;
    625       m_pcTDecBinIf->decodePCMAlignBits();
    626     }
    627 
    628   if (readPCMSampleFlag == true)
    629   {
    630626    Bool bIpcmFlag = true;
    631627
    … …  
    693689    }
    694690
    695       m_pcTDecBinIf->resetBac();
     691    m_pcTDecBinIf->start();
    696692  }
    697693}
    … …  
    1003999    else
    10041000    {
    1005       intraPredMode = 0;
    10061001      m_pcTDecBinIf->decodeBinsEP( symbol, 5 );
    10071002      intraPredMode = symbol;
    … …  
    14441439  else
    14451440  {
    1446     iDQp=0;
    14471441    qp = pcCU->getRefQP(uiAbsPartIdx);
    14481442  }
    … …  
    16341628
    16351629  //===== decode significance flags =====
    1636   UInt uiScanPosLast = uiBlkPosLast;
     1630  UInt uiScanPosLast;
    16371631  const UInt *scan   = g_auiSigLastScan[ uiScanIdx ][ uiLog2BlockSize-1 ];
    16381632  for( uiScanPosLast = 0; uiScanPosLast < uiMaxNumCoeffM1; uiScanPosLast++ )

  • branches/HTM-DEV-0.3-dev2/source/Lib/TLibDecoder/TDecSlice.cpp

    r521 r537  
    372372    pcSbacDecoders[uiSubStrm].load(pcSbacDecoder);
    373373
     374    if ( uiCol == rpcPic->getPicSym()->getTComTile(rpcPic->getPicSym()->getTileIdxMap(iCUAddr))->getRightEdgePosInCU()
     375        && pcSlice->getPPS()->getEntropyCodingSyncEnabledFlag()
     376        && !uiIsLast )
     377    {
     378      // Parse end_of_substream_one_bit for WPP case
     379      UInt binVal;
     380      pcSbacDecoder->parseTerminatingBit( binVal );
     381      assert( binVal );
     382    }
     383
    374384    //Store probabilities of second LCU in line into buffer
    375385    if ( (uiCol == uiTileLCUX+1)&& (depSliceSegmentsEnabled || (pcSlice->getPPS()->getNumSubstreams() > 1)) && (pcSlice->getPPS()->getEntropyCodingSyncEnabledFlag()) )

  • branches/HTM-DEV-0.3-dev2/source/Lib/TLibDecoder/TDecTop.cpp

    r534 r537  
    441441  }
    442442
    443 #if L0323_DPB
    444   m_iMaxRefPicNum = pcSlice->getSPS()->getMaxDecPicBuffering(pcSlice->getTLayer())+pcSlice->getSPS()->getNumReorderPics(pcSlice->getTLayer());     // m_uiMaxDecPicBuffering has the space for the picture currently being decoded
    445 #else
    446   m_iMaxRefPicNum = pcSlice->getSPS()->getMaxDecPicBuffering(pcSlice->getTLayer())+pcSlice->getSPS()->getNumReorderPics(pcSlice->getTLayer()) + 1; // +1 to have space for the picture currently being decoded
    447 #endif
     443  m_iMaxRefPicNum = pcSlice->getSPS()->getMaxDecPicBuffering(pcSlice->getTLayer());     // m_uiMaxDecPicBuffering has the space for the picture currently being decoded
    448444  if (m_cListPic.size() < (UInt)m_iMaxRefPicNum)
    449445  {
    … …  
    964960    //---------------
    965961    pcSlice->setRefPOCList();
    966 #if !L0034_COMBINED_LIST_CLEANUP
    967     pcSlice->setNoBackPredFlag( false );
    968     if ( pcSlice->getSliceType() == B_SLICE )
    969     {
    970       if ( pcSlice->getNumRefIdx(RefPicList( 0 ) ) == pcSlice->getNumRefIdx(RefPicList( 1 ) ) )
    971       {
    972         pcSlice->setNoBackPredFlag( true );
    973         for ( i=0; i < pcSlice->getNumRefIdx(RefPicList( 1 ) ); i++ )
    974         {
    975           if ( pcSlice->getRefPOC(RefPicList(1), i) != pcSlice->getRefPOC(RefPicList(0), i) )
    976           {
    977             pcSlice->setNoBackPredFlag( false );
    978             break;
    979           }
    980         }
    981       }
    982     }
    983 #endif
    984962#if  H_3D_TMVP
    985963    if(pcSlice->getLayerId())

  • branches/HTM-DEV-0.3-dev2/source/Lib/TLibEncoder/SEIwrite.cpp

    r446 r537  
    8484    fprintf( g_hTrace, "=========== Decoding Unit Information SEI message ===========\n");
    8585    break;
    86 #if J0149_TONE_MAPPING_SEI
    8786  case SEI::TONE_MAPPING_INFO:
    8887    fprintf( g_hTrace, "=========== Tone Mapping Info SEI message ===========\n");
    8988    break;
    90 #endif
    91 #if L0208_SOP_DESCRIPTION_SEI
    9289  case SEI::SOP_DESCRIPTION:
    9390    fprintf( g_hTrace, "=========== SOP Description SEI message ===========\n");
    9491    break;
    95 #endif
    96 #if K0180_SCALABLE_NESTING_SEI
    9792  case SEI::SCALABLE_NESTING:
    9893    fprintf( g_hTrace, "=========== Scalable Nesting SEI message ===========\n");
    9994    break;
    100 #endif
    10195  default:
    10296    fprintf( g_hTrace, "=========== Unknown SEI message ===========\n");
    … …  
    106100#endif
    107101
    108 #if K0180_SCALABLE_NESTING_SEI
    109102void SEIWriter::xWriteSEIpayloadData(TComBitIf& bs, const SEI& sei, TComSPS *sps)
    110 #else
    111 void SEIWriter::xWriteSEIpayloadData(const SEI& sei, TComSPS *sps)
    112 #endif
    113103{
    114104  switch (sei.payloadType())
    … …  
    147137    xWriteSEIGradualDecodingRefreshInfo(*static_cast<const SEIGradualDecodingRefreshInfo*>(&sei));
    148138    break;
    149 #if J0149_TONE_MAPPING_SEI
    150139  case SEI::TONE_MAPPING_INFO:
    151140    xWriteSEIToneMappingInfo(*static_cast<const SEIToneMappingInfo*>(&sei));
    152141    break;
    153 #endif
    154 #if L0208_SOP_DESCRIPTION_SEI
    155142  case SEI::SOP_DESCRIPTION:
    156143    xWriteSEISOPDescription(*static_cast<const SEISOPDescription*>(&sei));
    157144    break;
    158 #endif
    159 #if K0180_SCALABLE_NESTING_SEI
    160145  case SEI::SCALABLE_NESTING:
    161146    xWriteSEIScalableNesting(bs, *static_cast<const SEIScalableNesting*>(&sei), sps);
    162147    break;
    163 #endif
    164148  default:
    165149    assert(!"Unhandled SEI message");
    … …  
    179163  setBitstream(&bs_count);
    180164
    181 
    182 #if K0180_SCALABLE_NESTING_SEI
    183165
    184166#if ENC_DEC_TRACE
    … …  
    191173#endif
    192174
    193 #else
    194 
    195 #if ENC_DEC_TRACE
    196   g_HLSTraceEnable = false;
    197 #endif
    198   xWriteSEIpayloadData(sei, sps);
    199 #if ENC_DEC_TRACE
    200   g_HLSTraceEnable = true;
    201 #endif
    202 
    203 #endif
    204 
    205175  UInt payload_data_num_bits = bs_count.getNumberOfWrittenBits();
    206176  assert(0 == payload_data_num_bits % 8);
    … …  
    209179
    210180#if ENC_DEC_TRACE
    211 #if K0180_SCALABLE_NESTING_SEI
    212181  if (g_HLSTraceEnable)
    213 #endif
    214182  xTraceSEIHeader();
    215183#endif
    … …  
    231199  /* payloadData */
    232200#if ENC_DEC_TRACE
    233 #if K0180_SCALABLE_NESTING_SEI
    234201  if (g_HLSTraceEnable)
    235 #endif
    236202  xTraceSEIMessageType(sei.payloadType());
    237203#endif
    238204
    239 #if K0180_SCALABLE_NESTING_SEI
    240205  xWriteSEIpayloadData(bs, sei, sps);
    241 #else
    242   xWriteSEIpayloadData(sei, sps);
    243 #endif
    244206}
    245207
    … …  
    296258{
    297259  WRITE_CODE(sei.activeVPSId,     4, "active_vps_id");
    298 #if L0047_APS_FLAGS
    299260  WRITE_FLAG(sei.m_fullRandomAccessFlag, "full_random_access_flag");
    300261  WRITE_FLAG(sei.m_noParamSetUpdateFlag, "no_param_set_update_flag");
    301 #endif
    302262  WRITE_UVLC(sei.numSpsIdsMinus1,    "num_sps_ids_minus1");
    303263
    … …  
    330290    WRITE_CODE( sei.m_duSptCpbRemovalDelay, (vui->getHrdParameters()->getDuCpbRemovalDelayLengthMinus1() + 1), "du_spt_cpb_removal_delay");
    331291  }
    332 #if L0044_DU_DPB_OUTPUT_DELAY_HRD
    333292  WRITE_FLAG( sei.m_dpbOutputDuDelayPresentFlag, "dpb_output_du_delay_present_flag");
    334293  if(sei.m_dpbOutputDuDelayPresentFlag)
    … …  
    336295    WRITE_CODE(sei.m_picSptDpbOutputDuDelay, vui->getHrdParameters()->getDpbOutputDelayDuLengthMinus1() + 1, "pic_spt_dpb_output_du_delay");
    337296  }
    338 #endif
    339297  xWriteByteAlign();
    340298}
    … …  
    351309    WRITE_FLAG( sei.m_rapCpbParamsPresentFlag, "rap_cpb_params_present_flag" );
    352310  }
    353 #if L0328_SPLICING
    354311  WRITE_FLAG( sei.m_concatenationFlag, "concatenation_flag");
    355312  WRITE_CODE( sei.m_auCpbRemovalDelayDelta - 1, ( hrd->getCpbRemovalDelayLengthMinus1() + 1 ), "au_cpb_removal_delay_delta_minus1" );
    356 #endif
    357 #if L0044_CPB_DPB_DELAY_OFFSET
    358313  if( sei.m_rapCpbParamsPresentFlag )
    359314  {
    … …  
    361316    WRITE_CODE( sei.m_dpbDelayOffset, hrd->getDpbOutputDelayLengthMinus1()  + 1, "dpb_delay_offset" );
    362317  }
    363 #endif
    364318  for( nalOrVcl = 0; nalOrVcl < 2; nalOrVcl ++ )
    365319  {
    … …  
    387341  TComHRD *hrd = vui->getHrdParameters();
    388342
    389 #if !L0045_CONDITION_SIGNALLING
    390   // This condition was probably OK before the pic_struct, progressive_source_idc, duplicate_flag were added
    391   if( !hrd->getNalHrdParametersPresentFlag() && !hrd->getVclHrdParametersPresentFlag() )
    392     return;
    393 #endif
    394343  if( vui->getFrameFieldInfoPresentFlag() )
    395344  {
    396345    WRITE_CODE( sei.m_picStruct, 4,              "pic_struct" );
    397 #if L0046_RENAME_PROG_SRC_IDC
    398346    WRITE_CODE( sei.m_sourceScanType, 2,         "source_scan_type" );
    399 #else
    400     WRITE_CODE( sei.m_progressiveSourceIdc, 2,   "progressive_source_idc" );
    401 #endif
    402347    WRITE_FLAG( sei.m_duplicateFlag ? 1 : 0,     "duplicate_flag" );
    403348  }
    404349
    405 #if L0045_CONDITION_SIGNALLING
    406350  if( hrd->getCpbDpbDelaysPresentFlag() )
    407351  {
    408 #endif
    409352    WRITE_CODE( sei.m_auCpbRemovalDelay - 1, ( hrd->getCpbRemovalDelayLengthMinus1() + 1 ),                                         "au_cpb_removal_delay_minus1" );
    410353    WRITE_CODE( sei.m_picDpbOutputDelay, ( hrd->getDpbOutputDelayLengthMinus1() + 1 ),                                          "pic_dpb_output_delay" );
    411 #if L0044_DU_DPB_OUTPUT_DELAY_HRD
    412354    if(hrd->getSubPicCpbParamsPresentFlag())
    413355    {
    414356      WRITE_CODE(sei.m_picDpbOutputDuDelay, hrd->getDpbOutputDelayDuLengthMinus1()+1, "pic_dpb_output_du_delay" );
    415357    }
    416 #endif
    417358    if( hrd->getSubPicCpbParamsPresentFlag() && hrd->getSubPicCpbParamsInPicTimingSEIFlag() )
    418359    {
    … …  
    432373      }
    433374    }
    434 #if L0045_CONDITION_SIGNALLING
    435   }
    436 #endif
     375  }
    437376  xWriteByteAlign();
    438377}
    … …  
    471410
    472411    WRITE_CODE( sei.m_arrangementReservedByte, 8,   "frame_packing_arrangement_reserved_byte" );
    473 #if L0045_PERSISTENCE_FLAGS
    474412    WRITE_FLAG( sei.m_arrangementPersistenceFlag,   "frame_packing_arrangement_persistence_flag" );
    475 #else
    476     WRITE_UVLC( sei.m_arrangementRepetetionPeriod,  "frame_packing_arrangement_repetition_period" );
    477 #endif
    478413  }
    479414
    … …  
    483418}
    484419
    485 #if J0149_TONE_MAPPING_SEI
    486420Void SEIWriter::xWriteSEIToneMappingInfo(const SEIToneMappingInfo& sei)
    487421{
    … …  
    555489  xWriteByteAlign();
    556490}
    557 #endif
    558491
    559492Void SEIWriter::xWriteSEIDisplayOrientation(const SEIDisplayOrientation &sei)
    … …  
    565498    WRITE_FLAG( sei.verFlip,                   "ver_flip" );
    566499    WRITE_CODE( sei.anticlockwiseRotation, 16, "anticlockwise_rotation" );
    567 #if L0045_PERSISTENCE_FLAGS
    568500    WRITE_FLAG( sei.persistenceFlag,          "display_orientation_persistence_flag" );
    569 #else
    570     WRITE_UVLC( sei.repetitionPeriod,          "display_orientation_repetition_period" );
    571 #endif
    572 #if !REMOVE_SINGLE_SEI_EXTENSION_FLAGS
    573     WRITE_FLAG( sei.extensionFlag,             "display_orientation_extension_flag" );
    574     assert( !sei.extensionFlag );
    575 #endif
    576501  }
    577502  xWriteByteAlign();
    … …  
    591516}
    592517
    593 #if L0208_SOP_DESCRIPTION_SEI
    594518Void SEIWriter::xWriteSEISOPDescription(const SEISOPDescription& sei)
    595519{
    … …  
    612536  xWriteByteAlign();
    613537}
    614 #endif
    615 
    616 #if K0180_SCALABLE_NESTING_SEI
     538
    617539Void SEIWriter::xWriteSEIScalableNesting(TComBitIf& bs, const SEIScalableNesting& sei, TComSPS *sps)
    618540{
    … …  
    656578  }
    657579}
    658 #endif
    659580
    660581Void SEIWriter::xWriteByteAlign()

  • branches/HTM-DEV-0.3-dev2/source/Lib/TLibEncoder/SEIwrite.h

    r446 r537  
    5050
    5151protected:
    52 #if K0180_SCALABLE_NESTING_SEI
    5352  Void xWriteSEIpayloadData(TComBitIf& bs, const SEI& sei, TComSPS *sps);
    54 #else
    55   Void xWriteSEIpayloadData(const SEI& sei, TComSPS *sps);
    56 #endif
    5753  Void xWriteSEIuserDataUnregistered(const SEIuserDataUnregistered &sei);
    5854  Void xWriteSEIActiveParameterSets(const SEIActiveParameterSets& sei);
    … …  
    6763  Void xWriteSEITemporalLevel0Index(const SEITemporalLevel0Index &sei);
    6864  Void xWriteSEIGradualDecodingRefreshInfo(const SEIGradualDecodingRefreshInfo &sei);
    69 #if J0149_TONE_MAPPING_SEI
    7065  Void xWriteSEIToneMappingInfo(const SEIToneMappingInfo& sei);
    71 #endif
    72 #if L0208_SOP_DESCRIPTION_SEI
    7366  Void xWriteSEISOPDescription(const SEISOPDescription& sei);
    74 #endif
    75 #if K0180_SCALABLE_NESTING_SEI
    7667  Void xWriteSEIScalableNesting(TComBitIf& bs, const SEIScalableNesting& sei, TComSPS *sps);
    77 #endif
    7868  Void xWriteByteAlign();
    7969};

  • branches/HTM-DEV-0.3-dev2/source/Lib/TLibEncoder/TEncCavlc.cpp

    r534 r537  
    172172  WRITE_UVLC( pcPPS->getSPSId(),                             "pps_seq_parameter_set_id" );
    173173  WRITE_FLAG( pcPPS->getDependentSliceSegmentsEnabledFlag()    ? 1 : 0, "dependent_slice_segments_enabled_flag" );
    174 #if L0255_MOVE_PPS_FLAGS
    175174  WRITE_FLAG( pcPPS->getOutputFlagPresentFlag() ? 1 : 0,     "output_flag_present_flag" );
    176175  WRITE_CODE( pcPPS->getNumExtraSliceHeaderBits(), 3,        "num_extra_slice_header_bits");
    177 #endif
    178176  WRITE_FLAG( pcPPS->getSignHideFlag(), "sign_data_hiding_flag" );
    179177  WRITE_FLAG( pcPPS->getCabacInitPresentFlag() ? 1 : 0,   "cabac_init_present_flag" );
    … …  
    195193  WRITE_FLAG( pcPPS->getUseWP() ? 1 : 0,  "weighted_pred_flag" );   // Use of Weighting Prediction (P_SLICE)
    196194  WRITE_FLAG( pcPPS->getWPBiPred() ? 1 : 0, "weighted_bipred_flag" );  // Use of Weighting Bi-Prediction (B_SLICE)
    197 #if !L0255_MOVE_PPS_FLAGS
    198   WRITE_FLAG( pcPPS->getOutputFlagPresentFlag() ? 1 : 0,  "output_flag_present_flag" );
    199 #endif
    200195  WRITE_FLAG( pcPPS->getTransquantBypassEnableFlag() ? 1 : 0, "transquant_bypass_enable_flag" );
    201196  WRITE_FLAG( pcPPS->getTilesEnabledFlag()             ? 1 : 0, "tiles_enabled_flag" );
    … …  
    244239  WRITE_FLAG( pcPPS->getListsModificationPresentFlag(), "lists_modification_present_flag");
    245240  WRITE_UVLC( pcPPS->getLog2ParallelMergeLevelMinus2(), "log2_parallel_merge_level_minus2");
    246 #if !L0255_MOVE_PPS_FLAGS
    247   WRITE_CODE( pcPPS->getNumExtraSliceHeaderBits(), 3, "num_extra_slice_header_bits");
    248 #endif
    249241  WRITE_FLAG( pcPPS->getSliceHeaderExtensionPresentFlag() ? 1 : 0, "slice_segment_header_extension_present_flag");
    250242  WRITE_FLAG( 0, "pps_extension_flag" );
    … …  
    305297    WRITE_UVLC(defaultDisplayWindow.getWindowBottomOffset(),    "def_disp_win_bottom_offset");
    306298  }
    307 #if L0043_TIMING_INFO
    308299  TimingInfo *timingInfo = pcVUI->getTimingInfo();
    309300  WRITE_FLAG(timingInfo->getTimingInfoPresentFlag(),          "vui_timing_info_present_flag");
    … …  
    317308      WRITE_UVLC(timingInfo->getNumTicksPocDiffOneMinus1(),   "vui_num_ticks_poc_diff_one_minus1");
    318309    }
    319 #endif
    320310  WRITE_FLAG(pcVUI->getHrdParametersPresentFlag(),              "hrd_parameters_present_flag");
    321311  if( pcVUI->getHrdParametersPresentFlag() )
    … …  
    323313    codeHrdParameters(pcVUI->getHrdParameters(), 1, pcSPS->getMaxTLayers() - 1 );
    324314  }
    325 #if L0043_TIMING_INFO
    326   }
    327 #endif
    328 #if !L0043_TIMING_INFO
    329   WRITE_FLAG( pcVUI->getPocProportionalToTimingFlag(), "poc_proportional_to_timing_flag" );
    330   if( pcVUI->getPocProportionalToTimingFlag() && pcVUI->getHrdParameters()->getTimingInfoPresentFlag() )
    331   {
    332     WRITE_UVLC( pcVUI->getNumTicksPocDiffOneMinus1(), "num_ticks_poc_diff_one_minus1" );
    333   }
    334 #endif
     315  }
    335316
    336317  WRITE_FLAG(pcVUI->getBitstreamRestrictionFlag(),              "bitstream_restriction_flag");
    … …  
    346327    WRITE_FLAG(pcVUI->getMotionVectorsOverPicBoundariesFlag(),  "motion_vectors_over_pic_boundaries_flag");
    347328    WRITE_FLAG(pcVUI->getRestrictedRefPicListsFlag(),           "restricted_ref_pic_lists_flag");
    348 #if L0043_MSS_IDC
    349329    WRITE_UVLC(pcVUI->getMinSpatialSegmentationIdc(),           "min_spatial_segmentation_idc");
    350 #else
    351     WRITE_CODE(pcVUI->getMinSpatialSegmentationIdc(),        8, "min_spatial_segmentation_idc");
    352 #endif
    353330    WRITE_UVLC(pcVUI->getMaxBytesPerPicDenom(),                 "max_bytes_per_pic_denom");
    354331    WRITE_UVLC(pcVUI->getMaxBitsPerMinCuDenom(),                "max_bits_per_mincu_denom");
    … …  
    362339  if( commonInfPresentFlag )
    363340  {
    364 #if !L0043_TIMING_INFO
    365     WRITE_FLAG( hrd->getTimingInfoPresentFlag() ? 1 : 0,        "timing_info_present_flag" );
    366     if( hrd->getTimingInfoPresentFlag() )
    367     {
    368       WRITE_CODE( hrd->getNumUnitsInTick(), 32,                  "num_units_in_tick" );
    369       WRITE_CODE( hrd->getTimeScale(),      32,                  "time_scale" );
    370     }
    371 #endif
    372341    WRITE_FLAG( hrd->getNalHrdParametersPresentFlag() ? 1 : 0 ,  "nal_hrd_parameters_present_flag" );
    373342    WRITE_FLAG( hrd->getVclHrdParametersPresentFlag() ? 1 : 0 ,  "vcl_hrd_parameters_present_flag" );
    … …  
    380349        WRITE_CODE( hrd->getDuCpbRemovalDelayLengthMinus1(), 5,  "du_cpb_removal_delay_length_minus1" );
    381350        WRITE_FLAG( hrd->getSubPicCpbParamsInPicTimingSEIFlag() ? 1 : 0, "sub_pic_cpb_params_in_pic_timing_sei_flag" );
    382 #if L0044_DU_DPB_OUTPUT_DELAY_HRD
    383351        WRITE_CODE( hrd->getDpbOutputDelayDuLengthMinus1(), 5,   "dpb_output_delay_du_length_minus1"  );
    384 #endif
    385352      }
    386353      WRITE_CODE( hrd->getBitRateScale(), 4,                     "bit_rate_scale" );
    … …  
    411378      WRITE_UVLC( hrd->getPicDurationInTcMinus1( i ),           "elemental_duration_in_tc_minus1");
    412379    }
    413 #if L0372
    414380    else
    415381    {
    … …  
    420386      WRITE_UVLC( hrd->getCpbCntMinus1( i ),                      "cpb_cnt_minus1");
    421387    }
    422 #else
    423     WRITE_FLAG( hrd->getLowDelayHrdFlag( i ) ? 1 : 0,           "low_delay_hrd_flag");
    424     WRITE_UVLC( hrd->getCpbCntMinus1( i ),                      "cpb_cnt_minus1");
    425 #endif
    426388   
    427389    for( nalOrVcl = 0; nalOrVcl < 2; nalOrVcl ++ )
    … …  
    436398          if( hrd->getSubPicCpbParamsPresentFlag() )
    437399          {
    438 #if L0363_DU_BIT_RATE
     400            WRITE_UVLC( hrd->getDuCpbSizeValueMinus1( i, j, nalOrVcl ), "cpb_size_du_value_minus1"); 
    439401            WRITE_UVLC( hrd->getDuBitRateValueMinus1( i, j, nalOrVcl ), "bit_rate_du_value_minus1");
    440 #endif
    441             WRITE_UVLC( hrd->getDuCpbSizeValueMinus1( i, j, nalOrVcl ), "cpb_size_du_value_minus1"); 
    442402          }
    443403          WRITE_FLAG( hrd->getCbrFlag( i, j, nalOrVcl ) ? 1 : 0, "cbr_flag");
    … …  
    499459  for(UInt i=0; i <= pcSPS->getMaxTLayers()-1; i++)
    500460  {
    501 #if L0323_DPB
    502461    WRITE_UVLC( pcSPS->getMaxDecPicBuffering(i) - 1,       "sps_max_dec_pic_buffering_minus1[i]" );
    503 #else
    504     WRITE_UVLC( pcSPS->getMaxDecPicBuffering(i),           "sps_max_dec_pic_buffering[i]" );
    505 #endif
    506462    WRITE_UVLC( pcSPS->getNumReorderPics(i),               "sps_num_reorder_pics[i]" );
    507     WRITE_UVLC( pcSPS->getMaxLatencyIncrease(i),           "sps_max_latency_increase[i]" );
     463    WRITE_UVLC( pcSPS->getMaxLatencyIncrease(i),           "sps_max_latency_increase_plus1[i]" );
    508464    if (!subLayerOrderingInfoPresentFlag)
    509465    {
    … …  
    642598#endif
    643599  codePTL( pcVPS->getPTL(), true, pcVPS->getMaxTLayers() - 1 );
    644 #if SIGNAL_BITRATE_PICRATE_IN_VPS
    645   codeBitratePicRateInfo(pcVPS->getBitratePicrateInfo(), 0, pcVPS->getMaxTLayers() - 1);
    646 #endif 
    647600  const Bool subLayerOrderingInfoPresentFlag = 1;
    648601  WRITE_FLAG(subLayerOrderingInfoPresentFlag,              "vps_sub_layer_ordering_info_present_flag");
    649602  for(UInt i=0; i <= pcVPS->getMaxTLayers()-1; i++)
    650603  {
    651 #if L0323_DPB
    652604    WRITE_UVLC( pcVPS->getMaxDecPicBuffering(i) - 1,       "vps_max_dec_pic_buffering_minus1[i]" );
    653 #else
    654     WRITE_UVLC( pcVPS->getMaxDecPicBuffering(i),           "vps_max_dec_pic_buffering[i]" );
    655 #endif
    656605    WRITE_UVLC( pcVPS->getNumReorderPics(i),               "vps_num_reorder_pics[i]" );
    657     WRITE_UVLC( pcVPS->getMaxLatencyIncrease(i),           "vps_max_latency_increase[i]" );
     606    WRITE_UVLC( pcVPS->getMaxLatencyIncrease(i),           "vps_max_latency_increase_plus1[i]" );
    658607    if (!subLayerOrderingInfoPresentFlag)
    659608    {
    … …  
    676625  assert( pcVPS->getMaxNuhReservedZeroLayerId() < MAX_VPS_NUH_RESERVED_ZERO_LAYER_ID_PLUS1 );
    677626  WRITE_CODE( pcVPS->getMaxNuhReservedZeroLayerId(), 6,     "vps_max_nuh_reserved_zero_layer_id" );
    678 
    679627  pcVPS->setMaxOpSets(1);
    680628  WRITE_UVLC( pcVPS->getMaxOpSets() - 1,                    "vps_max_op_sets_minus1" );
    … …  
    690638    }
    691639  }
    692 #if L0043_TIMING_INFO
    693640  TimingInfo *timingInfo = pcVPS->getTimingInfo();
    694641  WRITE_FLAG(timingInfo->getTimingInfoPresentFlag(),          "vps_timing_info_present_flag");
    … …  
    702649      WRITE_UVLC(timingInfo->getNumTicksPocDiffOneMinus1(),   "vps_num_ticks_poc_diff_one_minus1");
    703650    }
    704 #endif
    705651    pcVPS->setNumHrdParameters( 0 );
    706652    WRITE_UVLC( pcVPS->getNumHrdParameters(),                 "vps_num_hrd_parameters" );
    … …  
    721667      codeHrdParameters(pcVPS->getHrdParameters(i), pcVPS->getCprmsPresentFlag( i ), pcVPS->getMaxTLayers() - 1);
    722668    }
    723 #if L0043_TIMING_INFO
    724   }
    725 #endif
     669  }
    726670#if H_MV
    727671  WRITE_FLAG( 1,                                             "vps_extension_flag" );
    … …  
    983927    //   colour_plane_id                                      u(2)
    984928
    985 #if H_MV && !H_MV_FIX1071
    986     // Temporary fix for FIX1071 should be removed later
    987     TComReferencePictureSet* rps = pcSlice->getRPS();
    988 #endif     
    989929    if( !pcSlice->getIdrPicFlag() )
    990930    {
    991931      Int picOrderCntLSB = (pcSlice->getPOC()-pcSlice->getLastIDR()+(1<<pcSlice->getSPS()->getBitsForPOC()))%(1<<pcSlice->getSPS()->getBitsForPOC());
    992932      WRITE_CODE( picOrderCntLSB, pcSlice->getSPS()->getBitsForPOC(), "pic_order_cnt_lsb");
    993 #if !H_MV || H_MV_FIX1071
    994933      TComReferencePictureSet* rps = pcSlice->getRPS();
    995 #endif     
    996 #if FIX1071 && H_MV_FIX1071
     934     
     935#if FIX1071
    997936      // check for bitstream restriction stating that:
    998937      // If the current picture is a BLA or CRA picture, the value of NumPocTotalCurr shall be equal to 0.
    … …  
    1006945        }
    1007946#endif
    1008 #if FIX1071 && !H_MV_FIX1071
    1009       // Deal with bitstream restriction stating that:
    1010       // – If the current picture is a BLA or CRA picture, the value of NumPocTotalCurr shall be equal to 0.
    1011       // Ideally this process should not be repeated for each slice in a picture
    1012       TComReferencePictureSet altRps;
    1013       Bool useAltRps = false;
    1014       if (pcSlice->getRapPicFlag())
    1015       {
    1016         for (Int picIdx = 0; !useAltRps && picIdx < rps->getNumberOfPictures(); picIdx++)
    1017         {
    1018           useAltRps = rps->getUsed(picIdx);
    1019         }
    1020         if (useAltRps)
    1021         {
    1022           memcpy(&altRps, rps, sizeof(TComReferencePictureSet));
    1023           rps = &altRps;
    1024           for (Int picIdx = 0; picIdx < rps->getNumberOfPictures(); picIdx++)
    1025           {
    1026             rps->setUsed(picIdx, false);
    1027           }
    1028         }
    1029       }
    1030       if(pcSlice->getRPSidx() < 0 || useAltRps)
    1031 #else
     947
    1032948      if(pcSlice->getRPSidx() < 0)
    1033 #endif
    1034949      {
    1035950        WRITE_FLAG( 0, "short_term_ref_pic_set_sps_flag");
    … …  
    11881103      pcSlice->setNumRefIdx(REF_PIC_LIST_1, 0);
    11891104    }
    1190 #if H_MV && !H_MV_FIX1071
    1191     // Temporary fix for FIX1071 should be removed later
    1192     if( pcSlice->getPPS()->getListsModificationPresentFlag() && pcSlice->getNumRpsCurrTempList( rps ) > 1)
    1193 #else
     1105
    11941106    if( pcSlice->getPPS()->getListsModificationPresentFlag() && pcSlice->getNumRpsCurrTempList() > 1)
    1195 #endif
    11961107    {
    11971108      TComRefPicListModification* refPicListModification = pcSlice->getRefPicListModification();
    … …  
    13851296  WRITE_CODE( pcPTL->getGeneralPTL()->getLevelIdc(), 8, "general_level_idc" );
    13861297
    1387 #if L0363_BYTE_ALIGN
    13881298  for (Int i = 0; i < maxNumSubLayersMinus1; i++)
    13891299  {
    … …  
    14071317    }
    14081318  }
    1409 #endif
    14101319 
    14111320  for(Int i = 0; i < maxNumSubLayersMinus1; i++)
    14121321  {
    1413 #if !L0363_BYTE_ALIGN
    1414     if(profilePresentFlag)
    1415     {
    1416       WRITE_FLAG( pcPTL->getSubLayerProfilePresentFlag(i), "sub_layer_profile_present_flag[i]" );
    1417     }
    1418 
    1419     WRITE_FLAG( pcPTL->getSubLayerLevelPresentFlag(i),   "sub_layer_level_present_flag[i]" );
    1420 #endif
    14211322    if( profilePresentFlag && pcPTL->getSubLayerProfilePresentFlag(i) )
    14221323    {
    … …  
    14391340  }
    14401341
    1441 #if L0046_CONSTRAINT_FLAGS
    14421342  WRITE_FLAG(ptl->getProgressiveSourceFlag(),   "general_progressive_source_flag");
    14431343  WRITE_FLAG(ptl->getInterlacedSourceFlag(),    "general_interlaced_source_flag");
    … …  
    14481348  WRITE_CODE(0 , 16, "XXX_reserved_zero_44bits[16..31]");
    14491349  WRITE_CODE(0 , 12, "XXX_reserved_zero_44bits[32..43]");
    1450 #elif L0363_MORE_BITS
    1451   WRITE_CODE(0 , 16, "XXX_reserved_zero_48bits[0..15]");
    1452   WRITE_CODE(0 , 16, "XXX_reserved_zero_48bits[16..31]");
    1453   WRITE_CODE(0 , 16, "XXX_reserved_zero_48bits[32..47]");
    1454 #else
    1455   WRITE_CODE(0 , 16, "XXX_reserved_zero_16bits[]");
    1456 #endif
    1457 }
    1458 #if SIGNAL_BITRATE_PICRATE_IN_VPS
    1459 Void TEncCavlc::codeBitratePicRateInfo(TComBitRatePicRateInfo *info, Int tempLevelLow, Int tempLevelHigh)
    1460 {
    1461   for(Int i = tempLevelLow; i <= tempLevelHigh; i++)
    1462   {
    1463     WRITE_FLAG( info->getBitRateInfoPresentFlag(i),  "bit_rate_info_present_flag[i]" );
    1464     WRITE_FLAG( info->getPicRateInfoPresentFlag(i),  "pic_rate_info_present_flag[i]" );
    1465     if(info->getBitRateInfoPresentFlag(i))
    1466     {
    1467       WRITE_CODE( info->getAvgBitRate(i), 16, "avg_bit_rate[i]" );
    1468       WRITE_CODE( info->getMaxBitRate(i), 16, "max_bit_rate[i]" );
    1469     }
    1470     if(info->getPicRateInfoPresentFlag(i))
    1471     {
    1472       WRITE_CODE( info->getConstantPicRateIdc(i),  2, "constant_pic_rate_idc[i]" );
    1473       WRITE_CODE( info->getAvgPicRate(i),         16, "avg_pic_rate[i]"          );
    1474     }
    1475   }
    1476 }
    1477 #endif 
     1350    }
     1351
    14781352/**
    14791353 - write wavefront substreams sizes for the slice header.
    … …  
    15451419  for (UInt idx=0; idx<numEntryPointOffsets; idx++)
    15461420  {
    1547 #if L0116_ENTRY_POINT
    15481421    WRITE_CODE(entryPointOffset[ idx ]-1, offsetLenMinus1+1, "entry_point_offset_minus1");
    1549 #else
    1550     WRITE_CODE(entryPointOffset[ idx ], offsetLenMinus1+1, "entry_point_offset");
    1551 #endif
    15521422  }
    15531423

  • branches/HTM-DEV-0.3-dev2/source/Lib/TLibEncoder/TEncCavlc.h

    r504 r537  
    9494  Void  codePTL                 ( TComPTL* pcPTL, Bool profilePresentFlag, Int maxNumSubLayersMinus1);
    9595  Void  codeProfileTier         ( ProfileTierLevel* ptl );
    96 #if SIGNAL_BITRATE_PICRATE_IN_VPS
    97   Void codeBitratePicRateInfo(TComBitRatePicRateInfo *info, Int tempLevelLow, Int tempLevelHigh);
    98 #endif
    9996  Void  codeHrdParameters       ( TComHRD *hrd, Bool commonInfPresentFlag, UInt maxNumSubLayersMinus1 );
    10097  Void  codeTilesWPPEntryPoint( TComSlice* pSlice );

  • branches/HTM-DEV-0.3-dev2/source/Lib/TLibEncoder/TEncCfg.h

    r534 r537  
    135135  Level::Tier   m_levelTier;
    136136  Level::Name   m_level;
    137 #if L0046_CONSTRAINT_FLAGS
    138137  Bool m_progressiveSourceFlag;
    139138  Bool m_interlacedSourceFlag;
    140139  Bool m_nonPackedConstraintFlag;
    141140  Bool m_frameOnlyConstraintFlag;
    142 #endif
    143141
    144142  //====== Coding Structure ========
    … …  
    177175  Int       m_loopFilterTcOffsetDiv2;
    178176  Bool      m_DeblockingFilterControlPresent;
    179 #if L0386_DB_METRIC
    180177  Bool      m_DeblockingFilterMetric;
    181 #endif
    182178  Bool      m_bUseSAO;
    183179  Int       m_maxNumOffsetsPerPic;
    … …  
    210206  Bool      m_bUseASR;
    211207  Bool      m_bUseHADME;
    212 #if !L0034_COMBINED_LIST_CLEANUP
    213   Bool      m_bUseLComb;
    214 #endif
    215208  Bool      m_useRDOQ;
    216209  Bool      m_useRDOQTS;
    217 #if L0232_RD_PENALTY
    218210  UInt      m_rdPenalty;
    219 #endif
    220211  Bool      m_bUseFastEnc;
    221212  Bool      m_bUseEarlyCU;
    … …  
    258249  Int       m_pictureTimingSEIEnabled;
    259250  Int       m_recoveryPointSEIEnabled;
    260 #if J0149_TONE_MAPPING_SEI
    261251  Bool      m_toneMappingInfoSEIEnabled;
    262252  Int       m_toneMapId;
    … …  
    284274  Int*      m_codedPivotValue;
    285275  Int*      m_targetPivotValue;
    286 #endif
    287276  Int       m_framePackingSEIEnabled;
    288277  Int       m_framePackingSEIType;
    … …  
    294283  Int       m_gradualDecodingRefreshInfoEnabled;
    295284  Int       m_decodingUnitInfoSEIEnabled;
    296 #if L0208_SOP_DESCRIPTION_SEI
    297285  Int       m_SOPDescriptionSEIEnabled;
    298 #endif
    299 #if K0180_SCALABLE_NESTING_SEI
    300286  Int       m_scalableNestingSEIEnabled;
    301 #endif
    302287  //====== Weighted Prediction ========
    303288  Bool      m_useWeightedPred;       //< Use of Weighting Prediction (P_SLICE)
    … …  
    312297  Bool      m_RCEnableRateControl;
    313298  Int       m_RCTargetBitrate;
     299#if M0036_RC_IMPROVEMENT
     300  Int       m_RCKeepHierarchicalBit;
     301#else
    314302  Bool      m_RCKeepHierarchicalBit;
     303#endif
    315304  Bool      m_RCLCULevelRC;
    316305  Bool      m_RCUseLCUSeparateModel;
    … …  
    389378  Double    m_dLambdaScaleVSO;
    390379  UInt      m_uiVSOMode;
    391  
    392380  // LGE_WVSO_A0119
    393381  Bool      m_bUseWVSO;
    … …  
    395383  Int       m_iVSDWeight;
    396384  Int       m_iDWeight;
    397 #endif
    398 
    399385  // SAIT_VSO_EST_A0033
    400386  Bool      m_bUseEstimatedVSD;
    401387  Double    m_dDispCoeff;
    402 
     388#endif
    403389#if H_3D_ARP
    404390  UInt      m_uiUseAdvResPred;
    405391  UInt      m_uiARPStepNum;
    406392#endif
    407 
    408393#if H_3D_IC
    409394  Bool      m_bUseIC;
    410395#endif
    411 
    412396  //====== Depth Intra Modes ======
    413397#if H_3D_DIM
    … …  
    417401  Bool      m_useDLT;
    418402#endif
    419 
    420 #endif
    421 
     403#endif
    422404public:
    423405  TEncCfg()
    … …  
    519501  Void      setLoopFilterTcOffset           ( Int   i )      { m_loopFilterTcOffsetDiv2    = i; }
    520502  Void      setDeblockingFilterControlPresent ( Bool b ) { m_DeblockingFilterControlPresent = b; }
    521 #if L0386_DB_METRIC
    522503  Void      setDeblockingFilterMetric       ( Bool  b )      { m_DeblockingFilterMetric = b; }
    523 #endif
    524504
    525505  //====== Motion search ========
    … …  
    576556  Int       getLoopFilterTcOffset           ()      { return m_loopFilterTcOffsetDiv2; }
    577557  Bool      getDeblockingFilterControlPresent()  { return  m_DeblockingFilterControlPresent; }
    578 #if L0386_DB_METRIC
    579558  Bool      getDeblockingFilterMetric       ()      { return m_DeblockingFilterMetric; }
    580 #endif
    581559
    582560  //==== Motion search ========
    … …  
    596574  Void      setUseASR                       ( Bool  b )     { m_bUseASR     = b; }
    597575  Void      setUseHADME                     ( Bool  b )     { m_bUseHADME   = b; }
    598 #if !L0034_COMBINED_LIST_CLEANUP
    599   Void      setUseLComb                     ( Bool  b )     { m_bUseLComb   = b; }
    600 #endif
    601576  Void      setUseRDOQ                      ( Bool  b )     { m_useRDOQ    = b; }
    602577  Void      setUseRDOQTS                    ( Bool  b )     { m_useRDOQTS  = b; }
    603 #if L0232_RD_PENALTY
    604578  Void      setRDpenalty                 ( UInt  b )     { m_rdPenalty  = b; }
    605 #endif
    606579  Void      setUseFastEnc                   ( Bool  b )     { m_bUseFastEnc = b; }
    607580  Void      setUseEarlyCU                   ( Bool  b )     { m_bUseEarlyCU = b; }
    … …  
    620593  Bool      getUseASR                       ()      { return m_bUseASR;     }
    621594  Bool      getUseHADME                     ()      { return m_bUseHADME;   }
    622 #if !L0034_COMBINED_LIST_CLEANUP
    623   Bool      getUseLComb                     ()      { return m_bUseLComb;   }
    624 #endif
    625595  Bool      getUseRDOQ                      ()      { return m_useRDOQ;    }
    626596  Bool      getUseRDOQTS                    ()      { return m_useRDOQTS;  }
    627 #if L0232_RD_PENALTY
    628597  Int      getRDpenalty                  ()      { return m_rdPenalty;  }
    629 #endif
    630598  Bool      getUseFastEnc                   ()      { return m_bUseFastEnc; }
    631599  Bool      getUseEarlyCU                   ()      { return m_bUseEarlyCU; }
    … …  
    719687  Void  setRecoveryPointSEIEnabled(Int b)                { m_recoveryPointSEIEnabled = b; }
    720688  Int   getRecoveryPointSEIEnabled()                     { return m_recoveryPointSEIEnabled; }
    721 #if J0149_TONE_MAPPING_SEI
    722689  Void  setToneMappingInfoSEIEnabled(Bool b)                 {  m_toneMappingInfoSEIEnabled = b;  }
    723690  Bool  getToneMappingInfoSEIEnabled()                       {  return m_toneMappingInfoSEIEnabled;  }
    … …  
    770737  Void  setTMISEIExtendedWhiteLevelLumaCodeValue(Int b)      {  m_extendedWhiteLevelLumaCodeValue =b;  }
    771738  Int   getTMISEIExtendedWhiteLevelLumaCodeValue()           {  return m_extendedWhiteLevelLumaCodeValue;  }
    772 #endif
    773739  Void  setFramePackingArrangementSEIEnabled(Int b)      { m_framePackingSEIEnabled = b; }
    774740  Int   getFramePackingArrangementSEIEnabled()           { return m_framePackingSEIEnabled; }
    … …  
    789755  Void  setDecodingUnitInfoSEIEnabled(Int b)                { m_decodingUnitInfoSEIEnabled = b;    }
    790756  Int   getDecodingUnitInfoSEIEnabled()                     { return m_decodingUnitInfoSEIEnabled; }
    791 #if L0208_SOP_DESCRIPTION_SEI
    792757  Void  setSOPDescriptionSEIEnabled(Int b)                { m_SOPDescriptionSEIEnabled = b; }
    793758  Int   getSOPDescriptionSEIEnabled()                     { return m_SOPDescriptionSEIEnabled; }
    794 #endif
    795 #if K0180_SCALABLE_NESTING_SEI
    796759  Void  setScalableNestingSEIEnabled(Int b)                { m_scalableNestingSEIEnabled = b; }
    797760  Int   getScalableNestingSEIEnabled()                     { return m_scalableNestingSEIEnabled; }
    798 #endif
    799761  Void      setUseWP               ( Bool b )    { m_useWeightedPred   = b;    }
    800762  Void      setWPBiPred            ( Bool b )    { m_useWeightedBiPred = b;    }
    … …  
    818780  Int       getTargetBitrate       ()              { return m_RCTargetBitrate;       }
    819781  Void      setTargetBitrate       ( Int bitrate ) { m_RCTargetBitrate  = bitrate;   }
     782#if M0036_RC_IMPROVEMENT
     783  Int       getKeepHierBit         ()              { return m_RCKeepHierarchicalBit; }
     784  Void      setKeepHierBit         ( Int i )       { m_RCKeepHierarchicalBit = i;    }
     785#else
    820786  Bool      getKeepHierBit         ()              { return m_RCKeepHierarchicalBit; }
    821787  Void      setKeepHierBit         ( Bool b )      { m_RCKeepHierarchicalBit = b;    }
     788#endif
    822789  Bool      getLCULevelRC          ()              { return m_RCLCULevelRC; }
    823790  Void      setLCULevelRC          ( Bool b )      { m_RCLCULevelRC = b; }
    … …  
    916883  Void      setLog2MaxMvLengthVertical(Int i)             { m_log2MaxMvLengthVertical = i; }
    917884 
    918 #if L0046_CONSTRAINT_FLAGS
    919885  Bool getProgressiveSourceFlag() const { return m_progressiveSourceFlag; }
    920886  Void setProgressiveSourceFlag(Bool b) { m_progressiveSourceFlag = b; }
    … …  
    928894  Bool getFrameOnlyConstraintFlag() const { return m_frameOnlyConstraintFlag; }
    929895  Void setFrameOnlyConstraintFlag(Bool b) { m_frameOnlyConstraintFlag = b; }
    930 #endif
    931896#if H_3D
    932897  /// 3D Tools

  • branches/HTM-DEV-0.3-dev2/source/Lib/TLibEncoder/TEncCu.cpp

    r531 r537  
    103103 
    104104  m_bEncodeDQP = false;
    105 #if RATE_CONTROL_LAMBDA_DOMAIN
     105#if RATE_CONTROL_LAMBDA_DOMAIN && !M0036_RC_IMPROVEMENT
    106106  m_LCUPredictionSAD = 0;
    107107  m_addSADDepth      = 0;
    … …  
    256256  m_ppcTempCU[0]->initCU( rpcCU->getPic(), rpcCU->getAddr() );
    257257
    258 #if RATE_CONTROL_LAMBDA_DOMAIN
     258#if RATE_CONTROL_LAMBDA_DOMAIN && !M0036_RC_IMPROVEMENT
    259259  m_addSADDepth      = 0;
    260260  m_LCUPredictionSAD = 0;
    … …  
    592592    }
    593593
    594 #if RATE_CONTROL_LAMBDA_DOMAIN
     594#if RATE_CONTROL_LAMBDA_DOMAIN && !M0036_RC_IMPROVEMENT
    595595    if ( uiDepth <= m_addSADDepth )
    596596    {
    … …  
    862862  {
    863863    bBoundary = true;
    864 #if RATE_CONTROL_LAMBDA_DOMAIN
     864#if RATE_CONTROL_LAMBDA_DOMAIN && !M0036_RC_IMPROVEMENT
    865865    m_addSADDepth++;
    866866#endif
    … …  
    13481348}
    13491349
     1350#if RATE_CONTROL_INTRA
     1351Int xCalcHADs8x8_ISlice(Pel *piOrg, Int iStrideOrg)
     1352{
     1353  Int k, i, j, jj;
     1354  Int diff[64], m1[8][8], m2[8][8], m3[8][8], iSumHad = 0;
     1355
     1356  for( k = 0; k < 64; k += 8 )
     1357  {
     1358    diff[k+0] = piOrg[0] ;
     1359    diff[k+1] = piOrg[1] ;
     1360    diff[k+2] = piOrg[2] ;
     1361    diff[k+3] = piOrg[3] ;
     1362    diff[k+4] = piOrg[4] ;
     1363    diff[k+5] = piOrg[5] ;
     1364    diff[k+6] = piOrg[6] ;
     1365    diff[k+7] = piOrg[7] ;
     1366 
     1367    piOrg += iStrideOrg;
     1368  }
     1369 
     1370  //horizontal
     1371  for (j=0; j < 8; j++)
     1372  {
     1373    jj = j << 3;
     1374    m2[j][0] = diff[jj  ] + diff[jj+4];
     1375    m2[j][1] = diff[jj+1] + diff[jj+5];
     1376    m2[j][2] = diff[jj+2] + diff[jj+6];
     1377    m2[j][3] = diff[jj+3] + diff[jj+7];
     1378    m2[j][4] = diff[jj  ] - diff[jj+4];
     1379    m2[j][5] = diff[jj+1] - diff[jj+5];
     1380    m2[j][6] = diff[jj+2] - diff[jj+6];
     1381    m2[j][7] = diff[jj+3] - diff[jj+7];
     1382   
     1383    m1[j][0] = m2[j][0] + m2[j][2];
     1384    m1[j][1] = m2[j][1] + m2[j][3];
     1385    m1[j][2] = m2[j][0] - m2[j][2];
     1386    m1[j][3] = m2[j][1] - m2[j][3];
     1387    m1[j][4] = m2[j][4] + m2[j][6];
     1388    m1[j][5] = m2[j][5] + m2[j][7];
     1389    m1[j][6] = m2[j][4] - m2[j][6];
     1390    m1[j][7] = m2[j][5] - m2[j][7];
     1391   
     1392    m2[j][0] = m1[j][0] + m1[j][1];
     1393    m2[j][1] = m1[j][0] - m1[j][1];
     1394    m2[j][2] = m1[j][2] + m1[j][3];
     1395    m2[j][3] = m1[j][2] - m1[j][3];
     1396    m2[j][4] = m1[j][4] + m1[j][5];
     1397    m2[j][5] = m1[j][4] - m1[j][5];
     1398    m2[j][6] = m1[j][6] + m1[j][7];
     1399    m2[j][7] = m1[j][6] - m1[j][7];
     1400  }
     1401 
     1402  //vertical
     1403  for (i=0; i < 8; i++)
     1404  {
     1405    m3[0][i] = m2[0][i] + m2[4][i];
     1406    m3[1][i] = m2[1][i] + m2[5][i];
     1407    m3[2][i] = m2[2][i] + m2[6][i];
     1408    m3[3][i] = m2[3][i] + m2[7][i];
     1409    m3[4][i] = m2[0][i] - m2[4][i];
     1410    m3[5][i] = m2[1][i] - m2[5][i];
     1411    m3[6][i] = m2[2][i] - m2[6][i];
     1412    m3[7][i] = m2[3][i] - m2[7][i];
     1413   
     1414    m1[0][i] = m3[0][i] + m3[2][i];
     1415    m1[1][i] = m3[1][i] + m3[3][i];
     1416    m1[2][i] = m3[0][i] - m3[2][i];
     1417    m1[3][i] = m3[1][i] - m3[3][i];
     1418    m1[4][i] = m3[4][i] + m3[6][i];
     1419    m1[5][i] = m3[5][i] + m3[7][i];
     1420    m1[6][i] = m3[4][i] - m3[6][i];
     1421    m1[7][i] = m3[5][i] - m3[7][i];
     1422   
     1423    m2[0][i] = m1[0][i] + m1[1][i];
     1424    m2[1][i] = m1[0][i] - m1[1][i];
     1425    m2[2][i] = m1[2][i] + m1[3][i];
     1426    m2[3][i] = m1[2][i] - m1[3][i];
     1427    m2[4][i] = m1[4][i] + m1[5][i];
     1428    m2[5][i] = m1[4][i] - m1[5][i];
     1429    m2[6][i] = m1[6][i] + m1[7][i];
     1430    m2[7][i] = m1[6][i] - m1[7][i];
     1431  }
     1432 
     1433  for (i = 0; i < 8; i++)
     1434  {
     1435    for (j = 0; j < 8; j++)
     1436    {
     1437      iSumHad += abs(m2[i][j]);
     1438    }
     1439  }
     1440  iSumHad -= abs(m2[0][0]);
     1441  iSumHad =(iSumHad+2)>>2;
     1442  return(iSumHad);
     1443}
     1444
     1445Int  TEncCu::updateLCUDataISlice(TComDataCU* pcCU, Int LCUIdx, Int width, Int height)
     1446{
     1447  Int  xBl, yBl;
     1448  const Int iBlkSize = 8;
     1449
     1450  Pel* pOrgInit   = pcCU->getPic()->getPicYuvOrg()->getLumaAddr(pcCU->getAddr(), 0);
     1451  Int  iStrideOrig = pcCU->getPic()->getPicYuvOrg()->getStride();
     1452  Pel  *pOrg;
     1453
     1454  Int iSumHad = 0;
     1455  for ( yBl=0; (yBl+iBlkSize)<=height; yBl+= iBlkSize)
     1456  {
     1457    for ( xBl=0; (xBl+iBlkSize)<=width; xBl+= iBlkSize)
     1458    {
     1459      pOrg = pOrgInit + iStrideOrig*yBl + xBl;
     1460      iSumHad += xCalcHADs8x8_ISlice(pOrg, iStrideOrig);
     1461    }
     1462  }
     1463  return(iSumHad);
     1464}
     1465#endif
     1466
    13501467/** check RD costs for a CU block encoded with merge
    13511468 * \param rpcBestCU
    … …  
    13601477  UChar uhInterDirNeighbours[MRG_MAX_NUM_CANDS_MEM];
    13611478#else
    1362   TComMvField  cMvFieldNeighbours[MRG_MAX_NUM_CANDS << 1]; // double length for mv of both lists
     1479  TComMvField  cMvFieldNeighbours[2 * MRG_MAX_NUM_CANDS]; // double length for mv of both lists
    13631480  UChar uhInterDirNeighbours[MRG_MAX_NUM_CANDS];
    13641481#endif
    … …  
    14001517  Int mergeCandBuffer[MRG_MAX_NUM_CANDS];
    14011518#endif
    1402   for( UInt ui = 0; ui < rpcTempCU->getSlice()->getMaxNumMergeCand(); ++ui )
     1519for( UInt ui = 0; ui < numValidMergeCand; ++ui )
    14031520  {
    14041521    mergeCandBuffer[ui] = 0;
    … …  
    14301547  {
    14311548    for( UInt uiMergeCand = 0; uiMergeCand < numValidMergeCand; ++uiMergeCand )
    1432     {
    1433       {
     1549    {     
    14341550#if H_3D_IC
    14351551        if( rpcTempCU->getSlice()->getApplyIC() && rpcTempCU->getSlice()->getIcSkipParseFlag() )
    … …  
    14431559        if(!(uiNoResidual==1 && mergeCandBuffer[uiMergeCand]==1))
    14441560        {
    1445 
    14461561        if( !(bestIsSkip && uiNoResidual == 0) )
    14471562        {
    … …  
    14871602       m_pcPredSearch->motionCompensation ( rpcTempCU, m_ppcPredYuvTemp[uhDepth] );
    14881603       // estimate residual and encode everything
    1489 
    14901604#if H_3D_VSO //M2
    14911605       if( m_pcRdCost->getUseRenModel() )
    … …  
    14981612       }
    14991613#endif
    1500 
    15011614       m_pcPredSearch->encodeResAndCalcRdInterCU( rpcTempCU,
    15021615         m_ppcOrigYuv    [uhDepth],
    … …  
    15081621
    15091622
    1510        if(uiNoResidual==0)
    1511        {
    1512          if(rpcTempCU->getQtRootCbf(0) == 0)
     1623          if ( uiNoResidual == 0 && rpcTempCU->getQtRootCbf(0) == 0 )
    15131624         {
     1625            // If no residual when allowing for one, then set mark to not try case where residual is forced to 0
    15141626           mergeCandBuffer[uiMergeCand] = 1;
    15151627         }
    1516        }
    1517 
    1518        rpcTempCU->setSkipFlagSubParts( rpcTempCU->getQtRootCbf(0) == 0, 0, uhDepth );
     1628
     1629          rpcTempCU->setSkipFlagSubParts( rpcTempCU->getQtRootCbf(0) == 0, 0, uhDepth );
    15191630          Int orgQP = rpcTempCU->getQP( 0 );
    15201631          xCheckDQP( rpcTempCU );
    … …  
    15221633          rpcTempCU->initEstData( uhDepth, orgQP );
    15231634
    1524 
    15251635      if( m_pcEncCfg->getUseFastDecisionForMerge() && !bestIsSkip )
    15261636      {
    15271637        bestIsSkip = rpcBestCU->getQtRootCbf(0) == 0;
    15281638      }
    1529 
    1530     }
    15311639    }
    15321640   }
    … …  
    16891797#endif
    16901798
    1691 #if RATE_CONTROL_LAMBDA_DOMAIN
     1799#if RATE_CONTROL_LAMBDA_DOMAIN && !M0036_RC_IMPROVEMENT
    16921800  if ( m_pcEncCfg->getUseRateCtrl() && m_pcEncCfg->getLCULevelRC() && ePartSize == SIZE_2Nx2N && uhDepth <= m_addSADDepth )
    16931801  {

  • branches/HTM-DEV-0.3-dev2/source/Lib/TLibEncoder/TEncCu.h

    r504 r537  
    102102  Bool                    m_bUseSBACRD;
    103103  TEncRateCtrl*           m_pcRateCtrl;
    104 #if RATE_CONTROL_LAMBDA_DOMAIN
     104#if RATE_CONTROL_LAMBDA_DOMAIN && !M0036_RC_IMPROVEMENT
    105105  UInt                    m_LCUPredictionSAD;
    106106  Int                     m_addSADDepth;
    … …  
    124124 
    125125  Void setBitCounter        ( TComBitCounter* pcBitCounter ) { m_pcBitCounter = pcBitCounter; }
    126 #if RATE_CONTROL_LAMBDA_DOMAIN
     126#if RATE_CONTROL_LAMBDA_DOMAIN && !M0036_RC_IMPROVEMENT
    127127  UInt getLCUPredictionSAD() { return m_LCUPredictionSAD; }
     128#endif
     129#if RATE_CONTROL_INTRA
     130  Int   updateLCUDataISlice ( TComDataCU* pcCU, Int LCUIdx, Int width, Int height );
    128131#endif
    129132protected:

  • branches/HTM-DEV-0.3-dev2/source/Lib/TLibEncoder/TEncGOP.cpp

    r534 r537  
    9494  m_cpbRemovalDelay   = 0;
    9595  m_lastBPSEI         = 0;
    96 #if L0045_NON_NESTED_SEI_RESTRICTIONS
    9796  xResetNonNestedSEIPresentFlags();
    98 #if K0180_SCALABLE_NESTING_SEI
    9997  xResetNestedSEIPresentFlags();
    100 #endif
    101 #endif
    10298#if H_MV
    10399  m_layerId      = 0;
    … …  
    163159  SEIActiveParameterSets *seiActiveParameterSets = new SEIActiveParameterSets();
    164160  seiActiveParameterSets->activeVPSId = m_pcCfg->getVPS()->getVPSId();
    165 #if L0047_APS_FLAGS
    166161  seiActiveParameterSets->m_fullRandomAccessFlag = false;
    167162  seiActiveParameterSets->m_noParamSetUpdateFlag = false;
    168 #endif
    169163  seiActiveParameterSets->numSpsIdsMinus1 = 0;
    170164  seiActiveParameterSets->activeSeqParamSetId.resize(seiActiveParameterSets->numSpsIdsMinus1 + 1);
    … …  
    179173  seiFramePacking->m_arrangementCancelFlag = 0;
    180174  seiFramePacking->m_arrangementType = m_pcCfg->getFramePackingArrangementSEIType();
    181 #if L0444_FPA_TYPE
    182175  assert((seiFramePacking->m_arrangementType > 2) && (seiFramePacking->m_arrangementType < 6) );
    183 #endif
    184176  seiFramePacking->m_quincunxSamplingFlag = m_pcCfg->getFramePackingArrangementSEIQuincunx();
    185177  seiFramePacking->m_contentInterpretationType = m_pcCfg->getFramePackingArrangementSEIInterpretation();
    … …  
    195187  seiFramePacking->m_frame1GridPositionY = 0;
    196188  seiFramePacking->m_arrangementReservedByte = 0;
    197 #if L0045_PERSISTENCE_FLAGS
    198189  seiFramePacking->m_arrangementPersistenceFlag = true;
    199 #else
    200   seiFramePacking->m_arrangementRepetetionPeriod = 1;
    201 #endif
    202190  seiFramePacking->m_upsampledAspectRatio = 0;
    203191  return seiFramePacking;
    … …  
    214202}
    215203
    216 #if J0149_TONE_MAPPING_SEI
    217204SEIToneMappingInfo*  TEncGOP::xCreateSEIToneMappingInfo()
    218205{
    … …  
    225212  assert(seiToneMappingInfo->m_codedDataBitDepth >= 8 && seiToneMappingInfo->m_codedDataBitDepth <= 14);
    226213  seiToneMappingInfo->m_targetBitDepth = m_pcCfg->getTMISEITargetBitDepth();
    227   assert( (seiToneMappingInfo->m_targetBitDepth >= 1 && seiToneMappingInfo->m_targetBitDepth <= 17) || (seiToneMappingInfo->m_targetBitDepth  == 255) );
     214  assert( seiToneMappingInfo->m_targetBitDepth >= 1 && seiToneMappingInfo->m_targetBitDepth <= 17 );
    228215  seiToneMappingInfo->m_modelId = m_pcCfg->getTMISEIModelID();
    229216  assert(seiToneMappingInfo->m_modelId >=0 &&seiToneMappingInfo->m_modelId<=4);
    … …  
    300287  return seiToneMappingInfo;
    301288}
    302 #endif
     289
    303290Void TEncGOP::xCreateLeadingSEIMessages (/*SEIMessages seiMessages,*/ AccessUnit &accessUnit, TComSPS *sps)
    304291{
    … …  
    315302    accessUnit.push_back(new NALUnitEBSP(nalu));
    316303    delete sei;
    317 #if L0045_NON_NESTED_SEI_RESTRICTIONS
    318304    m_activeParameterSetSEIPresentInAU = true;
    319 #endif
    320305  }
    321306
    … …  
    342327    delete sei;
    343328  }
    344 #if J0149_TONE_MAPPING_SEI
    345329  if(m_pcCfg->getToneMappingInfoSEIEnabled())
    346330  {
    … …  
    354338    delete sei;
    355339  }
    356 #endif
    357340}
    358341
    … …  
    389372#endif
    390373  SEIPictureTiming pictureTimingSEI;
    391 #if L0208_SOP_DESCRIPTION_SEI
    392374  Bool writeSOP = m_pcCfg->getSOPDescriptionSEIEnabled();
    393 #endif
    394 #if K0180_SCALABLE_NESTING_SEI
    395375  // Initialize Scalable Nesting SEI with single layer values
    396376  SEIScalableNesting scalableNestingSEI;
    … …  
    403383  scalableNestingSEI.m_nestingLayerId[0]             = 0;
    404384  scalableNestingSEI.m_callerOwnsSEIs                = true;
    405 #endif
    406 #if L0044_DU_DPB_OUTPUT_DELAY_HRD
    407385  Int picSptDpbOutputDuDelay = 0;
    408 #endif
    409386  UInt *accumBitsDU = NULL;
    410387  UInt *accumNalsDU = NULL;
    … …  
    596573    pcSlice->getRPS()->setNumberOfLongtermPictures(0);
    597574
    598 #if FIX1071 && H_MV_FIX1071
     575#if FIX1071
    599576    if ((pcSlice->checkThatAllRefPicsAreAvailable(rcListPic, pcSlice->getRPS(), false) != 0) || (pcSlice->isIRAP()))
    600577    {
    … …  
    772749    }
    773750#endif
    774 #if !L0034_COMBINED_LIST_CLEANUP
    775     if (pcSlice->getSliceType() != B_SLICE || !pcSlice->getSPS()->getUseLComb())
    776     {
    777       pcSlice->setNumRefIdx(REF_PIC_LIST_C, 0);
    778       pcSlice->setRefPicListCombinationFlag(false);
    779       pcSlice->setRefPicListModificationFlagLC(false);
    780     }
    781     else
    782     {
    783       pcSlice->setRefPicListCombinationFlag(pcSlice->getSPS()->getUseLComb());
    784       pcSlice->setNumRefIdx(REF_PIC_LIST_C, pcSlice->getNumRefIdx(REF_PIC_LIST_0));
    785     }
    786 #endif
    787 
    788751    if (pcSlice->getSliceType() == B_SLICE)
    789752    {
    … …  
    820783    pcSlice->setRefPOCList();
    821784
    822 #if L0034_COMBINED_LIST_CLEANUP
    823785    pcSlice->setList1IdxToList0Idx();
    824 #else
    825     pcSlice->setNoBackPredFlag( false );
    826     if ( pcSlice->getSliceType() == B_SLICE && !pcSlice->getRefPicListCombinationFlag())
    827     {
    828       if ( pcSlice->getNumRefIdx(RefPicList( 0 ) ) == pcSlice->getNumRefIdx(RefPicList( 1 ) ) )
    829       {
    830         pcSlice->setNoBackPredFlag( true );
    831         Int i;
    832         for ( i=0; i < pcSlice->getNumRefIdx(RefPicList( 1 ) ); i++ )
    833         {
    834           if ( pcSlice->getRefPOC(RefPicList(1), i) != pcSlice->getRefPOC(RefPicList(0), i) )
    835           {
    836             pcSlice->setNoBackPredFlag( false );
    837             break;
    838           }
    839         }
    840       }
    841     }
    842 
    843     if(pcSlice->getNoBackPredFlag())
    844     {
    845       pcSlice->setNumRefIdx(REF_PIC_LIST_C, 0);
    846     }
    847     pcSlice->generateCombinedList();
    848 #endif
    849786#if H_3D_TMVP
    850787    if(pcSlice->getLayerId())
    … …  
    943880
    944881#if RATE_CONTROL_LAMBDA_DOMAIN
    945     Int sliceQP              = pcSlice->getSliceQp();
    946882    Double lambda            = 0.0;
    947883    Int actualHeadBits       = 0;
    … …  
    959895      estimatedBits = m_pcRateCtrl->getRCPic()->getTargetBits();
    960896
     897      Int sliceQP = m_pcCfg->getInitialQP();
    961898      if ( ( pcSlice->getPOC() == 0 && m_pcCfg->getInitialQP() > 0 ) || ( frameLevel == 0 && m_pcCfg->getForceIntraQP() ) ) // QP is specified
    962899      {
    963         sliceQP              = m_pcCfg->getInitialQP();
    964900        Int    NumberBFrames = ( m_pcCfg->getGOPSize() - 1 );
    965901        Double dLambda_scale = 1.0 - Clip3( 0.0, 0.5, 0.05*(Double)NumberBFrames );
    … …  
    972908      else if ( frameLevel == 0 )   // intra case, but use the model
    973909      {
     910#if RATE_CONTROL_INTRA
     911        m_pcSliceEncoder->calCostSliceI(pcPic);
     912#endif
    974913        if ( m_pcCfg->getIntraPeriod() != 1 )   // do not refine allocated bits for all intra case
    975914        {
    976915          Int bits = m_pcRateCtrl->getRCSeq()->getLeftAverageBits();
     916#if RATE_CONTROL_INTRA
     917          bits = m_pcRateCtrl->getRCPic()->getRefineBitsForIntra( bits );
     918#else
    977919          bits = m_pcRateCtrl->getRCSeq()->getRefineBitsForIntra( bits );
     920#endif
    978921          if ( bits < 200 )
    979922          {
    … …  
    984927
    985928        list<TEncRCPic*> listPreviousPicture = m_pcRateCtrl->getPicList();
     929#if RATE_CONTROL_INTRA
     930        m_pcRateCtrl->getRCPic()->getLCUInitTargetBits();
     931        lambda  = m_pcRateCtrl->getRCPic()->estimatePicLambda( listPreviousPicture, pcSlice->getSliceType());
     932#else
    986933        lambda  = m_pcRateCtrl->getRCPic()->estimatePicLambda( listPreviousPicture );
     934#endif
    987935        sliceQP = m_pcRateCtrl->getRCPic()->estimatePicQP( lambda, listPreviousPicture );
    988936      }
    … …  
    990938      {
    991939        list<TEncRCPic*> listPreviousPicture = m_pcRateCtrl->getPicList();
     940#if RATE_CONTROL_INTRA
     941        lambda  = m_pcRateCtrl->getRCPic()->estimatePicLambda( listPreviousPicture, pcSlice->getSliceType());
     942#else
    992943        lambda  = m_pcRateCtrl->getRCPic()->estimatePicLambda( listPreviousPicture );
     944#endif
    993945        sliceQP = m_pcRateCtrl->getRCPic()->estimatePicQP( lambda, listPreviousPicture );
    994946      }
    … …  
    11991151    Bool bLFCrossTileBoundary = pcSlice->getPPS()->getLoopFilterAcrossTilesEnabledFlag();
    12001152    m_pcLoopFilter->setCfg(bLFCrossTileBoundary);
    1201 #if L0386_DB_METRIC
    12021153    if ( m_pcCfg->getDeblockingFilterMetric() )
    12031154    {
    12041155      dblMetric(pcPic, uiNumSlices);
    12051156    }
    1206 #endif
    12071157    m_pcLoopFilter->loopFilterPic( pcPic );
    12081158
    … …  
    12671217        UInt maxCU = m_pcCfg->getSliceArgument() >> ( pcSlice->getSPS()->getMaxCUDepth() << 1);
    12681218        UInt numDU = ( m_pcCfg->getSliceMode() == 1 ) ? ( pcPic->getNumCUsInFrame() / maxCU ) : ( 0 );
    1269         if( pcPic->getNumCUsInFrame() % maxCU != 0 )
     1219        if( pcPic->getNumCUsInFrame() % maxCU != 0 || numDU == 0 )
    12701220        {
    12711221          numDU ++;
    … …  
    13071257    }
    13081258
    1309 #if L0208_SOP_DESCRIPTION_SEI
    13101259    if (writeSOP) // write SOP description SEI (if enabled) at the beginning of GOP
    13111260    {
    … …  
    13451294      writeSOP = false;
    13461295    }
    1347 #endif
    13481296
    13491297    if( ( m_pcCfg->getPictureTimingSEIEnabled() || m_pcCfg->getDecodingUnitInfoSEIEnabled() ) &&
    … …  
    13771325      pictureTimingSEI.m_auCpbRemovalDelay = std::max<Int>(1, m_totalCoded - m_lastBPSEI); // Syntax element signalled as minus, hence the .
    13781326      pictureTimingSEI.m_picDpbOutputDelay = pcSlice->getSPS()->getNumReorderPics(0) + pcSlice->getPOC() - m_totalCoded;
    1379 #if L0044_DU_DPB_OUTPUT_DELAY_HRD
    13801327      Int factor = pcSlice->getSPS()->getVuiParameters()->getHrdParameters()->getTickDivisorMinus2() + 2;
    13811328      pictureTimingSEI.m_picDpbOutputDuDelay = factor * pictureTimingSEI.m_picDpbOutputDelay;
    … …  
    13841331        picSptDpbOutputDuDelay = factor * pictureTimingSEI.m_picDpbOutputDelay;
    13851332      }
    1386 #endif
    13871333    }
    13881334
    … …  
    14041350      sei_buffering_period.m_initialCpbRemovalDelayOffset[0][1]     = uiInitialCpbRemovalDelay;
    14051351
    1406 #if L0043_TIMING_INFO
    14071352      Double dTmp = (Double)pcSlice->getSPS()->getVuiParameters()->getTimingInfo()->getNumUnitsInTick() / (Double)pcSlice->getSPS()->getVuiParameters()->getTimingInfo()->getTimeScale();
    1408 #else
    1409       Double dTmp = (Double)pcSlice->getSPS()->getVuiParameters()->getHrdParameters()->getNumUnitsInTick() / (Double)pcSlice->getSPS()->getVuiParameters()->getHrdParameters()->getTimeScale();
    1410 #endif
    14111353
    14121354      UInt uiTmp = (UInt)( dTmp * 90000.0 );
    … …  
    14191361
    14201362      sei_buffering_period.m_rapCpbParamsPresentFlag              = 0;
    1421 #if L0328_SPLICING
    14221363      //for the concatenation, it can be set to one during splicing.
    14231364      sei_buffering_period.m_concatenationFlag = 0;
    14241365      //since the temporal layer HRD is not ready, we assumed it is fixed
    14251366      sei_buffering_period.m_auCpbRemovalDelayDelta = 1;
    1426 #endif
    1427 #if L0044_CPB_DPB_DELAY_OFFSET
    14281367      sei_buffering_period.m_cpbDelayOffset = 0;
    14291368      sei_buffering_period.m_dpbDelayOffset = 0;
    1430 #endif
    14311369
    14321370      m_seiWriter.writeSEImessage( nalu.m_Bitstream, sei_buffering_period, pcSlice->getSPS());
    14331371      writeRBSPTrailingBits(nalu.m_Bitstream);
    1434 #if L0045_NON_NESTED_SEI_RESTRICTIONS
    14351372      {
    14361373      UInt seiPositionInAu = xGetFirstSeiLocation(accessUnit);
    … …  
    14441381      m_bufferingPeriodSEIPresentInAU = true;
    14451382      }
    1446 #else
    1447       accessUnit.push_back(new NALUnitEBSP(nalu));
    1448 #endif
    1449 
    1450 #if K0180_SCALABLE_NESTING_SEI
     1383
    14511384      if (m_pcCfg->getScalableNestingSEIEnabled())
    14521385      {
    … …  
    14581391        m_seiWriter.writeSEImessage( naluTmp.m_Bitstream, scalableNestingSEI, pcSlice->getSPS());
    14591392        writeRBSPTrailingBits(naluTmp.m_Bitstream);
    1460 #if L0045_NON_NESTED_SEI_RESTRICTIONS
    14611393        UInt seiPositionInAu = xGetFirstSeiLocation(accessUnit);
    14621394        UInt offsetPosition = m_activeParameterSetSEIPresentInAU + m_bufferingPeriodSEIPresentInAU + m_pictureTimingSEIPresentInAU;   // Insert BP SEI after non-nested APS, BP and PT SEIs
    … …  
    14681400        accessUnit.insert(it, new NALUnitEBSP(naluTmp));
    14691401        m_nestedBufferingPeriodSEIPresentInAU = true;
    1470 #else
    1471         accessUnit.push_back(new NALUnitEBSP(naluTmp));
    1472 #endif
    1473       }
    1474 #endif
     1402      }
    14751403
    14761404      m_lastBPSEI = m_totalCoded;
    … …  
    19351863      if ( m_pcCfg->getUseRateCtrl() )
    19361864      {
     1865#if !M0036_RC_IMPROVEMENT
    19371866        Double effectivePercentage = m_pcRateCtrl->getRCPic()->getEffectivePercentage();
     1867#endif
    19381868        Double avgQP     = m_pcRateCtrl->getRCPic()->calAverageQP();
    19391869        Double avgLambda = m_pcRateCtrl->getRCPic()->calAverageLambda();
    … …  
    19421872          avgLambda = lambda;
    19431873        }
     1874#if M0036_RC_IMPROVEMENT
     1875#if RATE_CONTROL_INTRA
     1876        m_pcRateCtrl->getRCPic()->updateAfterPicture( actualHeadBits, actualTotalBits, avgQP, avgLambda, pcSlice->getSliceType());
     1877#else
     1878        m_pcRateCtrl->getRCPic()->updateAfterPicture( actualHeadBits, actualTotalBits, avgQP, avgLambda );
     1879#endif
     1880#else
    19441881        m_pcRateCtrl->getRCPic()->updateAfterPicture( actualHeadBits, actualTotalBits, avgQP, avgLambda, effectivePercentage );
     1882#endif
    19451883        m_pcRateCtrl->getRCPic()->addToPictureLsit( m_pcRateCtrl->getPicList() );
    19461884
    … …  
    19621900      }
    19631901#endif
     1902
    19641903      if( ( m_pcCfg->getPictureTimingSEIEnabled() || m_pcCfg->getDecodingUnitInfoSEIEnabled() ) &&
    19651904          ( pcSlice->getSPS()->getVuiParametersPresentFlag() ) &&
    … …  
    19961935            for( i = ( numDU - 2 ); i >= 0; i -- )
    19971936            {
    1998 #if L0043_TIMING_INFO
    19991937              ui64Tmp = ( ( ( accumBitsDU[ numDU - 1 ]  - accumBitsDU[ i ] ) * ( vui->getTimingInfo()->getTimeScale() / vui->getTimingInfo()->getNumUnitsInTick() ) * ( hrd->getTickDivisorMinus2() + 2 ) ) / ( m_pcCfg->getTargetBitrate() ) );
    2000 #else
    2001               ui64Tmp = ( ( ( accumBitsDU[ numDU - 1 ]  - accumBitsDU[ i ] ) * ( hrd->getTimeScale() / hrd->getNumUnitsInTick() ) * ( hrd->getTickDivisorMinus2() + 2 ) ) / ( m_pcCfg->getTargetBitrate() ) );
    2002 #endif
    20031938              if( (UInt)ui64Tmp > maxDiff )
    20041939              {
    … …  
    20121947            {
    20131948              flag = 0;
    2014 #if L0043_TIMING_INFO
    20151949              ui64Tmp = ( ( ( accumBitsDU[ numDU - 1 ]  - accumBitsDU[ i ] ) * ( vui->getTimingInfo()->getTimeScale() / vui->getTimingInfo()->getNumUnitsInTick() ) * ( hrd->getTickDivisorMinus2() + 2 ) ) / ( m_pcCfg->getTargetBitrate() ) );
    2016 #else
    2017               ui64Tmp = ( ( ( accumBitsDU[ numDU - 1 ]  - accumBitsDU[ i ] ) * ( hrd->getTimeScale() / hrd->getNumUnitsInTick() ) * ( hrd->getTickDivisorMinus2() + 2 ) ) / ( m_pcCfg->getTargetBitrate() ) );
    2018 #endif
    20191950
    20201951              if( (UInt)ui64Tmp > maxDiff )
    … …  
    20481979          m_seiWriter.writeSEImessage(nalu.m_Bitstream, pictureTimingSEI, pcSlice->getSPS());
    20491980          writeRBSPTrailingBits(nalu.m_Bitstream);
    2050 #if L0045_NON_NESTED_SEI_RESTRICTIONS
    20511981          UInt seiPositionInAu = xGetFirstSeiLocation(accessUnit);
    20521982          UInt offsetPosition = m_activeParameterSetSEIPresentInAU
    … …  
    20591989          accessUnit.insert(it, new NALUnitEBSP(nalu));
    20601990          m_pictureTimingSEIPresentInAU = true;
    2061 #else
    2062           AccessUnit::iterator it = find_if(accessUnit.begin(), accessUnit.end(), mem_fun(&NALUnit::isSlice));
    2063           accessUnit.insert(it, new NALUnitEBSP(nalu));
    2064 #endif
    2065         }
    2066 #if K0180_SCALABLE_NESTING_SEI
     1991        }
    20671992          if ( m_pcCfg->getScalableNestingSEIEnabled() ) // put picture timing SEI into scalable nesting SEI
    20681993          {
    … …  
    20731998            m_seiWriter.writeSEImessage(nalu.m_Bitstream, scalableNestingSEI, pcSlice->getSPS());
    20741999            writeRBSPTrailingBits(nalu.m_Bitstream);
    2075 #if L0045_NON_NESTED_SEI_RESTRICTIONS
    20762000            UInt seiPositionInAu = xGetFirstSeiLocation(accessUnit);
    20772001            UInt offsetPosition = m_activeParameterSetSEIPresentInAU
    … …  
    20842008            accessUnit.insert(it, new NALUnitEBSP(nalu));
    20852009            m_nestedPictureTimingSEIPresentInAU = true;
    2086 #else
    2087             AccessUnit::iterator it = find_if(accessUnit.begin(), accessUnit.end(), mem_fun(&NALUnit::isSlice));
    2088             accessUnit.insert(it, new NALUnitEBSP(nalu));
    2089 #endif
    20902010          }
    2091 #endif
    2092 
    20932011        }
    20942012        if( m_pcCfg->getDecodingUnitInfoSEIEnabled() && hrd->getSubPicCpbParamsPresentFlag() )
    … …  
    21022020            tempSEI.m_decodingUnitIdx = i;
    21032021            tempSEI.m_duSptCpbRemovalDelay = pictureTimingSEI.m_duCpbRemovalDelayMinus1[i] + 1;
    2104 #if L0044_DU_DPB_OUTPUT_DELAY_HRD
    21052022            tempSEI.m_dpbOutputDuDelayPresentFlag = false;
    21062023            tempSEI.m_picSptDpbOutputDuDelay = picSptDpbOutputDuDelay;
    2107 #endif
    21082024
    21092025            AccessUnit::iterator it;
    … …  
    21152031              writeRBSPTrailingBits(nalu.m_Bitstream);
    21162032
    2117 #if L0045_NON_NESTED_SEI_RESTRICTIONS
    21182033              UInt seiPositionInAu = xGetFirstSeiLocation(accessUnit);
    21192034              UInt offsetPosition = m_activeParameterSetSEIPresentInAU
    … …  
    21252040              }
    21262041              accessUnit.insert(it, new NALUnitEBSP(nalu));
    2127 #else
    2128               it = find_if(accessUnit.begin(), accessUnit.end(), mem_fun(&NALUnit::isSlice));
    2129               accessUnit.insert(it, new NALUnitEBSP(nalu));
    2130 #endif
    21312042            }
    21322043            else
    … …  
    21542065        }
    21552066      }
    2156 #if L0045_NON_NESTED_SEI_RESTRICTIONS
    21572067      xResetNonNestedSEIPresentFlags();
    2158 #if K0180_SCALABLE_NESTING_SEI
    21592068      xResetNestedSEIPresentFlags();
    2160 #endif
    2161 #endif
    21622069      pcPic->getPicYuvRec()->copyToPic(pcPicYuvRecOut);
    21632070
    … …  
    28512758}
    28522759
    2853 #if L0045_NON_NESTED_SEI_RESTRICTIONS
    28542760/** Function for finding the position to insert the first of APS and non-nested BP, PT, DU info SEI messages.
    28552761 * \param accessUnit Access Unit of the current picture
    … …  
    28712777  return seiStartPos;
    28722778}
    2873 #endif
    2874 
    2875 #if L0386_DB_METRIC
     2779
    28762780Void TEncGOP::dblMetric( TComPic* pcPic, UInt uiNumSlices )
    28772781{
    … …  
    28872791  const UInt noCol = (picWidth>>log2maxTB);
    28882792  const UInt noRows = (picHeight>>log2maxTB);
     2793  assert(noCol > 1);
     2794  assert(noRows > 1);
    28892795  UInt64 *colSAD = (UInt64*)malloc(noCol*sizeof(UInt64));
    28902796  UInt64 *rowSAD = (UInt64*)malloc(noRows*sizeof(UInt64));
    … …  
    29952901  free(rowSAD);
    29962902}
    2997 #endif
     2903
    29982904#if H_MV
    29992905Void TEncGOP::xSetRefPicListModificationsMv( TComSlice* pcSlice, UInt iGOPid )

  • branches/HTM-DEV-0.3-dev2/source/Lib/TLibEncoder/TEncGOP.h

    r534 r537  
    128128  UInt                    m_tl0Idx;
    129129  UInt                    m_rapIdx;
    130 #if L0045_NON_NESTED_SEI_RESTRICTIONS
    131130  Bool                    m_activeParameterSetSEIPresentInAU;
    132131  Bool                    m_bufferingPeriodSEIPresentInAU;
    133132  Bool                    m_pictureTimingSEIPresentInAU;
    134 #if K0180_SCALABLE_NESTING_SEI
    135133  Bool                    m_nestedBufferingPeriodSEIPresentInAU;
    136134  Bool                    m_nestedPictureTimingSEIPresentInAU;
    137 #endif
    138 #endif
    139135public:
    140136  TEncGOP();
    … …  
    199195  SEIDisplayOrientation*  xCreateSEIDisplayOrientation();
    200196
    201 #if J0149_TONE_MAPPING_SEI
    202197  SEIToneMappingInfo*     xCreateSEIToneMappingInfo();
    203 #endif
    204198
    205199  Void xCreateLeadingSEIMessages (/*SEIMessages seiMessages,*/ AccessUnit &accessUnit, TComSPS *sps);
    206 #if L0045_NON_NESTED_SEI_RESTRICTIONS
    207200  Int xGetFirstSeiLocation (AccessUnit &accessUnit);
    208201  Void xResetNonNestedSEIPresentFlags()
    … …  
    212205    m_pictureTimingSEIPresentInAU      = false;
    213206  }
    214 #if K0180_SCALABLE_NESTING_SEI
    215207  Void xResetNestedSEIPresentFlags()
    216208  {
    … …  
    218210    m_nestedPictureTimingSEIPresentInAU      = false;
    219211  }
    220 #endif
    221 #endif
    222212#if H_MV
    223213   Void  xSetRefPicListModificationsMv( TComSlice* pcSlice, UInt iGOPid );
    224214#endif
    225 #if L0386_DB_METRIC
    226215  Void dblMetric( TComPic* pcPic, UInt uiNumSlices );
    227 #endif
    228216};// END CLASS DEFINITION TEncGOP
    229217

  • branches/HTM-DEV-0.3-dev2/source/Lib/TLibEncoder/TEncRateCtrl.cpp

    r324 r537  
    6767  m_bitsLeft            = 0;
    6868  m_useLCUSeparateModel = false;
     69#if M0036_RC_IMPROVEMENT
     70  m_adaptiveBit         = 0;
     71  m_lastLambda          = 0.0;
     72#endif
    6973}
    7074
    … …  
    7478}
    7579
     80#if M0036_RC_IMPROVEMENT
     81Void TEncRCSeq::create( Int totalFrames, Int targetBitrate, Int frameRate, Int GOPSize, Int picWidth, Int picHeight, Int LCUWidth, Int LCUHeight, Int numberOfLevel, Bool useLCUSeparateModel, Int adaptiveBit )
     82#else
    7683Void TEncRCSeq::create( Int totalFrames, Int targetBitrate, Int frameRate, Int GOPSize, Int picWidth, Int picHeight, Int LCUWidth, Int LCUHeight, Int numberOfLevel, Bool useLCUSeparateModel )
     84#endif
    7785{
    7886  destroy();
    … …  
    101109    m_betaUpdate  = 0.025;
    102110  }
    103   else
     111#if M0036_RC_IMPROVEMENT
     112  else if ( m_seqTargetBpp < 0.2 )
    104113  {
    105114    m_alphaUpdate = 0.1;
    106115    m_betaUpdate  = 0.05;
    107116  }
     117  else if ( m_seqTargetBpp < 0.5 )
     118  {
     119    m_alphaUpdate = 0.2;
     120    m_betaUpdate  = 0.1;
     121  }
     122  else
     123  {
     124    m_alphaUpdate = 0.4;
     125    m_betaUpdate  = 0.2;
     126  }
     127#else
     128  else
     129  {
     130    m_alphaUpdate = 0.1;
     131    m_betaUpdate  = 0.05;
     132  }
     133#endif
    108134  m_averageBits     = (Int)(m_targetBits / totalFrames);
    109135  Int picWidthInBU  = ( m_picWidth  % m_LCUWidth  ) == 0 ? m_picWidth  / m_LCUWidth  : m_picWidth  / m_LCUWidth  + 1;
    … …  
    146172  m_framesLeft = m_totalFrames;
    147173  m_bitsLeft   = m_targetBits;
     174#if M0036_RC_IMPROVEMENT
     175  m_adaptiveBit = adaptiveBit;
     176  m_lastLambda = 0.0;
     177#endif
    148178}
    149179
    … …  
    203233    for ( Int i=0; i<m_numberOfLevel; i++ )
    204234    {
     235#if RATE_CONTROL_INTRA
     236      if (i>0)
     237      {
     238        m_picPara[i].m_alpha = 3.2003;
     239        m_picPara[i].m_beta  = -1.367;
     240      }
     241      else
     242      {
     243        m_picPara[i].m_alpha = ALPHA;   
     244        m_picPara[i].m_beta  = BETA2;
     245      }
     246#else
    205247      m_picPara[i].m_alpha = 3.2003;
    206248      m_picPara[i].m_beta  = -1.367;
     249#endif
    207250    }
    208251  }
    … …  
    228271      for ( Int j=0; j<m_numberOfLCU; j++)
    229272      {
     273#if RATE_CONTROL_INTRA
     274        m_LCUPara[i][j].m_alpha = m_picPara[i].m_alpha;
     275        m_LCUPara[i][j].m_beta  = m_picPara[i].m_beta;
     276#else
    230277        m_LCUPara[i][j].m_alpha = 3.2003;
    231278        m_LCUPara[i][j].m_beta  = -1.367;
     279#endif
    232280      }
    233281    }
    … …  
    251299}
    252300
     301#if !RATE_CONTROL_INTRA
    253302Int TEncRCSeq::getRefineBitsForIntra( Int orgBits )
    254303{
    … …  
    264313  return orgBits * 10;
    265314}
     315#endif
     316
     317#if M0036_RC_IMPROVEMENT
     318Void TEncRCSeq::setAllBitRatio( Double basicLambda, Double* equaCoeffA, Double* equaCoeffB )
     319{
     320  Int* bitsRatio = new Int[m_GOPSize];
     321  for ( Int i=0; i<m_GOPSize; i++ )
     322  {
     323    bitsRatio[i] = (Int)( equaCoeffA[i] * pow( basicLambda, equaCoeffB[i] ) * m_numberOfPixel );
     324  }
     325  initBitsRatio( bitsRatio );
     326  delete[] bitsRatio;
     327}
     328#endif
    266329
    267330//GOP level
    … …  
    286349  Int targetBits = xEstGOPTargetBits( encRCSeq, numPic );
    287350
     351#if M0036_RC_IMPROVEMENT
     352  if ( encRCSeq->getAdaptiveBits() > 0 && encRCSeq->getLastLambda() > 0.1 )
     353  {
     354    Double targetBpp = (Double)targetBits / encRCSeq->getNumPixel();
     355    Double basicLambda = 0.0;
     356    Double* lambdaRatio = new Double[encRCSeq->getGOPSize()];
     357    Double* equaCoeffA = new Double[encRCSeq->getGOPSize()];
     358    Double* equaCoeffB = new Double[encRCSeq->getGOPSize()];
     359
     360    if ( encRCSeq->getAdaptiveBits() == 1 )   // for GOP size =4, low delay case
     361    {
     362      if ( encRCSeq->getLastLambda() < 120.0 )
     363      {
     364        lambdaRatio[1] = 0.725 * log( encRCSeq->getLastLambda() ) + 0.5793;
     365        lambdaRatio[0] = 1.3 * lambdaRatio[1];
     366        lambdaRatio[2] = 1.3 * lambdaRatio[1];
     367        lambdaRatio[3] = 1.0;
     368      }
     369      else
     370      {
     371        lambdaRatio[0] = 5.0;
     372        lambdaRatio[1] = 4.0;
     373        lambdaRatio[2] = 5.0;
     374        lambdaRatio[3] = 1.0;
     375      }
     376    }
     377    else if ( encRCSeq->getAdaptiveBits() == 2 )  // for GOP size = 8, random access case
     378    {
     379      if ( encRCSeq->getLastLambda() < 90.0 )
     380      {
     381        lambdaRatio[0] = 1.0;
     382        lambdaRatio[1] = 0.725 * log( encRCSeq->getLastLambda() ) + 0.7963;
     383        lambdaRatio[2] = 1.3 * lambdaRatio[1];
     384        lambdaRatio[3] = 3.25 * lambdaRatio[1];
     385        lambdaRatio[4] = 3.25 * lambdaRatio[1];
     386        lambdaRatio[5] = 1.3  * lambdaRatio[1];
     387        lambdaRatio[6] = 3.25 * lambdaRatio[1];
     388        lambdaRatio[7] = 3.25 * lambdaRatio[1];
     389      }
     390      else
     391      {
     392        lambdaRatio[0] = 1.0;
     393        lambdaRatio[1] = 4.0;
     394        lambdaRatio[2] = 5.0;
     395        lambdaRatio[3] = 12.3;
     396        lambdaRatio[4] = 12.3;
     397        lambdaRatio[5] = 5.0;
     398        lambdaRatio[6] = 12.3;
     399        lambdaRatio[7] = 12.3;
     400      }
     401    }
     402
     403    xCalEquaCoeff( encRCSeq, lambdaRatio, equaCoeffA, equaCoeffB, encRCSeq->getGOPSize() );
     404    basicLambda = xSolveEqua( targetBpp, equaCoeffA, equaCoeffB, encRCSeq->getGOPSize() );
     405    encRCSeq->setAllBitRatio( basicLambda, equaCoeffA, equaCoeffB );
     406
     407    delete []lambdaRatio;
     408    delete []equaCoeffA;
     409    delete []equaCoeffB;
     410  }
     411#endif
     412
    288413  m_picTargetBitInGOP = new Int[numPic];
    289414  Int i;
    … …  
    297422  {
    298423    currPicRatio = encRCSeq->getBitRatio( i );
     424#if M0036_RC_IMPROVEMENT
     425    m_picTargetBitInGOP[i] = (Int)( ((Double)targetBits) * currPicRatio / totalPicRatio );
     426#else
    299427    m_picTargetBitInGOP[i] = targetBits * currPicRatio / totalPicRatio;
     428#endif
    300429  }
    301430
    … …  
    306435  m_bitsLeft     = m_targetBits;
    307436}
     437
     438#if M0036_RC_IMPROVEMENT
     439Void TEncRCGOP::xCalEquaCoeff( TEncRCSeq* encRCSeq, Double* lambdaRatio, Double* equaCoeffA, Double* equaCoeffB, Int GOPSize )
     440{
     441  for ( Int i=0; i<GOPSize; i++ )
     442  {
     443    Int frameLevel = encRCSeq->getGOPID2Level(i);
     444    Double alpha   = encRCSeq->getPicPara(frameLevel).m_alpha;
     445    Double beta    = encRCSeq->getPicPara(frameLevel).m_beta;
     446    equaCoeffA[i] = pow( 1.0/alpha, 1.0/beta ) * pow( lambdaRatio[i], 1.0/beta );
     447    equaCoeffB[i] = 1.0/beta;
     448  }
     449}
     450
     451Double TEncRCGOP::xSolveEqua( Double targetBpp, Double* equaCoeffA, Double* equaCoeffB, Int GOPSize )
     452{
     453  Double solution = 100.0;
     454  Double minNumber = 0.1;
     455  Double maxNumber = 10000.0;
     456  for ( Int i=0; i<g_RCIterationNum; i++ )
     457  {
     458    Double fx = 0.0;
     459    for ( Int j=0; j<GOPSize; j++ )
     460    {
     461      fx += equaCoeffA[j] * pow( solution, equaCoeffB[j] );
     462    }
     463
     464    if ( fabs( fx - targetBpp ) < 0.000001 )
     465    {
     466      break;
     467    }
     468
     469    if ( fx > targetBpp )
     470    {
     471      minNumber = solution;
     472      solution = ( solution + maxNumber ) / 2.0;
     473    }
     474    else
     475    {
     476      maxNumber = solution;
     477      solution = ( solution + minNumber ) / 2.0;
     478    }
     479  }
     480
     481  solution = Clip3( 0.1, 10000.0, solution );
     482  return solution;
     483}
     484#endif
    308485
    309486Void TEncRCGOP::destroy()
    … …  
    357534
    358535  m_LCUs         = NULL;
     536#if !M0036_RC_IMPROVEMENT
    359537  m_lastPicture  = NULL;
     538#endif
    360539  m_picActualHeaderBits = 0;
     540#if !M0036_RC_IMPROVEMENT
    361541  m_totalMAD            = 0.0;
     542#endif
    362543  m_picActualBits       = 0;
    363544  m_picQP               = 0;
    … …  
    384565  }
    385566
     567#if M0036_RC_IMPROVEMENT
     568  targetBits  = Int( ((Double)GOPbitsLeft) * currPicRatio / totalPicRatio );
     569#else
    386570  targetBits  = Int( GOPbitsLeft * currPicRatio / totalPicRatio );
     571#endif
    387572
    388573  if ( targetBits < 100 )
    … …  
    480665      m_LCUs[LCUIdx].m_lambda     = 0.0;
    481666      m_LCUs[LCUIdx].m_targetBits = 0;
     667#if M0036_RC_IMPROVEMENT
     668      m_LCUs[LCUIdx].m_bitWeight  = 1.0;
     669#else
    482670      m_LCUs[LCUIdx].m_MAD        = 0.0;
     671#endif
    483672      Int currWidth  = ( (i == picWidthInLCU -1) ? picWidth  - LCUWidth *(picWidthInLCU -1) : LCUWidth  );
    484673      Int currHeight = ( (j == picHeightInLCU-1) ? picHeight - LCUHeight*(picHeightInLCU-1) : LCUHeight );
    … …  
    487676  }
    488677  m_picActualHeaderBits = 0;
     678#if !M0036_RC_IMPROVEMENT
    489679  m_totalMAD            = 0.0;
     680#endif
    490681  m_picActualBits       = 0;
    491682  m_picQP               = 0;
    492683  m_picLambda           = 0.0;
    493684
     685#if !M0036_RC_IMPROVEMENT
    494686  m_lastPicture = NULL;
    495687  list<TEncRCPic*>::reverse_iterator it;
    … …  
    502694    }
    503695  }
     696#endif
    504697}
    505698
    … …  
    515708}
    516709
     710
     711#if RATE_CONTROL_INTRA
     712Double TEncRCPic::estimatePicLambda( list<TEncRCPic*>& listPreviousPictures, SliceType eSliceType)
     713#else
    517714Double TEncRCPic::estimatePicLambda( list<TEncRCPic*>& listPreviousPictures )
     715#endif
    518716{
    519717  Double alpha         = m_encRCSeq->getPicPara( m_frameLevel ).m_alpha;
    520718  Double beta          = m_encRCSeq->getPicPara( m_frameLevel ).m_beta;
    521719  Double bpp       = (Double)m_targetBits/(Double)m_numberOfPixel;
     720#if RATE_CONTROL_INTRA
     721  Double estLambda;
     722  if (eSliceType == I_SLICE)
     723  {
     724    estLambda = calculateLambdaIntra(alpha, beta, pow(m_totalCostIntra/(Double)m_numberOfPixel, BETA1), bpp);
     725  }
     726  else
     727  {
     728    estLambda = alpha * pow( bpp, beta );
     729  }
     730#else
    522731  Double estLambda = alpha * pow( bpp, beta );
     732#endif 
     733 
    523734  Double lastLevelLambda = -1.0;
    524735  Double lastPicLambda   = -1.0;
    … …  
    566777
    567778  m_estPicLambda = estLambda;
     779
     780#if M0036_RC_IMPROVEMENT
     781  Double totalWeight = 0.0;
     782  // initial BU bit allocation weight
     783  for ( Int i=0; i<m_numberOfLCU; i++ )
     784  {
     785#if RC_FIX
     786    Double alphaLCU, betaLCU;
     787    if ( m_encRCSeq->getUseLCUSeparateModel() )
     788    {
     789      alphaLCU = m_encRCSeq->getLCUPara( m_frameLevel, i ).m_alpha;
     790      betaLCU  = m_encRCSeq->getLCUPara( m_frameLevel, i ).m_beta;
     791    }
     792    else
     793    {
     794      alphaLCU = m_encRCSeq->getPicPara( m_frameLevel ).m_alpha;
     795      betaLCU  = m_encRCSeq->getPicPara( m_frameLevel ).m_beta;
     796    }
     797#else
     798    Double alphaLCU = m_encRCSeq->getLCUPara( m_frameLevel, i ).m_alpha;
     799    Double betaLCU  = m_encRCSeq->getLCUPara( m_frameLevel, i ).m_beta;
     800#endif
     801
     802    m_LCUs[i].m_bitWeight =  m_LCUs[i].m_numberOfPixel * pow( estLambda/alphaLCU, 1.0/betaLCU );
     803
     804    if ( m_LCUs[i].m_bitWeight < 0.01 )
     805    {
     806      m_LCUs[i].m_bitWeight = 0.01;
     807    }
     808    totalWeight += m_LCUs[i].m_bitWeight;
     809  }
     810  for ( Int i=0; i<m_numberOfLCU; i++ )
     811  {
     812    Double BUTargetBits = m_targetBits * m_LCUs[i].m_bitWeight / totalWeight;
     813    m_LCUs[i].m_bitWeight = BUTargetBits;
     814  }
     815#endif
     816
    568817  return estLambda;
    569818}
    … …  
    607856}
    608857
     858#if RATE_CONTROL_INTRA
     859Double TEncRCPic::getLCUTargetBpp(SliceType eSliceType) 
     860#else
    609861Double TEncRCPic::getLCUTargetBpp()
     862#endif
    610863{
    611864  Int   LCUIdx    = getLCUCoded();
    612865  Double bpp      = -1.0;
    613866  Int avgBits     = 0;
     867#if !M0036_RC_IMPROVEMENT
    614868  Double totalMAD = -1.0;
    615869  Double MAD      = -1.0;
    616 
     870#endif
     871
     872#if RATE_CONTROL_INTRA
     873  if (eSliceType == I_SLICE){
     874    Int noOfLCUsLeft = m_numberOfLCU - LCUIdx + 1;
     875    Int bitrateWindow = min(4,noOfLCUsLeft);
     876    Double MAD      = getLCU(LCUIdx).m_costIntra;
     877
     878    if (m_remainingCostIntra > 0.1 )
     879    {
     880      Double weightedBitsLeft = (m_bitsLeft*bitrateWindow+(m_bitsLeft-getLCU(LCUIdx).m_targetBitsLeft)*noOfLCUsLeft)/(Double)bitrateWindow;
     881      avgBits = Int( MAD*weightedBitsLeft/m_remainingCostIntra );
     882    }
     883    else
     884    {
     885      avgBits = Int( m_bitsLeft / m_LCULeft );
     886    }
     887    m_remainingCostIntra -= MAD;
     888  }
     889  else
     890  {
     891#endif
     892#if M0036_RC_IMPROVEMENT
     893  Double totalWeight = 0;
     894  for ( Int i=LCUIdx; i<m_numberOfLCU; i++ )
     895  {
     896    totalWeight += m_LCUs[i].m_bitWeight;
     897  }
     898  Int realInfluenceLCU = min( g_RCLCUSmoothWindowSize, getLCULeft() );
     899  avgBits = (Int)( m_LCUs[LCUIdx].m_bitWeight - ( totalWeight - m_bitsLeft ) / realInfluenceLCU + 0.5 );
     900#else
    617901  if ( m_lastPicture == NULL )
    618902  {
    … …  
    637921    }
    638922  }
    639 
    640 #if L0033_RC_BUGFIX
     923#endif
     924#if RATE_CONTROL_INTRA
     925  }
     926#endif
     927
    641928  if ( avgBits < 1 )
    642929  {
    643930    avgBits = 1;
    644931  }
    645 #else
    646   if ( avgBits < 5 )
    647   {
    648     avgBits = 5;
    649   }
    650 #endif
    651932
    652933  bpp = ( Double )avgBits/( Double )m_LCUs[ LCUIdx ].m_numberOfPixel;
    … …  
    716997  //for Lambda clip, LCU level clip
    717998  Int clipNeighbourQP = g_RCInvalidQPValue;
    718 #if L0033_RC_BUGFIX
    719999  for ( int i=LCUIdx - 1; i>=0; i-- )
    720 #else
    721   for ( int i=LCUIdx; i>=0; i-- )
    722 #endif
    7231000  {
    7241001    if ( (getLCU(i)).m_QP > g_RCInvalidQPValue )
    … …  
    7731050    beta  *= ( 1.0 - m_encRCSeq->getBetaUpdate() / 2.0 );
    7741051
     1052#if M0036_RC_IMPROVEMENT
     1053    alpha = Clip3( g_RCAlphaMinValue, g_RCAlphaMaxValue, alpha );
     1054    beta  = Clip3( g_RCBetaMinValue,  g_RCBetaMaxValue,  beta  );
     1055#else
    7751056    alpha = Clip3( 0.05, 20.0, alpha );
    7761057    beta  = Clip3( -3.0, -0.1, beta  );
     1058#endif
    7771059
    7781060    TRCParameter rcPara;
    … …  
    7871069  alpha += m_encRCSeq->getAlphaUpdate() * ( log( inputLambda ) - log( calLambda ) ) * alpha;
    7881070  double lnbpp = log( bpp );
     1071#if M0036_RC_IMPROVEMENT
     1072  lnbpp = Clip3( -5.0, -0.1, lnbpp );
     1073#else
    7891074  lnbpp = Clip3( -5.0, 1.0, lnbpp );
     1075#endif
    7901076  beta  += m_encRCSeq->getBetaUpdate() * ( log( inputLambda ) - log( calLambda ) ) * lnbpp;
    7911077
     1078#if M0036_RC_IMPROVEMENT
     1079  alpha = Clip3( g_RCAlphaMinValue, g_RCAlphaMaxValue, alpha );
     1080  beta  = Clip3( g_RCBetaMinValue,  g_RCBetaMaxValue,  beta  );
     1081#else
    7921082  alpha = Clip3( 0.05, 20.0, alpha );
    7931083  beta  = Clip3( -3.0, -0.1, beta  );
     1084#endif
    7941085  TRCParameter rcPara;
    7951086  rcPara.m_alpha = alpha;
    … …  
    7991090}
    8001091
     1092#if !M0036_RC_IMPROVEMENT
    8011093Double TEncRCPic::getEffectivePercentage()
    8021094{
    … …  
    8161108  return effectivePixelPercentage;
    8171109}
     1110#endif
    8181111
    8191112Double TEncRCPic::calAverageQP()
    … …  
    8711164}
    8721165
     1166#if M0036_RC_IMPROVEMENT
     1167#if RATE_CONTROL_INTRA
     1168Void TEncRCPic::updateAfterPicture( Int actualHeaderBits, Int actualTotalBits, Double averageQP, Double averageLambda, SliceType eSliceType)
     1169#else
     1170Void TEncRCPic::updateAfterPicture( Int actualHeaderBits, Int actualTotalBits, Double averageQP, Double averageLambda )
     1171#endif
     1172#else
    8731173Void TEncRCPic::updateAfterPicture( Int actualHeaderBits, Int actualTotalBits, Double averageQP, Double averageLambda, Double effectivePercentage )
     1174#endif
    8741175{
    8751176  m_picActualHeaderBits = actualHeaderBits;
    … …  
    8841185  }
    8851186  m_picLambda           = averageLambda;
     1187#if !M0036_RC_IMPROVEMENT
    8861188  for ( Int i=0; i<m_numberOfLCU; i++ )
    8871189  {
    8881190    m_totalMAD += m_LCUs[i].m_MAD;
    8891191  }
     1192#endif
    8901193
    8911194  Double alpha = m_encRCSeq->getPicPara( m_frameLevel ).m_alpha;
    8921195  Double beta  = m_encRCSeq->getPicPara( m_frameLevel ).m_beta;
    893 
     1196#if RATE_CONTROL_INTRA
     1197  if (eSliceType == I_SLICE)
     1198  {
     1199    updateAlphaBetaIntra(&alpha, &beta);
     1200  }
     1201  else
     1202  {
     1203#endif
    8941204  // update parameters
    8951205  Double picActualBits = ( Double )m_picActualBits;
    … …  
    8981208  Double inputLambda   = m_picLambda;
    8991209
     1210#if M0036_RC_IMPROVEMENT
     1211  if ( inputLambda < 0.01 || calLambda < 0.01 || picActualBpp < 0.0001 )
     1212#else
    9001213  if ( inputLambda < 0.01 || calLambda < 0.01 || picActualBpp < 0.0001 || effectivePercentage < 0.05 )
     1214#endif
    9011215  {
    9021216    alpha *= ( 1.0 - m_encRCSeq->getAlphaUpdate() / 2.0 );
    9031217    beta  *= ( 1.0 - m_encRCSeq->getBetaUpdate() / 2.0 );
    9041218
     1219#if M0036_RC_IMPROVEMENT
     1220    alpha = Clip3( g_RCAlphaMinValue, g_RCAlphaMaxValue, alpha );
     1221    beta  = Clip3( g_RCBetaMinValue,  g_RCBetaMaxValue,  beta  );
     1222#else
    9051223    alpha = Clip3( 0.05, 20.0, alpha );
    9061224    beta  = Clip3( -3.0, -0.1, beta  );
     1225#endif
    9071226    TRCParameter rcPara;
    9081227    rcPara.m_alpha = alpha;
    … …  
    9161235  alpha += m_encRCSeq->getAlphaUpdate() * ( log( inputLambda ) - log( calLambda ) ) * alpha;
    9171236  double lnbpp = log( picActualBpp );
     1237#if M0036_RC_IMPROVEMENT
     1238  lnbpp = Clip3( -5.0, -0.1, lnbpp );
     1239#else
    9181240  lnbpp = Clip3( -5.0, 1.0, lnbpp );
     1241#endif
    9191242  beta  += m_encRCSeq->getBetaUpdate() * ( log( inputLambda ) - log( calLambda ) ) * lnbpp;
    9201243
     1244#if M0036_RC_IMPROVEMENT
     1245  alpha = Clip3( g_RCAlphaMinValue, g_RCAlphaMaxValue, alpha );
     1246  beta  = Clip3( g_RCBetaMinValue,  g_RCBetaMaxValue,  beta  );
     1247#else
    9211248  alpha = Clip3( 0.05, 20.0, alpha );
    9221249  beta  = Clip3( -3.0, -0.1, beta  );
     1250#endif
     1251#if RATE_CONTROL_INTRA
     1252  }
     1253#endif
    9231254
    9241255  TRCParameter rcPara;
    … …  
    9271258
    9281259  m_encRCSeq->setPicPara( m_frameLevel, rcPara );
    929 }
     1260
     1261#if M0036_RC_IMPROVEMENT
     1262  if ( m_frameLevel == 1 )
     1263  {
     1264    Double currLambda = Clip3( 0.1, 10000.0, m_picLambda );
     1265    Double updateLastLambda = g_RCWeightHistoryLambda * m_encRCSeq->getLastLambda() + g_RCWeightCurrentLambda * currLambda;
     1266    m_encRCSeq->setLastLambda( updateLastLambda );
     1267  }
     1268#endif
     1269}
     1270
     1271#if RATE_CONTROL_INTRA
     1272Int TEncRCPic::getRefineBitsForIntra( Int orgBits )
     1273{
     1274  Double alpha=0.25, beta=0.5582;
     1275  Int iIntraBits;
     1276
     1277  if (orgBits*40 < m_numberOfPixel)
     1278  {
     1279    alpha=0.25;
     1280  }
     1281  else
     1282  {
     1283    alpha=0.30;
     1284  }
     1285
     1286  iIntraBits = (Int)(alpha* pow(m_totalCostIntra*4.0/(Double)orgBits, beta)*(Double)orgBits+0.5);
     1287 
     1288  return iIntraBits;
     1289}
     1290
     1291Double TEncRCPic::calculateLambdaIntra(double alpha, double beta, double MADPerPixel, double bitsPerPixel)
     1292{
     1293  return ( (alpha/256.0) * pow( MADPerPixel/bitsPerPixel, beta ) );
     1294}
     1295
     1296Void TEncRCPic::updateAlphaBetaIntra(double *alpha, double *beta)
     1297{
     1298  Double lnbpp = log(pow(m_totalCostIntra / (Double)m_numberOfPixel, BETA1));
     1299  Double diffLambda = (*beta)*(log((Double)m_picActualBits)-log((Double)m_targetBits));
     1300
     1301  diffLambda = Clip3(-0.125, 0.125, 0.25*diffLambda);
     1302  *alpha    =  (*alpha) * exp(diffLambda);
     1303  *beta     =  (*beta) + diffLambda / lnbpp;
     1304}
     1305
     1306
     1307Void TEncRCPic::getLCUInitTargetBits() 
     1308{
     1309  Int iAvgBits     = 0;
     1310
     1311  m_remainingCostIntra = m_totalCostIntra;
     1312  for (Int i=m_numberOfLCU-1; i>=0; i--)
     1313  {
     1314    iAvgBits += Int(m_targetBits * getLCU(i).m_costIntra/m_totalCostIntra);
     1315    getLCU(i).m_targetBitsLeft = iAvgBits;
     1316  }
     1317}
     1318
     1319
     1320Double TEncRCPic::getLCUEstLambdaAndQP(Double bpp, Int clipPicQP, Int *estQP)
     1321{
     1322  Int   LCUIdx = getLCUCoded();
     1323
     1324  Double   alpha = m_encRCSeq->getPicPara( m_frameLevel ).m_alpha;
     1325  Double   beta  = m_encRCSeq->getPicPara( m_frameLevel ).m_beta;
     1326
     1327  Double costPerPixel = getLCU(LCUIdx).m_costIntra/(Double)getLCU(LCUIdx).m_numberOfPixel;
     1328  costPerPixel = pow(costPerPixel, BETA1);
     1329  Double estLambda = calculateLambdaIntra(alpha, beta, costPerPixel, bpp);
     1330
     1331  Int clipNeighbourQP = g_RCInvalidQPValue;
     1332  for (int i=LCUIdx-1; i>=0; i--)
     1333  {
     1334    if ((getLCU(i)).m_QP > g_RCInvalidQPValue)
     1335    {
     1336      clipNeighbourQP = getLCU(i).m_QP;
     1337      break;
     1338    }
     1339  }
     1340
     1341  Int minQP = clipPicQP - 2;
     1342  Int maxQP = clipPicQP + 2;
     1343
     1344  if ( clipNeighbourQP > g_RCInvalidQPValue )
     1345  {
     1346    maxQP = min(clipNeighbourQP + 1, maxQP);
     1347    minQP = max(clipNeighbourQP - 1, minQP);
     1348  }
     1349
     1350  Double maxLambda=exp(((Double)(maxQP+0.49)-13.7122)/4.2005);
     1351  Double minLambda=exp(((Double)(minQP-0.49)-13.7122)/4.2005);
     1352
     1353  estLambda = Clip3(minLambda, maxLambda, estLambda);
     1354
     1355  *estQP = Int( 4.2005 * log(estLambda) + 13.7122 + 0.5 );
     1356  *estQP = Clip3(minQP, maxQP, *estQP);
     1357
     1358  return estLambda;
     1359}
     1360#endif
    9301361
    9311362TEncRateCtrl::TEncRateCtrl()
    … …  
    9611392}
    9621393
     1394#if M0036_RC_IMPROVEMENT
     1395Void TEncRateCtrl::init( Int totalFrames, Int targetBitrate, Int frameRate, Int GOPSize, Int picWidth, Int picHeight, Int LCUWidth, Int LCUHeight, Int keepHierBits, Bool useLCUSeparateModel, GOPEntry  GOPList[MAX_GOP] )
     1396#else
    9631397Void TEncRateCtrl::init( Int totalFrames, Int targetBitrate, Int frameRate, Int GOPSize, Int picWidth, Int picHeight, Int LCUWidth, Int LCUHeight, Bool keepHierBits, Bool useLCUSeparateModel, GOPEntry  GOPList[MAX_GOP] )
     1398#endif
    9641399{
    9651400  destroy();
    … …  
    9761411
    9771412  Int numberOfLevel = 1;
     1413#if M0036_RC_IMPROVEMENT
     1414  Int adaptiveBit = 0;
     1415  if ( keepHierBits > 0 )
     1416#else
    9781417  if ( keepHierBits )
     1418#endif
    9791419  {
    9801420    numberOfLevel = Int( log((Double)GOPSize)/log(2.0) + 0.5 ) + 1;
    … …  
    9981438    }
    9991439  }
     1440
     1441#if M0036_RC_IMPROVEMENT
     1442  if ( keepHierBits > 0 )
     1443#else
    10001444  if ( keepHierBits )
     1445#endif
    10011446  {
    10021447    Double bpp = (Double)( targetBitrate / (Double)( frameRate*picWidth*picHeight ) );
    … …  
    10311476        bitsRatio[3] = 14;
    10321477      }
     1478#if M0036_RC_IMPROVEMENT
     1479      if ( keepHierBits == 2 )
     1480      {
     1481        adaptiveBit = 1;
     1482      }
     1483#endif
    10331484    }
    10341485    else if ( GOPSize == 8 && !isLowdelay )
    … …  
    10781529        bitsRatio[7] = 1;
    10791530      }
     1531#if M0036_RC_IMPROVEMENT
     1532      if ( keepHierBits == 2 )
     1533      {
     1534        adaptiveBit = 2;
     1535      }
     1536#endif
    10801537    }
    10811538    else
    10821539    {
     1540#if M0036_RC_IMPROVEMENT
     1541      printf( "\n hierarchical bit allocation is not support for the specified coding structure currently.\n" );
     1542#else
    10831543      printf( "\n hierarchical bit allocation is not support for the specified coding structure currently." );
     1544#endif
    10841545    }
    10851546  }
    … …  
    10941555    }
    10951556  }
     1557#if M0036_RC_IMPROVEMENT
     1558  if ( keepHierBits > 0 )
     1559#else
    10961560  if ( keepHierBits )
     1561#endif
    10971562  {
    10981563    if ( GOPSize == 4 && isLowdelay )
    … …  
    11291594
    11301595  m_encRCSeq = new TEncRCSeq;
     1596#if M0036_RC_IMPROVEMENT
     1597  m_encRCSeq->create( totalFrames, targetBitrate, frameRate, GOPSize, picWidth, picHeight, LCUWidth, LCUHeight, numberOfLevel, useLCUSeparateModel, adaptiveBit );
     1598#else
    11311599  m_encRCSeq->create( totalFrames, targetBitrate, frameRate, GOPSize, picWidth, picHeight, LCUWidth, LCUHeight, numberOfLevel, useLCUSeparateModel );
     1600#endif
    11321601  m_encRCSeq->initBitsRatio( bitsRatio );
    11331602  m_encRCSeq->initGOPID2Level( GOPID2Level );

  • branches/HTM-DEV-0.3-dev2/source/Lib/TLibEncoder/TEncRateCtrl.h

    r324 r537  
    6565const Double g_RCWeightPicTargetBitInGOP    = 0.9;
    6666const Double g_RCWeightPicRargetBitInBuffer = 1.0 - g_RCWeightPicTargetBitInGOP;
     67#if M0036_RC_IMPROVEMENT
     68const Int g_RCIterationNum = 20;
     69const Double g_RCWeightHistoryLambda = 0.5;
     70const Double g_RCWeightCurrentLambda = 1.0 - g_RCWeightHistoryLambda;
     71const Int g_RCLCUSmoothWindowSize = 4;
     72const Double g_RCAlphaMinValue = 0.05;
     73const Double g_RCAlphaMaxValue = 500.0;
     74const Double g_RCBetaMinValue  = -3.0;
     75const Double g_RCBetaMaxValue  = -0.1;
     76#endif
     77
     78#if RATE_CONTROL_INTRA
     79#define ALPHA     6.7542;
     80#define BETA1     1.2517
     81#define BETA2     1.7860
     82#endif
    6783
    6884struct TRCLCU
    … …  
    7288  Int m_targetBits;
    7389  Double m_lambda;
     90#if M0036_RC_IMPROVEMENT
     91  Double m_bitWeight;
     92#else
    7493  Double m_MAD;
     94#endif
    7595  Int m_numberOfPixel;
     96#if RATE_CONTROL_INTRA
     97  Double m_costIntra;
     98  Int m_targetBitsLeft;
     99#endif
    76100};
    77101
    … …  
    89113
    90114public:
     115#if M0036_RC_IMPROVEMENT
     116  Void create( Int totalFrames, Int targetBitrate, Int frameRate, Int GOPSize, Int picWidth, Int picHeight, Int LCUWidth, Int LCUHeight, Int numberOfLevel, Bool useLCUSeparateModel, Int adaptiveBit );
     117#else
    91118  Void create( Int totalFrames, Int targetBitrate, Int frameRate, Int GOPSize, Int picWidth, Int picHeight, Int LCUWidth, Int LCUHeight, Int numberOfLevel, Bool useLCUSeparateModel );
     119#endif
    92120  Void destroy();
    93121  Void initBitsRatio( Int bitsRatio[] );
    … …  
    96124  Void initLCUPara( TRCParameter** LCUPara = NULL );    // NULL to initial with default value
    97125  Void updateAfterPic ( Int bits );
     126#if !RATE_CONTROL_INTRA
    98127  Int  getRefineBitsForIntra( Int orgBits );
     128#endif
     129#if M0036_RC_IMPROVEMENT
     130  Void setAllBitRatio( Double basicLambda, Double* equaCoeffA, Double* equaCoeffB );
     131#endif
    99132
    100133public:
    … …  
    134167  Double getBetaUpdate()                { return m_betaUpdate; }
    135168
     169#if M0036_RC_IMPROVEMENT
     170  Int    getAdaptiveBits()              { return m_adaptiveBit;  }
     171  Double getLastLambda()                { return m_lastLambda;   }
     172  Void   setLastLambda( Double lamdba ) { m_lastLambda = lamdba; }
     173#endif
     174
    136175private:
    137176  Int m_totalFrames;
    … …  
    160199  Double m_betaUpdate;
    161200  Bool m_useLCUSeparateModel;
     201
     202#if M0036_RC_IMPROVEMENT
     203  Int m_adaptiveBit;
     204  Double m_lastLambda;
     205#endif
    162206};
    163207
    … …  
    175219private:
    176220  Int  xEstGOPTargetBits( TEncRCSeq* encRCSeq, Int GOPSize );
     221#if M0036_RC_IMPROVEMENT
     222  Void   xCalEquaCoeff( TEncRCSeq* encRCSeq, Double* lambdaRatio, Double* equaCoeffA, Double* equaCoeffB, Int GOPSize );
     223  Double xSolveEqua( Double targetBpp, Double* equaCoeffA, Double* equaCoeffB, Int GOPSize );
     224#endif
    177225
    178226public:
    … …  
    203251  Void destroy();
    204252
     253#if !RATE_CONTROL_INTRA
    205254  Double estimatePicLambda( list<TEncRCPic*>& listPreviousPictures );
     255#endif
    206256  Int    estimatePicQP    ( Double lambda, list<TEncRCPic*>& listPreviousPictures );
     257#if RATE_CONTROL_INTRA
     258  Int    getRefineBitsForIntra(Int orgBits);
     259  Double calculateLambdaIntra(double alpha, double beta, double MADPerPixel, double bitsPerPixel);
     260  Double estimatePicLambda( list<TEncRCPic*>& listPreviousPictures, SliceType eSliceType);
     261
     262  Void   updateAlphaBetaIntra(double *alpha, double *beta);
     263
     264  Double getLCUTargetBpp(SliceType eSliceType);
     265  Double getLCUEstLambdaAndQP(Double bpp, Int clipPicQP, Int *estQP);
     266#else
    207267  Double getLCUTargetBpp();
     268#endif
    208269  Double getLCUEstLambda( Double bpp );
    209270  Int    getLCUEstQP( Double lambda, Int clipPicQP );
    210271
    211272  Void updateAfterLCU( Int LCUIdx, Int bits, Int QP, Double lambda, Bool updateLCUParameter = true );
     273#if M0036_RC_IMPROVEMENT
     274#if RATE_CONTROL_INTRA
     275  Void updateAfterPicture( Int actualHeaderBits, Int actualTotalBits, Double averageQP, Double averageLambda, SliceType eSliceType);
     276#else
     277  Void updateAfterPicture( Int actualHeaderBits, Int actualTotalBits, Double averageQP, Double averageLambda );
     278#endif
     279#else
    212280  Void updateAfterPicture( Int actualHeaderBits, Int actualTotalBits, Double averageQP, Double averageLambda, Double effectivePercentage );
     281#endif
    213282
    214283  Void addToPictureLsit( list<TEncRCPic*>& listPreviousPictures );
     284#if !M0036_RC_IMPROVEMENT
    215285  Double getEffectivePercentage();
     286#endif
    216287  Double calAverageQP();
    217288  Double calAverageLambda();
    … …  
    229300  Int  getNumberOfLCU()                                   { return m_numberOfLCU; }
    230301  Int  getTargetBits()                                    { return m_targetBits; }
     302#if !RATE_CONTROL_INTRA
    231303  Void setTargetBits( Int bits )                          { m_targetBits = bits; }
     304#endif
    232305  Int  getEstHeaderBits()                                 { return m_estHeaderBits; }
    233306  Int  getLCULeft()                                       { return m_LCULeft; }
    … …  
    239312  TRCLCU& getLCU( Int LCUIdx )                            { return m_LCUs[LCUIdx]; }
    240313  Int  getPicActualHeaderBits()                           { return m_picActualHeaderBits; }
     314#if !M0036_RC_IMPROVEMENT
    241315  Double getTotalMAD()                                    { return m_totalMAD; }
    242316  Void   setTotalMAD( Double MAD )                        { m_totalMAD = MAD; }
     317#endif
     318#if RATE_CONTROL_INTRA
     319  Void setTargetBits( Int bits )                          { m_targetBits = bits; m_bitsLeft = bits;}
     320  Void setTotalIntraCost(Double cost)                     { m_totalCostIntra = cost; }
     321  Void getLCUInitTargetBits();
     322#endif
     323
    243324  Int  getPicActualBits()                                 { return m_picActualBits; }
    244325  Int  getPicActualQP()                                   { return m_picQP; }
    … …  
    267348  TRCLCU* m_LCUs;
    268349  Int m_picActualHeaderBits;    // only SH and potential APS
     350#if !M0036_RC_IMPROVEMENT
    269351  Double m_totalMAD;
     352#endif
     353#if RATE_CONTROL_INTRA
     354  Double m_totalCostIntra;
     355  Double m_remainingCostIntra;
     356#endif
    270357  Int m_picActualBits;          // the whole picture, including header
    271358  Int m_picQP;                  // in integer form
    272359  Double m_picLambda;
     360#if !M0036_RC_IMPROVEMENT
    273361  TEncRCPic* m_lastPicture;
     362#endif
    274363};
    275364
    … …  
    281370
    282371public:
     372#if M0036_RC_IMPROVEMENT
     373  Void init( Int totalFrames, Int targetBitrate, Int frameRate, Int GOPSize, Int picWidth, Int picHeight, Int LCUWidth, Int LCUHeight, Int keepHierBits, Bool useLCUSeparateModel, GOPEntry GOPList[MAX_GOP] );
     374#else
    283375  Void init( Int totalFrames, Int targetBitrate, Int frameRate, Int GOPSize, Int picWidth, Int picHeight, Int LCUWidth, Int LCUHeight, Bool keepHierBits, Bool useLCUSeparateModel, GOPEntry GOPList[MAX_GOP] );
     376#endif
    284377  Void destroy();
    285378  Void initRCPic( Int frameLevel );

  • branches/HTM-DEV-0.3-dev2/source/Lib/TLibEncoder/TEncSampleAdaptiveOffset.cpp

    r446 r537  
    299299        m_iTypePartBest[iPartIdx] = -1;
    300300        if( m_bUseSBACRD )
     301        {
    301302          m_pcRDGoOnSbacCoder->store( m_pppcRDSbacCoder[pOnePart->PartLevel][CI_TEMP_BEST] );
     303        }
    302304      }
    303305    }

  • branches/HTM-DEV-0.3-dev2/source/Lib/TLibEncoder/TEncSearch.cpp

    r532 r537  
    10671067    }
    10681068#endif
    1069 
    10701069    // save prediction
    10711070    if(default0Save1Load2 == 1)
    … …  
    14271426#if H_3D_DIM_ENC
    14281427                                , Bool        zeroResi
    1429 #endif
    1430                                 )
     1428#endif                               
     1429)
    14311430{
    14321431  UInt    uiFullDepth   = pcCU->getDepth( 0 ) +  uiTrDepth;
    … …  
    14361435 
    14371436#if HHI_RQT_INTRA_SPEEDUP
    1438 #if L0232_RD_PENALTY
    14391437  Int maxTuSize = pcCU->getSlice()->getSPS()->getQuadtreeTULog2MaxSize();
    14401438  Int isIntraSlice = (pcCU->getSlice()->getSliceType() == I_SLICE);
    … …  
    14531451  }
    14541452  if( bCheckFirst && noSplitIntraMaxTuSize )
     1453  {
     1454    bCheckSplit = false;
     1455  }
    14551456#else
    1456   if( bCheckFirst && bCheckFull )
    1457 #endif
    1458   {
    1459     bCheckSplit = false;
    1460   }
    1461 #else
    1462 #if L0232_RD_PENALTY
    14631457  Int maxTuSize = pcCU->getSlice()->getSPS()->getQuadtreeTULog2MaxSize();
    14641458  Int isIntraSlice = (pcCU->getSlice()->getSliceType() == I_SLICE);
    … …  
    14691463  }
    14701464#endif
    1471 #endif
    14721465#if H_3D_DIM
    14731466  if( isDimMode( pcCU->getLumaIntraDir( uiAbsPartIdx ) ) )
    … …  
    14761469  }
    14771470#endif
    1478 
    14791471  Double  dSingleCost   = MAX_DOUBLE;
    14801472#if H_3D_VSO
    … …  
    16671659      //----- determine rate and r-d cost -----
    16681660      UInt uiSingleBits = xGetIntraBitsQT( pcCU, uiTrDepth, uiAbsPartIdx, true, !bLumaOnly, false );
    1669 #if L0232_RD_PENALTY
    16701661      if(m_pcEncCfg->getRDpenalty() && (uiLog2TrSize==5) && !isIntraSlice)
    16711662      {
    16721663        uiSingleBits=uiSingleBits*4;
    16731664      }
    1674 #endif
    16751665#if H_3D_VSO // M40
    16761666      if ( m_pcRdCost->getUseLambdaScaleVSO())     
    … …  
    18231813    }
    18241814  }
    1825 
    18261815#if H_3D_VSO // M42
    18271816  if ( m_pcRdCost->getUseRenModel() && bCheckFull )
    … …  
    18361825  }
    18371826#endif
    1838 
    18391827  ruiDistY += uiSingleDistY;
    18401828  ruiDistC += uiSingleDistC;
    … …  
    27882776       
    27892777        UInt   iModeBits = xModeBitsIntra( pcCU, uiMode, uiPU, uiPartOffset, uiDepth, uiInitTrDepth );
    2790 
    2791      
    27922778#if H_3D_VSO // M35
    27932779#if H_3D_VSO_FIX // This fix should be enabled after verification
    … …  
    29242910    }
    29252911#endif
    2926 
    29272912    //===== check modes (using r-d costs) =====
    29282913#if HHI_RQT_INTRA_SPEEDUP_MOD
    … …  
    31123097      UInt   uiPUDistC = 0;
    31133098      Double dPUCost   = 0.0;
    3114 
    31153099#if H_3D_VSO // M37
    31163100      // reset Model
    … …  
    31643148    {
    31653149#endif
    3166    
    3167     //--- update transform index and cbf ---
     3150        //--- update transform index and cbf ---
    31683151    UInt uiQPartNum = pcCU->getPic()->getNumPartInCU() >> ( ( pcCU->getDepth(0) + uiInitTrDepth ) << 1 );
    31693152    ::memcpy( pcCU->getTransformIdx()       + uiPartOffset, m_puhQTTempTrIdx,  uiQPartNum * sizeof( UChar ) );
    … …  
    37643747    UInt          uiBitsTempL0[MAX_NUM_REF];
    37653748
    3766 #if L0034_COMBINED_LIST_CLEANUP
    37673749    TComMv        mvValidList1;
    37683750    Int           refIdxValidList1 = 0;
    37693751    UInt          bitsValidList1 = MAX_UINT;
    37703752    UInt          costValidList1 = MAX_UINT;
    3771 #endif
    37723753
    37733754    xGetBlkBits( ePartSize, pcCU->getSlice()->isInterP(), iPartIdx, uiLastMode, uiMbBits);
    … …  
    38213802        uiBitsTemp += m_auiMVPIdxCost[aaiMvpIdx[iRefList][iRefIdxTemp]][AMVP_MAX_NUM_CANDS];
    38223803#if ZERO_MVD_EST
    3823 #if L0034_COMBINED_LIST_CLEANUP
    38243804        if ( iRefList == 0 || pcCU->getSlice()->getList1IdxToList0Idx( iRefIdxTemp ) < 0 )
    3825 #else
    3826         if ((iRefList != 1 || !pcCU->getSlice()->getNoBackPredFlag()) &&
    3827             (pcCU->getSlice()->getNumRefIdx(REF_PIC_LIST_C) <= 0 || pcCU->getSlice()->getRefIdxOfLC(eRefPicList, iRefIdxTemp)>=0))
    3828 #endif
    38293805        {
    38303806          uiZeroMvdBitsTemp = uiBitsTemp;
    … …  
    38463822       
    38473823#if GPB_SIMPLE_UNI
    3848 #if L0034_COMBINED_LIST_CLEANUP
    38493824        if ( iRefList == 1 )    // list 1
    38503825        {
    … …  
    38713846        }
    38723847#else
    3873         if ( pcCU->getSlice()->getNumRefIdx(REF_PIC_LIST_C) > 0)
    3874         {
    3875           if ( iRefList && ( pcCU->getSlice()->getNoBackPredFlag() || (pcCU->getSlice()->getNumRefIdx(REF_PIC_LIST_C) > 0 && !pcCU->getSlice()->getNoBackPredFlag() && pcCU->getSlice()->getRefIdxOfL0FromRefIdxOfL1(iRefIdxTemp)>=0 ) ) )
    3876             {
    3877               if ( pcCU->getSlice()->getNoBackPredFlag() )
    3878               {
    3879                 cMvTemp[1][iRefIdxTemp] = cMvTemp[0][iRefIdxTemp];
    3880                 uiCostTemp = uiCostTempL0[iRefIdxTemp];
    3881                 /*first subtract the bit-rate part of the cost of the other list*/
    3882                 uiCostTemp -= m_pcRdCost->getCost( uiBitsTempL0[iRefIdxTemp] );
    3883               }
    3884               else
    3885               {
    3886                 cMvTemp[1][iRefIdxTemp] = cMvTemp[0][pcCU->getSlice()->getRefIdxOfL0FromRefIdxOfL1(iRefIdxTemp)];
    3887                 uiCostTemp = uiCostTempL0[pcCU->getSlice()->getRefIdxOfL0FromRefIdxOfL1(iRefIdxTemp)];
    3888                 /*first subtract the bit-rate part of the cost of the other list*/
    3889                 uiCostTemp -= m_pcRdCost->getCost( uiBitsTempL0[pcCU->getSlice()->getRefIdxOfL0FromRefIdxOfL1(iRefIdxTemp)] );
    3890               }
    3891               /*correct the bit-rate part of the current ref*/
    3892               m_pcRdCost->setPredictor  ( cMvPred[iRefList][iRefIdxTemp] );
    3893               uiBitsTemp += m_pcRdCost->getBits( cMvTemp[1][iRefIdxTemp].getHor(), cMvTemp[1][iRefIdxTemp].getVer() );
    3894               /*calculate the correct cost*/
    3895               uiCostTemp += m_pcRdCost->getCost( uiBitsTemp );
    3896             }
    3897             else
    3898             {
    3899               xMotionEstimation ( pcCU, pcOrgYuv, iPartIdx, eRefPicList, &cMvPred[iRefList][iRefIdxTemp], iRefIdxTemp, cMvTemp[iRefList][iRefIdxTemp], uiBitsTemp, uiCostTemp );
    3900             }
    3901         }
    3902         else
    3903         {
    3904           if (iRefList && pcCU->getSlice()->getNoBackPredFlag())
    3905           {
    3906             uiCostTemp = MAX_UINT;
    3907             cMvTemp[1][iRefIdxTemp] = cMvTemp[0][iRefIdxTemp];
    3908           }
    3909           else
    3910           {
    3911             xMotionEstimation ( pcCU, pcOrgYuv, iPartIdx, eRefPicList, &cMvPred[iRefList][iRefIdxTemp], iRefIdxTemp, cMvTemp[iRefList][iRefIdxTemp], uiBitsTemp, uiCostTemp );
    3912           }       
    3913         }
    3914 #endif
    3915 #else
    39163848        xMotionEstimation ( pcCU, pcOrgYuv, iPartIdx, eRefPicList, &cMvPred[iRefList][iRefIdxTemp], iRefIdxTemp, cMvTemp[iRefList][iRefIdxTemp], uiBitsTemp, uiCostTemp );
    39173849#endif
    … …  
    39193851        xCheckBestMVP(pcCU, eRefPicList, cMvTemp[iRefList][iRefIdxTemp], cMvPred[iRefList][iRefIdxTemp], aaiMvpIdx[iRefList][iRefIdxTemp], uiBitsTemp, uiCostTemp);
    39203852
    3921 #if L0034_COMBINED_LIST_CLEANUP
    39223853        if ( iRefList == 0 )
    39233854        {
    … …  
    39443875          refIdxValidList1 = iRefIdxTemp;
    39453876        }
    3946 #else
    3947         if(pcCU->getSlice()->getNumRefIdx(REF_PIC_LIST_C) > 0 && !pcCU->getSlice()->getNoBackPredFlag())
    3948         {
    3949           if(iRefList==REF_PIC_LIST_0)
    3950           {
    3951             uiCostTempL0[iRefIdxTemp] = uiCostTemp;
    3952             uiBitsTempL0[iRefIdxTemp] = uiBitsTemp;
    3953             if(pcCU->getSlice()->getRefIdxOfLC(REF_PIC_LIST_0, iRefIdxTemp)<0)
    3954             {
    3955               uiCostTemp = MAX_UINT;
    3956             }
    3957           }
    3958           else
    3959           {
    3960             if(pcCU->getSlice()->getRefIdxOfLC(REF_PIC_LIST_1, iRefIdxTemp)<0)
    3961             {
    3962               uiCostTemp = MAX_UINT;
    3963             }           
    3964           }
    3965         }
    3966 
    3967         if ( ( iRefList == 0 && uiCostTemp < uiCost[iRefList] ) ||
    3968             ( iRefList == 1 &&  pcCU->getSlice()->getNoBackPredFlag() && iRefIdxTemp == iRefIdx[0] ) ||
    3969             ( iRefList == 1 && (pcCU->getSlice()->getNumRefIdx(REF_PIC_LIST_C) > 0) && (iRefIdxTemp==0 || iRefIdxTemp == iRefIdx[0]) && !pcCU->getSlice()->getNoBackPredFlag() && (iRefIdxTemp == pcCU->getSlice()->getRefIdxOfL0FromRefIdxOfL1(iRefIdxTemp)) ) ||
    3970             ( iRefList == 1 && !pcCU->getSlice()->getNoBackPredFlag() && uiCostTemp < uiCost[iRefList] ) )
    3971           {
    3972             uiCost[iRefList] = uiCostTemp;
    3973             uiBits[iRefList] = uiBitsTemp; // storing for bi-prediction
    3974            
    3975             // set motion
    3976             cMv[iRefList]     = cMvTemp[iRefList][iRefIdxTemp];
    3977             iRefIdx[iRefList] = iRefIdxTemp;
    3978             pcCU->getCUMvField(eRefPicList)->setAllMv( cMv[iRefList], ePartSize, uiPartAddr, 0, iPartIdx );
    3979             pcCU->getCUMvField(eRefPicList)->setAllRefIdx( iRefIdx[iRefList], ePartSize, uiPartAddr, 0, iPartIdx );
    3980 
    3981             if(!pcCU->getSlice()->getMvdL1ZeroFlag())
    3982             {
    3983               // storing list 1 prediction signal for iterative bi-directional prediction
    3984               if ( eRefPicList == REF_PIC_LIST_1 )
    3985               {
    3986                 TComYuv*  pcYuvPred = &m_acYuvPred[iRefList];
    3987                 motionCompensation ( pcCU, pcYuvPred, eRefPicList, iPartIdx );
    3988               }
    3989               if ( (pcCU->getSlice()->getNoBackPredFlag() || (pcCU->getSlice()->getNumRefIdx(REF_PIC_LIST_C) > 0 && pcCU->getSlice()->getRefIdxOfL0FromRefIdxOfL1(0)==0 )) && eRefPicList == REF_PIC_LIST_0 )
    3990               {
    3991                 TComYuv*  pcYuvPred = &m_acYuvPred[iRefList];
    3992                 motionCompensation ( pcCU, pcYuvPred, eRefPicList, iPartIdx );
    3993               }
    3994             }
    3995           }
    3996 #endif
    39973877      }
    39983878    }
    … …  
    40583938       
    40593939        Int         iRefList    = iIter % 2;
    4060 #if L0034_COMBINED_LIST_CLEANUP
    40613940        if ( m_pcEncCfg->getUseFastEnc() )
    40623941        {
    … …  
    40813960          motionCompensation ( pcCU, pcYuvPred, RefPicList(1-iRefList), iPartIdx );
    40823961        }
    4083 #else
    4084         if ( m_pcEncCfg->getUseFastEnc() && (pcCU->getSlice()->getNoBackPredFlag() || (pcCU->getSlice()->getNumRefIdx(REF_PIC_LIST_C) > 0 && pcCU->getSlice()->getRefIdxOfL0FromRefIdxOfL1(0)==0 )) )
    4085         {
    4086           iRefList = 1;
    4087         }
    4088 #endif
    40893962        RefPicList  eRefPicList = ( iRefList ? REF_PIC_LIST_1 : REF_PIC_LIST_0 );
    40903963
    … …  
    42214094    UInt uiMEBits = 0;
    42224095    // Set Motion Field_
    4223 #if L0034_COMBINED_LIST_CLEANUP
    42244096    cMv[1] = mvValidList1;
    42254097    iRefIdx[1] = refIdxValidList1;
    42264098    uiBits[1] = bitsValidList1;
    42274099    uiCost[1] = costValidList1;
    4228 #else
    4229     if ( pcCU->getSlice()->getNoBackPredFlag() || (pcCU->getSlice()->getNumRefIdx(REF_PIC_LIST_C) > 0 && pcCU->getSlice()->getRefIdxOfL0FromRefIdxOfL1(0)==0 ) )
    4230     {
    4231       uiCost[1] = MAX_UINT;
    4232     }
    4233 #endif
    42344100#if AMP_MRG
    42354101    if (bTestNormalMC)

  • branches/HTM-DEV-0.3-dev2/source/Lib/TLibEncoder/TEncSlice.cpp

    r521 r537  
    475475#endif
    476476
    477 #if L0386_DB_METRIC
    478477  if ( m_pcCfg->getDeblockingFilterMetric() )
    479478  {
    … …  
    483482    rpcSlice->setDeblockingFilterTcOffsetDiv2( 0 );
    484483  } else
    485 #endif
    486484  if (rpcSlice->getPPS()->getDeblockingFilterControlPresentFlag())
    487485  {
    … …  
    560558  // store lambda
    561559  slice->setSliceQp( sliceQP );
    562 #if L0033_RC_BUGFIX
    563560  slice->setSliceQpBase ( sliceQP );
    564 #endif
    565561  m_pcRdCost ->setLambda( lambda );
    566562#if WEIGHTED_CHROMA_DISTORTION
    … …  
    876872/** \param rpcPic   picture class
    877873 */
     874#if RATE_CONTROL_INTRA
     875Void TEncSlice::calCostSliceI(TComPic*& rpcPic)
     876{
     877  UInt    uiCUAddr;
     878  UInt    uiStartCUAddr;
     879  UInt    uiBoundingCUAddr;
     880  Int     iSumHad, shift = g_bitDepthY-8, offset = (shift>0)?(1<<(shift-1)):0;;
     881  Double  iSumHadSlice = 0;
     882
     883  rpcPic->getSlice(getSliceIdx())->setSliceSegmentBits(0);
     884  TComSlice* pcSlice            = rpcPic->getSlice(getSliceIdx());
     885  xDetermineStartAndBoundingCUAddr ( uiStartCUAddr, uiBoundingCUAddr, rpcPic, false );
     886
     887  UInt uiEncCUOrder;
     888  uiCUAddr = rpcPic->getPicSym()->getCUOrderMap( uiStartCUAddr /rpcPic->getNumPartInCU());
     889  for( uiEncCUOrder = uiStartCUAddr/rpcPic->getNumPartInCU();
     890       uiEncCUOrder < (uiBoundingCUAddr+(rpcPic->getNumPartInCU()-1))/rpcPic->getNumPartInCU();
     891       uiCUAddr = rpcPic->getPicSym()->getCUOrderMap(++uiEncCUOrder) )
     892  {
     893    // initialize CU encoder
     894    TComDataCU*& pcCU = rpcPic->getCU( uiCUAddr );
     895    pcCU->initCU( rpcPic, uiCUAddr );
     896
     897    Int height  = min( pcSlice->getSPS()->getMaxCUHeight(),pcSlice->getSPS()->getPicHeightInLumaSamples() - uiCUAddr / rpcPic->getFrameWidthInCU() * pcSlice->getSPS()->getMaxCUHeight() );
     898    Int width   = min( pcSlice->getSPS()->getMaxCUWidth(),pcSlice->getSPS()->getPicWidthInLumaSamples() - uiCUAddr % rpcPic->getFrameWidthInCU() * pcSlice->getSPS()->getMaxCUWidth() );
     899
     900    iSumHad = m_pcCuEncoder->updateLCUDataISlice(pcCU, uiCUAddr, width, height);
     901
     902    (m_pcRateCtrl->getRCPic()->getLCU(uiCUAddr)).m_costIntra=(iSumHad+offset)>>shift;
     903    iSumHadSlice += (m_pcRateCtrl->getRCPic()->getLCU(uiCUAddr)).m_costIntra;
     904
     905  }
     906  m_pcRateCtrl->getRCPic()->setTotalIntraCost(iSumHadSlice);
     907}
     908#endif
     909
    878910Void TEncSlice::compressSlice( TComPic*& rpcPic )
    879911{
    … …  
    11611193        Double bpp       = -1.0;
    11621194
     1195#if M0036_RC_IMPROVEMENT
     1196        if ( ( rpcPic->getSlice( 0 )->getSliceType() == I_SLICE && m_pcCfg->getForceIntraQP() ) || !m_pcCfg->getLCULevelRC() )
     1197#else
    11631198        if ( rpcPic->getSlice( 0 )->getSliceType() == I_SLICE || !m_pcCfg->getLCULevelRC() )
     1199#endif
    11641200        {
    11651201          estQP = pcSlice->getSliceQp();
    … …  
    11671203        else
    11681204        {
     1205#if RATE_CONTROL_INTRA
     1206          bpp = m_pcRateCtrl->getRCPic()->getLCUTargetBpp(pcSlice->getSliceType());
     1207          if ( rpcPic->getSlice( 0 )->getSliceType() == I_SLICE)
     1208          {
     1209            estLambda = m_pcRateCtrl->getRCPic()->getLCUEstLambdaAndQP(bpp, pcSlice->getSliceQp(), &estQP);
     1210          }
     1211          else
     1212          {
     1213            estLambda = m_pcRateCtrl->getRCPic()->getLCUEstLambda( bpp );
     1214            estQP     = m_pcRateCtrl->getRCPic()->getLCUEstQP    ( estLambda, pcSlice->getSliceQp() );
     1215          }
     1216#else
    11691217          bpp       = m_pcRateCtrl->getRCPic()->getLCUTargetBpp();
    11701218          estLambda = m_pcRateCtrl->getRCPic()->getLCUEstLambda( bpp );
    11711219          estQP     = m_pcRateCtrl->getRCPic()->getLCUEstQP    ( estLambda, pcSlice->getSliceQp() );
     1220#endif
     1221
    11721222          estQP     = Clip3( -pcSlice->getSPS()->getQpBDOffsetY(), MAX_QP, estQP );
    11731223
    11741224          m_pcRdCost->setLambda(estLambda);
     1225#if M0036_RC_IMPROVEMENT
     1226#if RDOQ_CHROMA_LAMBDA
     1227          // set lambda for RDOQ
     1228          Double weight=m_pcRdCost->getChromaWeight();
     1229          m_pcTrQuant->setLambda( estLambda, estLambda / weight );
     1230#else
     1231          m_pcTrQuant->setLambda( estLambda );
     1232#endif
     1233#endif
    11751234        }
    11761235
    11771236        m_pcRateCtrl->setRCQP( estQP );
    1178 #if L0033_RC_BUGFIX
    11791237        pcCU->getSlice()->setSliceQpBase( estQP );
    1180 #endif
    11811238      }
    11821239#endif
    … …  
    11851242      m_pcCuEncoder->compressCU( pcCU );
    11861243
     1244#if !TICKET_1090_FIX
    11871245#if RATE_CONTROL_LAMBDA_DOMAIN
    11881246      if ( m_pcCfg->getUseRateCtrl() )
    11891247      {
     1248#if !M0036_RC_IMPROVEMENT
    11901249        UInt SAD    = m_pcCuEncoder->getLCUPredictionSAD();
    11911250        Int height  = min( pcSlice->getSPS()->getMaxCUHeight(),pcSlice->getSPS()->getPicHeightInLumaSamples() - uiCUAddr / rpcPic->getFrameWidthInCU() * pcSlice->getSPS()->getMaxCUHeight() );
    … …  
    11941253        MAD = MAD * MAD;
    11951254        ( m_pcRateCtrl->getRCPic()->getLCU(uiCUAddr) ).m_MAD = MAD;
     1255#endif
    11961256
    11971257        Int actualQP        = g_RCInvalidQPValue;
    … …  
    12171277        }
    12181278        m_pcRdCost->setLambda(oldLambda);
    1219 
     1279#if RATE_CONTROL_INTRA
     1280        m_pcRateCtrl->getRCPic()->updateAfterLCU( m_pcRateCtrl->getRCPic()->getLCUCoded(), actualBits, actualQP, actualLambda,
     1281          pcCU->getSlice()->getSliceType() == I_SLICE ? 0 : m_pcCfg->getLCULevelRC() );
     1282#else
    12201283        m_pcRateCtrl->getRCPic()->updateAfterLCU( m_pcRateCtrl->getRCPic()->getLCUCoded(), actualBits, actualQP, actualLambda, m_pcCfg->getLCULevelRC() );
    1221       }
     1284#endif
     1285      }
     1286#endif
    12221287#endif
    12231288     
    … …  
    12531318        }
    12541319      }
     1320
     1321#if TICKET_1090_FIX
     1322#if RATE_CONTROL_LAMBDA_DOMAIN
     1323      if ( m_pcCfg->getUseRateCtrl() )
     1324      {
     1325#if !M0036_RC_IMPROVEMENT
     1326        UInt SAD    = m_pcCuEncoder->getLCUPredictionSAD();
     1327        Int height  = min( pcSlice->getSPS()->getMaxCUHeight(),pcSlice->getSPS()->getPicHeightInLumaSamples() - uiCUAddr / rpcPic->getFrameWidthInCU() * pcSlice->getSPS()->getMaxCUHeight() );
     1328        Int width   = min( pcSlice->getSPS()->getMaxCUWidth(),pcSlice->getSPS()->getPicWidthInLumaSamples() - uiCUAddr % rpcPic->getFrameWidthInCU() * pcSlice->getSPS()->getMaxCUWidth() );
     1329        Double MAD = (Double)SAD / (Double)(height * width);
     1330        MAD = MAD * MAD;
     1331        ( m_pcRateCtrl->getRCPic()->getLCU(uiCUAddr) ).m_MAD = MAD;
     1332#endif
     1333
     1334        Int actualQP        = g_RCInvalidQPValue;
     1335        Double actualLambda = m_pcRdCost->getLambda();
     1336        Int actualBits      = pcCU->getTotalBits();
     1337        Int numberOfEffectivePixels    = 0;
     1338        for ( Int idx = 0; idx < rpcPic->getNumPartInCU(); idx++ )
     1339        {
     1340          if ( pcCU->getPredictionMode( idx ) != MODE_NONE && ( !pcCU->isSkipped( idx ) ) )
     1341          {
     1342            numberOfEffectivePixels = numberOfEffectivePixels + 16;
     1343            break;
     1344          }
     1345        }
     1346
     1347        if ( numberOfEffectivePixels == 0 )
     1348        {
     1349          actualQP = g_RCInvalidQPValue;
     1350        }
     1351        else
     1352        {
     1353          actualQP = pcCU->getQP( 0 );
     1354        }
     1355        m_pcRdCost->setLambda(oldLambda);
     1356
     1357#if RATE_CONTROL_INTRA
     1358        m_pcRateCtrl->getRCPic()->updateAfterLCU( m_pcRateCtrl->getRCPic()->getLCUCoded(), actualBits, actualQP, actualLambda,
     1359          pcCU->getSlice()->getSliceType() == I_SLICE ? 0 : m_pcCfg->getLCULevelRC() );
     1360#else
     1361        m_pcRateCtrl->getRCPic()->updateAfterLCU( m_pcRateCtrl->getRCPic()->getLCUCoded(), actualBits, actualQP, actualLambda, m_pcCfg->getLCULevelRC() );
     1362#endif
     1363      }
     1364#endif
     1365#endif
    12551366    }
    12561367    // other case: encodeCU is not called

  • branches/HTM-DEV-0.3-dev2/source/Lib/TLibEncoder/TEncSlice.h

    r481 r537  
    131131  Void    precompressSlice    ( TComPic*& rpcPic                                );      ///< precompress slice for multi-loop opt.
    132132  Void    compressSlice       ( TComPic*& rpcPic                                );      ///< analysis stage of slice
     133#if RATE_CONTROL_INTRA
     134  Void    calCostSliceI       ( TComPic*& rpcPic );
     135#endif
    133136  Void    encodeSlice         ( TComPic*& rpcPic, TComOutputBitstream* pcSubstreams  );
    134137 

  • branches/HTM-DEV-0.3-dev2/source/Lib/TLibEncoder/TEncTop.cpp

    r534 r537  
    293293  // This seems to be incorrect, but irrelevant for the MV-HEVC
    294294  *(m_cVPS->getPTL()) = *m_cSPS.getPTL();
    295 #if L0043_TIMING_INFO
    296295  m_cVPS->getTimingInfo()->setTimingInfoPresentFlag       ( false );
    297 #endif
    298296#else
    299297  *m_cVPS.getPTL() = *m_cSPS.getPTL();
    300 
    301 #if L0043_TIMING_INFO
    302298  m_cVPS.getTimingInfo()->setTimingInfoPresentFlag       ( false );
    303 #endif
    304299#endif
    305300  // initialize PPS
    … …  
    532527  profileTierLevel.setProfileIdc(m_profile);
    533528  profileTierLevel.setProfileCompatibilityFlag(m_profile, 1);
    534 #if L0046_CONSTRAINT_FLAGS
    535529  profileTierLevel.setProgressiveSourceFlag(m_progressiveSourceFlag);
    536530  profileTierLevel.setInterlacedSourceFlag(m_interlacedSourceFlag);
    537531  profileTierLevel.setNonPackedConstraintFlag(m_nonPackedConstraintFlag);
    538532  profileTierLevel.setFrameOnlyConstraintFlag(m_frameOnlyConstraintFlag);
    539 #endif
    540533 
    541534  if (m_profile == Profile::MAIN10 && g_bitDepthY == 8 && g_bitDepthC == 8)
    … …  
    584577
    585578  m_cSPS.setMaxTrSize   ( 1 << m_uiQuadtreeTULog2MaxSize );
    586 #if !L0034_COMBINED_LIST_CLEANUP
    587   m_cSPS.setUseLComb    ( m_bUseLComb           );
    588 #endif
    589579 
    590580  Int i;
    … …  
    651641    pcVUI->setFieldSeqFlag(false);
    652642    pcVUI->setHrdParametersPresentFlag(false);
    653 #if L0043_TIMING_INFO
    654643    pcVUI->getTimingInfo()->setPocProportionalToTimingFlag(getPocProportionalToTimingFlag());
    655644    pcVUI->getTimingInfo()->setNumTicksPocDiffOneMinus1   (getNumTicksPocDiffOneMinus1()   );
    656 #else
    657     pcVUI->setPocProportionalToTimingFlag(getPocProportionalToTimingFlag());
    658     pcVUI->setNumTicksPocDiffOneMinus1   (getNumTicksPocDiffOneMinus1()   );
    659 #endif
    660645    pcVUI->setBitstreamRestrictionFlag(getBitstreamRestrictionFlag());
    661646    pcVUI->setTilesFixedStructureFlag(getTilesFixedStructureFlag());
    … …  
    790775    }
    791776  }
    792 #if L0323_LIMIT_DEFAULT_LIST_SIZE
    793777  assert(bestPos <= 15);
    794 #endif
    795778  m_cPPS.setNumRefIdxL0DefaultActive(bestPos);
    796779  m_cPPS.setNumRefIdxL1DefaultActive(bestPos);
    … …  
    10471030}
    10481031
    1049 #if L0208_SOP_DESCRIPTION_SEI
    10501032Int TEncTop::getReferencePictureSetIdxForSOP(TComSlice* slice, Int POCCurr, Int GOPid )
    10511033{
    … …  
    10771059  return rpsIdx;
    10781060}
    1079 #endif
    10801061
    10811062Void  TEncTop::xInitPPSforTiles()

  • branches/HTM-DEV-0.3-dev2/source/Lib/TLibEncoder/TEncTop.h

    r479 r537  
    188188  TComPPS*                getPPS                () { return  &m_cPPS;                 }
    189189  Void selectReferencePictureSet(TComSlice* slice, Int POCCurr, Int GOPid );
    190 #if L0208_SOP_DESCRIPTION_SEI
    191190  Int getReferencePictureSetIdxForSOP(TComSlice* slice, Int POCCurr, Int GOPid );
    192 #endif
    193191  TComScalingList*        getScalingList        () { return  &m_scalingList;         }
    194192#if H_MV
Note: See TracChangeset for help on using the changeset viewer.