Changeset 1199 in SHVCSoftware


Ignore:
Timestamp:
8 Jul 2015, 20:02:01 (9 years ago)
Author:
seregin
Message:

macro cleanup: P0297_VPS_POC_LSB_ALIGNED_FLAG

Location:
branches/SHM-dev/source
Files:
11 edited

Legend:

Unmodified
Added
Removed

  • branches/SHM-dev/source/App/TAppEncoder/TAppEncTop.cpp

    r1198 r1199  
    8080  TComVPS* vps = m_acTEncTop[0].getVPS();
    8181
    82 #if P0297_VPS_POC_LSB_ALIGNED_FLAG
    8382  vps->setVpsPocLsbAlignedFlag(false);
    84 #endif
     83
    8584  vps->setMaxTLayers                                                      ( m_maxTempLayer );
    8685  if (m_maxTempLayer == 1)

  • branches/SHM-dev/source/Lib/TLibCommon/TComSlice.cpp

    r1198 r1199  
    134134, m_pocMsbValRequiredFlag         ( false )
    135135, m_pocMsbValPresentFlag          ( false )
    136 #if P0297_VPS_POC_LSB_ALIGNED_FLAG
    137136, m_pocMsbValNeeded               ( false )
    138 #endif
    139137#endif
    140138#if POC_RESET_IDC_DECODER || POC_RESET_IDC_ENCODER
    … …  
    235233  m_picOrderCntLsb = 0;
    236234#endif
    237 #if P0297_VPS_POC_LSB_ALIGNED_FLAG
    238235  m_pocMsbValNeeded  = false;
    239236  m_pocResetDeltaPoc = 0;
    240 #endif
    241237}
    242238
    … …  
    16921688  Bool irapIsInRPS = false;
    16931689#endif
    1694 #if P0297_VPS_POC_LSB_ALIGNED_FLAG
     1690#if SVC_POC
    16951691  Bool pocsAdjusted = false;
    16961692#endif
    … …  
    17071703      rpcPic = *(iterPic++);
    17081704
    1709 #if P0297_VPS_POC_LSB_ALIGNED_FLAG
     1705#if SVC_POC
    17101706      // poc adjustement by poc reset needs to be taken into account here
    17111707      Int deltaPOC = pReferencePictureSet->getDeltaPOC(i) - rpcPic->getPicSym()->getSlice(0)->getPocResetDeltaPoc();
    … …  
    17221718        // This picture exists as a reference picture
    17231719        // and should be added to the explicit Reference Picture Set
    1724 #if P0297_VPS_POC_LSB_ALIGNED_FLAG
     1720#if SVC_POC
    17251721        pcRPS->setDeltaPOC(k, deltaPOC);
    17261722#else
    … …  
    17291725        pcRPS->setUsed(k, pReferencePictureSet->getUsed(i) && (!isRAP));
    17301726#if ALLOW_RECOVERY_POINT_AS_RAP
    1731 #if P0297_VPS_POC_LSB_ALIGNED_FLAG
     1727#if SVC_POC
    17321728        pcRPS->setUsed(k, pcRPS->getUsed(k) && !(bUseRecoveryPoint && this->getPOC() > pocRandomAccess && this->getPOC() + deltaPOC < pocRandomAccess) );
    17331729#else
    … …  
    17841780    || useNewRPS
    17851781#endif
    1786 #if P0297_VPS_POC_LSB_ALIGNED_FLAG
     1782#if SVC_POC
    17871783    || pocsAdjusted  // inter RPS prediction does not work if POCs have been adjusted
    17881784#endif
    … …  
    19461942, m_viewIdLen                (0)
    19471943, m_vpsNonVuiExtLength (0)
    1948 #if P0297_VPS_POC_LSB_ALIGNED_FLAG
    19491944, m_vpsPocLsbAlignedFlag(false)
    1950 #endif
    19511945{
    19521946  for( Int i = 0; i < MAX_TLAYER; i++)

  • branches/SHM-dev/source/Lib/TLibCommon/TComSlice.h

    r1198 r1199  
    730730  UInt       m_baseLayerPSCompatibilityFlag[MAX_LAYERS];
    731731  Int        m_vpsNonVuiExtLength;
    732 #if P0297_VPS_POC_LSB_ALIGNED_FLAG
    733732  Bool       m_vpsPocLsbAlignedFlag;
    734 #endif
    735733  std::vector< std::vector<Bool> > m_necessaryLayerFlag;
    736734  std::vector<Int>                 m_numNecessaryLayers;
    … …  
    942940  UInt   getPocLsbNotPresentFlag(Int i)                                         { return m_pocLsbNotPresentFlag[i];              }
    943941  Void   setPocLsbNotPresentFlag(Int i, Bool x)                                 { m_pocLsbNotPresentFlag[i] = x;                 }
    944 #if P0297_VPS_POC_LSB_ALIGNED_FLAG
    945942  Bool   getVpsPocLsbAlignedFlag()                                              { return m_vpsPocLsbAlignedFlag;                 }
    946943  Void   setVpsPocLsbAlignedFlag(Bool x)                                        { m_vpsPocLsbAlignedFlag = x;                    }
    947 #endif
    948944  Bool   getCrossLayerPictureTypeAlignFlag()                                    { return m_crossLayerPictureTypeAlignFlag;       }
    949945  Void   setCrossLayerPictureTypeAlignFlag(Bool x)                              { m_crossLayerPictureTypeAlignFlag = x;          }
    … …  
    20222018  Bool        m_pocMsbValRequiredFlag;
    20232019  Bool        m_pocMsbValPresentFlag;
    2024 #if P0297_VPS_POC_LSB_ALIGNED_FLAG
    20252020  Bool        m_pocMsbValNeeded;
    20262021  Int         m_pocResetDeltaPoc;
    2027 #endif
    20282022#endif
    20292023#if POC_RESET_IDC_ENCODER
    … …  
    23752369  Int       getPocLsbVal         ()                              { return m_pocLsbVal;       }
    23762370  Void      setPocLsbVal       (Int b)                           { m_pocLsbVal = b;          }
    2377 #if P0297_VPS_POC_LSB_ALIGNED_FLAG
    23782371  Void      setPocMsbNeeded      (Bool x)                        { m_pocMsbValNeeded = x; }
    23792372  Bool      getPocMsbNeeded      ()                              { return m_pocMsbValNeeded; }
    23802373  Int       getPocResetDeltaPoc  ()                              { return m_pocResetDeltaPoc; }
    23812374  Void      setPocResetDeltaPoc  (Int x)                         { m_pocResetDeltaPoc = x; }
    2382 #endif
    23832375  Int       getPocMsbVal         ()                              { return m_pocMsbVal;       }
    23842376  Void      setPocMsbVal       (Int b)                           { m_pocMsbVal = b;          }

  • branches/SHM-dev/source/Lib/TLibCommon/TypeDef.h

    r1198 r1199  
    8585#define REPN_FORMAT_IN_VPS               1      ///< JCTVC-N0092: Signal represenation format (spatial resolution, bit depth, colour format) in the VPS
    8686#define SCALINGLIST_INFERRING            1      ///< JCTVC-N0371: inter-layer scaling list
    87 #define P0297_VPS_POC_LSB_ALIGNED_FLAG   1      ///< JCTVC-P0297: vps_poc_lsb_aligned_flag for cross-layer POC anchor picture derivation
    8887
    8988#define AVC_BASE                         1      ///< YUV BL reading for AVC base SVC
     89#define SVC_POC                          1      ///< POC signalling and reset
    9090
    9191#define REF_IDX_MFM                      1      ///< JCTVC-L0336: motion vector mapping of inter-layer reference picture

  • branches/SHM-dev/source/Lib/TLibDecoder/TDecCAVLC.cpp

    r1198 r1199  
    19691969
    19701970    // Derive the value of PocMsbValRequiredFlag
    1971 #if P0297_VPS_POC_LSB_ALIGNED_FLAG
    19721971    pcSlice->setPocMsbValRequiredFlag( (pcSlice->getCraPicFlag() || pcSlice->getBlaPicFlag())
    19731972      && (!pcSlice->getVPS()->getVpsPocLsbAlignedFlag() ||
    19741973      (pcSlice->getVPS()->getVpsPocLsbAlignedFlag() && pcSlice->getVPS()->getNumDirectRefLayers(pcSlice->getLayerId()) == 0))
    19751974      );
    1976 #else
    1977     pcSlice->setPocMsbValRequiredFlag( pcSlice->getCraPicFlag() || pcSlice->getBlaPicFlag() );
    1978 #endif
    1979 
    1980 #if P0297_VPS_POC_LSB_ALIGNED_FLAG
    1981     if (!pcSlice->getPocMsbValRequiredFlag() && pcSlice->getVPS()->getVpsPocLsbAlignedFlag())
    1982 #else
    1983     if (!pcSlice->getPocMsbValRequiredFlag() /* vps_poc_lsb_aligned_flag */)
    1984 #endif
    1985     {
    1986 #if P0297_VPS_POC_LSB_ALIGNED_FLAG
     1975
     1976    if( !pcSlice->getPocMsbValRequiredFlag() && pcSlice->getVPS()->getVpsPocLsbAlignedFlag() )
     1977    {
    19871978      READ_FLAG(uiCode, "poc_msb_cycle_val_present_flag"); pcSlice->setPocMsbValPresentFlag(uiCode ? true : false);
    1988 #else
    1989       READ_FLAG(uiCode, "poc_msb_val_present_flag"); pcSlice->setPocMsbValPresentFlag(uiCode ? true : false);
    1990 #endif
    19911979    }
    19921980    else
    … …  
    20071995    if( pcSlice->getPocMsbValPresentFlag() )
    20081996    {
    2009 #if P0297_VPS_POC_LSB_ALIGNED_FLAG
    20101997      READ_UVLC( uiCode,    "poc_msb_cycle_val");             pcSlice->setPocMsbVal( uiCode );
    2011 #else
    2012       READ_UVLC( uiCode,    "poc_msb_val");             pcSlice->setPocMsbVal( uiCode );
    2013 #endif
    20141998
    20151999#if !POC_RESET_IDC_DECODER
    … …  
    30263010  READ_FLAG(uiCode, "max_one_active_ref_layer_flag" );
    30273011  vps->setMaxOneActiveRefLayerFlag(uiCode);
    3028 #if P0297_VPS_POC_LSB_ALIGNED_FLAG
     3012
    30293013  READ_FLAG(uiCode, "vps_poc_lsb_aligned_flag");
    30303014  vps->setVpsPocLsbAlignedFlag(uiCode);
    3031 #endif
    3032 
    3033   for(i = 1; i< vps->getMaxLayers(); i++)
     3015
     3016  for( i = 1; i< vps->getMaxLayers(); i++ )
    30343017  {
    30353018    if( vps->getNumDirectRefLayers( vps->getLayerIdInNuh(i) ) == 0  )
    … …  
    31773160  }
    31783161
    3179 #if P0297_VPS_POC_LSB_ALIGNED_FLAG
    31803162  vps->setVpsPocLsbAlignedFlag(false);
    3181 #endif
    31823163
    31833164  // When not present, poc_lsb_not_present_flag[ i ] is inferred to be equal to 0.

  • branches/SHM-dev/source/Lib/TLibDecoder/TDecTop.cpp

    r1191 r1199  
    124124  resetPocRestrictionCheckParameters();
    125125#endif
    126 #if P0297_VPS_POC_LSB_ALIGNED_FLAG
    127126  m_pocResettingFlag        = false;
    128127  m_pocDecrementedInDPBFlag = false;
    129 #endif
    130128#if CONFORMANCE_BITSTREAM_MODE
    131129  m_confModeFlag = false;
    … …  
    909907#endif
    910908      markAllPicsAsNoCurrAu(m_apcSlicePilot->getVPS());
    911 #if P0297_VPS_POC_LSB_ALIGNED_FLAG
    912       for (UInt i = 0; i < MAX_LAYERS; i++)
     909
     910      for( UInt i = 0; i < MAX_LAYERS; i++ )
    913911      {
    914912        m_ppcTDecTop[m_apcSlicePilot->getVPS()->getLayerIdInNuh(i)]->m_pocDecrementedInDPBFlag = false;
    915913      }
    916 #endif
    917     }
    918 
    919 
    920 #if P0297_VPS_POC_LSB_ALIGNED_FLAG
     914    }
     915
    921916    m_pocResettingFlag = false;
    922917
    923     if (m_apcSlicePilot->getPocResetIdc() != 0)
    924     {
    925       if (m_apcSlicePilot->getVPS()->getVpsPocLsbAlignedFlag())
     918    if( m_apcSlicePilot->getPocResetIdc() != 0 )
     919    {
     920      if( m_apcSlicePilot->getVPS()->getVpsPocLsbAlignedFlag() )
    926921      {
    927922        m_pocResettingFlag = true;
    … …  
    936931      }
    937932    }
    938 #endif
    939933
    940934    if( m_apcSlicePilot->getPocResetIdc() && m_apcSlicePilot->getSliceIdx() == 0 )
    … …  
    984978#if ALIGNED_BUMPING
    985979#if POC_RESET_IDC_DECODER
    986 
    987 #if P0297_VPS_POC_LSB_ALIGNED_FLAG
    988980  UInt affectedLayerList[MAX_LAYERS];
    989981  Int  numAffectedLayers;
    … …  
    992984  numAffectedLayers = 1;
    993985
    994   if (m_apcSlicePilot->getVPS()->getVpsPocLsbAlignedFlag())
    995   {
    996     for (UInt j = 0; j < m_apcSlicePilot->getVPS()->getNumPredictedLayers(m_apcSlicePilot->getLayerId()); j++)
     986  if( m_apcSlicePilot->getVPS()->getVpsPocLsbAlignedFlag() )
     987  {
     988    for( UInt j = 0; j < m_apcSlicePilot->getVPS()->getNumPredictedLayers(m_apcSlicePilot->getLayerId()); j++ )
    997989    {
    998990      affectedLayerList[j + 1] = m_apcSlicePilot->getVPS()->getPredictedLayerId(m_apcSlicePilot->getLayerId(), j);
    … …  
    1000992    numAffectedLayers = m_apcSlicePilot->getVPS()->getNumPredictedLayers(m_apcSlicePilot->getLayerId()) + 1;
    1001993  }
    1002 #endif
    1003 
    1004   //if(  (bNewPOC || m_layerId != m_uiPrevLayerId) && ( m_parseIdc != 1) )
    1005 #if P0297_VPS_POC_LSB_ALIGNED_FLAG
    1006   if (m_parseIdc == 1 && m_pocResettingFlag)
    1007 #else
    1008   if (m_parseIdc == 1)
    1009 #endif
     994
     995  if( m_parseIdc == 1 && m_pocResettingFlag )
    1010996  {
    1011997    // Invoke output of pictures if the current picture is a POC reset picture
    … …  
    1013999    /* Include reset of all POCs in the layer */
    10141000
    1015   // This operation would do the following:
    1016   // 1. Update the other picture in the DPB. This should be done only for the first slice of the picture.
    1017   // 2. Update the value of m_pocCRA.
    1018   // 3. Reset the POC values at the decoder for the current picture to be zero - will be done later
    1019   // 4. update value of POCLastDisplay
    1020      
    1021   //Do the reset stuff here
     1001    // This operation would do the following:
     1002    // 1. Update the other picture in the DPB. This should be done only for the first slice of the picture.
     1003    // 2. Update the value of m_pocCRA.
     1004    // 3. Reset the POC values at the decoder for the current picture to be zero - will be done later
     1005    // 4. update value of POCLastDisplay
     1006
     1007    //Do the reset stuff here
    10221008    Int maxPocLsb = 1 << m_apcSlicePilot->getSPS()->getBitsForPOC();
    10231009    Int pocLsbVal;
    … …  
    10321018
    10331019    Int pocMsbDelta = 0;
    1034     if ( m_apcSlicePilot->getPocMsbValPresentFlag() )
     1020    if( m_apcSlicePilot->getPocMsbValPresentFlag() )
    10351021    {
    10361022      pocMsbDelta = m_apcSlicePilot->getPocMsbVal() * maxPocLsb;
    … …  
    10581044    Int deltaPocVal  =  pocMsbDelta + pocLsbDelta;
    10591045
    1060 #if P0297_VPS_POC_LSB_ALIGNED_FLAG
    1061     for (UInt layerIdx = 0; layerIdx < numAffectedLayers; layerIdx++)
     1046    for( UInt layerIdx = 0; layerIdx < numAffectedLayers; layerIdx++ )
    10621047    {
    10631048      if (!m_ppcTDecTop[affectedLayerList[layerIdx]]->m_pocDecrementedInDPBFlag)
    … …  
    10651050        m_ppcTDecTop[affectedLayerList[layerIdx]]->m_pocDecrementedInDPBFlag = true;
    10661051        TComList<TComPic*>::iterator  iterPic = m_ppcTDecTop[affectedLayerList[layerIdx]]->getListPic()->begin();
     1052
    10671053        while (iterPic != m_ppcTDecTop[affectedLayerList[layerIdx]]->getListPic()->end())
    1068 #else
    1069     //Reset all POC for DPB -> basically do it for each slice in the picutre
    1070     TComList<TComPic*>::iterator  iterPic = m_cListPic.begin(); 
    1071 
    1072     // Iterate through all picture in DPB
    1073     while( iterPic != m_cListPic.end() )
    1074 #endif
    1075     {
    1076       TComPic *dpbPic = *iterPic;
    1077       // Check if the picture pointed to by iterPic is either used for reference or
    1078       // needed for output, are in the same layer, and not the current picture.
    1079 #if P0297_VPS_POC_LSB_ALIGNED_FLAG
    1080       assert(dpbPic->getLayerId() == affectedLayerList[layerIdx]);
    1081       if ( (dpbPic->getReconMark()) && (dpbPic->getPicSym()->getSlice(0)->getPicOutputFlag()) )
    1082 #else
    1083       if ( /*  ( ( dpbPic->getSlice(0)->isReferenced() ) || ( dpbPic->getOutputMark() ) )
    1084           &&*/ ( dpbPic->getLayerId() == m_apcSlicePilot->getLayerId() )
    1085             && ( dpbPic->getReconMark() ) && ( dpbPic->getPicSym()->getSlice(0)->getPicOutputFlag() ))
    1086 #endif
    1087       {
    1088         for(Int i = dpbPic->getNumAllocatedSlice()-1; i >= 0; i--)
    1089         {
    1090 
    1091           TComSlice *slice = dpbPic->getSlice(i);
    1092           TComReferencePictureSet *rps = slice->getRPS();
    1093           slice->setPOC( slice->getPOC() - deltaPocVal );
    1094 
    1095           // Also adjust the POC value stored in the RPS of each such slice
    1096           for(Int j = rps->getNumberOfPictures(); j >= 0; j--)
     1054        {
     1055          TComPic *dpbPic = *iterPic;
     1056          // Check if the picture pointed to by iterPic is either used for reference or
     1057          // needed for output, are in the same layer, and not the current picture.
     1058          assert(dpbPic->getLayerId() == affectedLayerList[layerIdx]);
     1059
     1060          if( (dpbPic->getReconMark()) && (dpbPic->getPicSym()->getSlice(0)->getPicOutputFlag()) )
    10971061          {
    1098             rps->setPOC( j, rps->getPOC(j) - deltaPocVal );
    1099           }
    1100           // Also adjust the value of refPOC
    1101           for(Int k = 0; k < 2; k++)  // For List 0 and List 1
    1102           {
    1103             RefPicList list = (k == 1) ? REF_PIC_LIST_1 : REF_PIC_LIST_0;
    1104             for(Int j = 0; j < slice->getNumRefIdx(list); j++)
     1062            for(Int i = dpbPic->getNumAllocatedSlice()-1; i >= 0; i--)
    11051063            {
    1106               slice->setRefPOC( slice->getRefPOC(list, j) - deltaPocVal, list, j);
     1064
     1065              TComSlice *slice = dpbPic->getSlice(i);
     1066              TComReferencePictureSet *rps = slice->getRPS();
     1067              slice->setPOC( slice->getPOC() - deltaPocVal );
     1068
     1069              // Also adjust the POC value stored in the RPS of each such slice
     1070              for(Int j = rps->getNumberOfPictures(); j >= 0; j--)
     1071              {
     1072                rps->setPOC( j, rps->getPOC(j) - deltaPocVal );
     1073              }
     1074              // Also adjust the value of refPOC
     1075              for(Int k = 0; k < 2; k++)  // For List 0 and List 1
     1076              {
     1077                RefPicList list = (k == 1) ? REF_PIC_LIST_1 : REF_PIC_LIST_0;
     1078                for(Int j = 0; j < slice->getNumRefIdx(list); j++)
     1079                {
     1080                  slice->setRefPOC( slice->getRefPOC(list, j) - deltaPocVal, list, j);
     1081                }
     1082              }
    11071083            }
    11081084          }
    1109         }
    1110       }
    1111       iterPic++;
    1112     }
    1113 #if P0297_VPS_POC_LSB_ALIGNED_FLAG
     1085          iterPic++;
     1086        }
    11141087        // Update the value of pocCRA
    11151088        m_ppcTDecTop[affectedLayerList[layerIdx]]->m_pocCRA -= deltaPocVal;
    11161089      }
    11171090    }
    1118 #else
    1119     // Update the value of pocCRA
    1120     m_pocCRA -= deltaPocVal;
    1121 #endif
    11221091
    11231092    // Update value of POCLastDisplay
    … …  
    11271096  Int slicePicOrderCntLsb = m_apcSlicePilot->getPicOrderCntLsb();
    11281097
    1129 #if P0297_VPS_POC_LSB_ALIGNED_FLAG
    1130   if (m_pocResettingFlag && (m_parseIdc == 1 || m_parseIdc == 2))
    1131 #else
    1132   if (m_parseIdc == 1 || m_parseIdc == 2) // TODO This should be replaced by pocResettingFlag.
    1133 #endif
     1098  if( m_pocResettingFlag && (m_parseIdc == 1 || m_parseIdc == 2) )
    11341099  {
    11351100    // Set poc for current slice
    … …  
    11721137    // Adjust prevPicOrderCnt
    11731138    if(    !m_apcSlicePilot->getRaslPicFlag()
    1174         && !m_apcSlicePilot->getRadlPicFlag()
    1175         && (m_apcSlicePilot->getNalUnitType() % 2 == 1)
    1176         && ( nalu.m_temporalId == 0 )
    1177         && !m_apcSlicePilot->getDiscardableFlag() )
    1178     {
    1179 #if P0297_VPS_POC_LSB_ALIGNED_FLAG
    1180       for (UInt i = 0; i < numAffectedLayers; i++)
     1139      && !m_apcSlicePilot->getRadlPicFlag()
     1140      && (m_apcSlicePilot->getNalUnitType() % 2 == 1)
     1141      && ( nalu.m_temporalId == 0 )
     1142      && !m_apcSlicePilot->getDiscardableFlag() )
     1143    {
     1144      for( UInt i = 0; i < numAffectedLayers; i++ )
    11811145      {
    11821146        m_ppcTDecTop[affectedLayerList[i]]->setPrevPicOrderCnt(m_apcSlicePilot->getPOC());
    11831147      }
    1184 #else
    1185       this->setPrevPicOrderCnt( m_apcSlicePilot->getPOC() );
    1186 #endif
    1187     }
    1188     else if ( m_apcSlicePilot->getPocResetIdc() == 3 )
    1189     {
    1190 #if P0297_VPS_POC_LSB_ALIGNED_FLAG
    1191       if (!m_firstPicInLayerDecodedFlag || (m_firstPicInLayerDecodedFlag && m_pocResettingFlag))
    1192       {
    1193         for (UInt i = 0; i < numAffectedLayers; i++)
    1194         {
    1195           m_ppcTDecTop[affectedLayerList[i]]->setPrevPicOrderCnt( m_apcSlicePilot->getFullPocResetFlag()
    1196                                                                   ? 0 : m_apcSlicePilot->getPocLsbVal() );
    1197         }
    1198       }
    1199 #else
    1200       this->setPrevPicOrderCnt( m_apcSlicePilot->getFullPocResetFlag()
    1201                                             ? 0 : m_apcSlicePilot->getPocLsbVal() );
    1202 #endif
     1148    }
     1149    else if( m_apcSlicePilot->getPocResetIdc() == 3 )
     1150    {
     1151      if( !m_firstPicInLayerDecodedFlag || (m_firstPicInLayerDecodedFlag && m_pocResettingFlag) )
     1152      {
     1153        for( UInt i = 0; i < numAffectedLayers; i++ )
     1154        {
     1155          m_ppcTDecTop[affectedLayerList[i]]->setPrevPicOrderCnt( m_apcSlicePilot->getFullPocResetFlag() ? 0 : m_apcSlicePilot->getPocLsbVal() );
     1156        }
     1157      }
    12031158    }
    12041159#else
    … …  
    19471902  m_cGopDecoder.decompressSlice(nalu.m_Bitstream, m_pcPic);
    19481903
    1949 #if P0297_VPS_POC_LSB_ALIGNED_FLAG
     1904#if SVC_EXTENSION
    19501905  setFirstPicInLayerDecodedFlag(true);
    1951 #endif
    1952 #if SVC_EXTENSION
    19531906  m_lastPicHasEos = false;
    19541907#endif

  • branches/SHM-dev/source/Lib/TLibDecoder/TDecTop.h

    r1177 r1199  
    132132  TDecTop**               m_ppcTDecTop;
    133133  UInt                    m_smallestLayerId;
    134 #if P0297_VPS_POC_LSB_ALIGNED_FLAG
    135134  Bool                    m_pocResettingFlag;
    136135  Bool                    m_pocDecrementedInDPBFlag;
    137 #endif
    138136#if AVC_BASE
    139137  fstream*                m_pBLReconFile;

  • branches/SHM-dev/source/Lib/TLibEncoder/TEncCavlc.cpp

    r1198 r1199  
    18441844  {
    18451845    // Derive the value of PocMsbValRequiredFlag
    1846 #if P0297_VPS_POC_LSB_ALIGNED_FLAG
    18471846    slice->setPocMsbValRequiredFlag( (slice->getCraPicFlag() || slice->getBlaPicFlag())
    18481847                                  && (!slice->getVPS()->getVpsPocLsbAlignedFlag() ||
    18491848                                      (slice->getVPS()->getVpsPocLsbAlignedFlag() && slice->getVPS()->getNumDirectRefLayers(slice->getLayerId()) == 0))
    18501849                                   );
    1851 #else
    1852     slice->setPocMsbValRequiredFlag( slice->getCraPicFlag() || slice->getBlaPicFlag() );
    1853 #endif
    18541850
    18551851    // Determine value of SH extension length.
    … …  
    18681864    }
    18691865
    1870 
    1871 #if P0297_VPS_POC_LSB_ALIGNED_FLAG
    18721866    if (!slice->getPocMsbValRequiredFlag() && slice->getVPS()->getVpsPocLsbAlignedFlag())
    1873 #else
    1874     if (!slice->getPocMsbValRequiredFlag() /* &&  vps_poc_lsb_aligned_flag */)
    1875 #endif
    18761867    {
    18771868      shExtnLengthInBit++;
    … …  
    18891880    }
    18901881
    1891 #if P0297_VPS_POC_LSB_ALIGNED_FLAG
    18921882    if (slice->getPocMsbNeeded())
    18931883    {
    18941884      slice->setPocMsbValPresentFlag(true);
    18951885    }
    1896 #endif
    18971886
    18981887    if (slice->getPocMsbValPresentFlag())
    … …  
    19301919    }
    19311920
    1932 #if P0297_VPS_POC_LSB_ALIGNED_FLAG
    1933     if (!slice->getPocMsbValRequiredFlag() && slice->getVPS()->getVpsPocLsbAlignedFlag())
    1934 #else
    1935     if (!slice->getPocMsbValRequiredFlag() /* &&  vps_poc_lsb_aligned_flag */)
    1936 #endif
    1937     {
    1938 #if P0297_VPS_POC_LSB_ALIGNED_FLAG
     1921    if( !slice->getPocMsbValRequiredFlag() && slice->getVPS()->getVpsPocLsbAlignedFlag() )
     1922    {
    19391923      WRITE_FLAG( slice->getPocMsbValPresentFlag(),                           "poc_msb_cycle_val_present_flag" );
    1940 #else
    1941       WRITE_FLAG( slice->getPocMsbValPresentFlag(),                           "poc_msb_val_present_flag" );
    1942 #endif
    1943     }
    1944     if (slice->getPocMsbValPresentFlag())
     1924    }
     1925
     1926    if( slice->getPocMsbValPresentFlag() )
    19451927    {
    19461928      assert(slice->getPocMsbVal() % maxPocLsb == 0);
    1947 #if P0297_VPS_POC_LSB_ALIGNED_FLAG
    19481929      WRITE_UVLC(slice->getPocMsbVal() / maxPocLsb, "poc_msb_cycle_val");
    1949 #else
    1950       WRITE_UVLC(slice->getPocMsbVal() / maxPocLsb, "poc_msb_val");
    1951 #endif
    1952     }
     1930    }
     1931
    19531932    for (Int i = 0; i < shExtnAdditionalBits; i++)
    19541933    {
    … …  
    19561935    }
    19571936  }
     1937
    19581938  shBitsWrittenTillNow += ( getNumberOfWrittenBits() - tmpBitsBeforeWriting );
    19591939 
    … …  
    21892169
    21902170  WRITE_FLAG(vps->getMaxOneActiveRefLayerFlag(), "max_one_active_ref_layer_flag");
    2191 #if P0297_VPS_POC_LSB_ALIGNED_FLAG
     2171
    21922172  WRITE_FLAG(vps->getVpsPocLsbAlignedFlag(), "vps_poc_lsb_aligned_flag");
    2193 #endif
    21942173
    21952174  for( i = 1; i< vps->getMaxLayers(); i++ )

  • branches/SHM-dev/source/Lib/TLibEncoder/TEncGOP.cpp

    r1185 r1199  
    4949#include <time.h>
    5050#include <math.h>
    51 #if P0297_VPS_POC_LSB_ALIGNED_FLAG
     51#if SVC_EXTENSION
    5252#include <limits.h>
    5353#endif
    … …  
    11461146    determinePocResetIdc(pocCurr, pcSlice);
    11471147
    1148 #if P0297_VPS_POC_LSB_ALIGNED_FLAG
    11491148    Bool pocResettingFlag = false;
    11501149
    … …  
    11641163      }
    11651164    }
    1166 #endif
    11671165
    11681166    // If reset, do the following steps:
    1169 #if P0297_VPS_POC_LSB_ALIGNED_FLAG
    11701167    if( pocResettingFlag )
    1171 #else
    1172     if( pcSlice->getPocResetIdc() )
    1173 #endif
    11741168    {
    11751169      updatePocValuesOfPics(pocCurr, pcSlice);
    … …  
    34573451#if SVC_EXTENSION
    34583452    pcPicYuvRecOut->setReconstructed(true);
    3459 #endif
    3460 #if P0297_VPS_POC_LSB_ALIGNED_FLAG
    34613453    m_pcEncTop->setFirstPicInLayerDecodedFlag(true);
    34623454#endif
     3455
    34633456    pcPic->setReconMark   ( true );
    34643457    m_bFirst = false;
    … …  
    46434636#endif
    46444637
    4645 
    46464638#if POC_RESET_IDC_ENCODER
    46474639Void TEncGOP::determinePocResetIdc(Int const pocCurr, TComSlice *const slice)
    … …  
    46504642  // If BL picture in the AU is IDR, and another picture is not IDR, set the poc_reset_idc to 2
    46514643  // If BL picture is IRAP, and another picture is non-IRAP, then the poc_reset_idc is equal to 1 or 2.
    4652 #if P0297_VPS_POC_LSB_ALIGNED_FLAG
    46534644  slice->setPocMsbNeeded(false);
    4654 #endif
     4645
    46554646  if( slice->getSliceIdx() == 0 ) // First slice - compute, copy for other slices
    46564647  {
    … …  
    46784669      }
    46794670    }
    4680    
     4671
    46814672    if( !needReset )// No need reset due to base layer IRAP
    46824673    {
    … …  
    46854676      {
    46864677        Bool idrFlag = ( (m_ppcTEncTop[i]->getGOPEncoder()->getIntraRefreshType() == 2)
    4687                         && ( pocCurr % m_ppcTEncTop[i]->getGOPEncoder()->getIntraRefreshInterval() == 0 )
    4688                         );
     4678          && ( pocCurr % m_ppcTEncTop[i]->getGOPEncoder()->getIntraRefreshInterval() == 0 )
     4679          );
    46894680        for(Int j = 0; j < slice->getVPS()->getMaxLayers(); j++)
    46904681        {
    … …  
    46954686
    46964687          Bool idrOtherPicFlag = ( (m_ppcTEncTop[j]->getGOPEncoder()->getIntraRefreshType() == 2)
    4697                                   && ( pocCurr % m_ppcTEncTop[j]->getGOPEncoder()->getIntraRefreshInterval() == 0 )
    4698                                   );
     4688            && ( pocCurr % m_ppcTEncTop[j]->getGOPEncoder()->getIntraRefreshInterval() == 0 )
     4689            );
    46994690
    47004691          if( idrFlag != idrOtherPicFlag )
    … …  
    47134704        {
    47144705          slice->setPocResetIdc( 2 ); // Full reset needed
    4715 #if P0297_VPS_POC_LSB_ALIGNED_FLAG
    4716           if (slice->getVPS()->getVpsPocLsbAlignedFlag() && slice->getVPS()->getNumDirectRefLayers(slice->getLayerId()) == 0)
     4706
     4707          if( slice->getVPS()->getVpsPocLsbAlignedFlag() && slice->getVPS()->getNumDirectRefLayers(slice->getLayerId()) == 0 )
    47174708          {
    47184709            slice->setPocMsbNeeded(true);  // Force msb writing
    47194710          }
    4720 #endif
    47214711        }
    47224712        else
    … …  
    47364726        m_lastPocPeriodId = (periodId == m_lastPocPeriodId) ? (periodId + 1) % 64 : periodId ;
    47374727
    4738 #if P0297_VPS_POC_LSB_ALIGNED_FLAG
    4739         for (UInt i = 0; i < MAX_LAYERS; i++)
     4728        for( UInt i = 0; i < MAX_LAYERS; i++ )
    47404729        {
    47414730          m_ppcTEncTop[i]->setPocDecrementedInDPBFlag(false);
    47424731        }
    4743 #endif
    47444732      }
    47454733      else
    … …  
    47584746Void TEncGOP::updatePocValuesOfPics(Int const pocCurr, TComSlice *const slice)
    47594747{
    4760 #if P0297_VPS_POC_LSB_ALIGNED_FLAG
    47614748  UInt affectedLayerList[MAX_NUM_LAYER_IDS];
    47624749  Int  numAffectedLayers;
    … …  
    47734760    numAffectedLayers = m_pcEncTop->getVPS()->getNumPredictedLayers(m_layerId) + 1;
    47744761  }
    4775 #endif
    47764762
    47774763  Int pocAdjustValue = pocCurr - m_pcEncTop->getPocAdjustmentValue();
    … …  
    47824768  maxPocLsb   = 1 << slice->getSPS()->getBitsForPOC();
    47834769
    4784 #if P0297_VPS_POC_LSB_ALIGNED_FLAG
    47854770  Int adjustedPocValue = pocCurr;
    47864771
    47874772  if (m_pcEncTop->getFirstPicInLayerDecodedFlag())
    47884773  {
    4789 #endif
    4790 
    4791   pocLsbVal   = (slice->getPocResetIdc() == 3)
    4792                 ? slice->getPocLsbVal()
    4793                 : pocAdjustValue % maxPocLsb;
    4794   pocMsbDelta = pocAdjustValue - pocLsbVal;
    4795   pocLsbDelta = (slice->getPocResetIdc() == 2 || ( slice->getPocResetIdc() == 3 && slice->getFullPocResetFlag() ))
    4796                 ? pocLsbVal
    4797                 : 0;
    4798   deltaPocVal = pocMsbDelta  + pocLsbDelta;
    4799 
    4800 #if P0297_VPS_POC_LSB_ALIGNED_FLAG
    4801   Int origDeltaPocVal = deltaPocVal;  // original value needed when updating POC adjustment value
    4802 
    4803   if (slice->getPocMsbNeeded())  // IDR picture in base layer, non-IDR picture in other layers, poc_lsb_aligned_flag = 1
    4804   {
    4805     if (slice->getLayerId() == 0)
    4806     {
    4807       Int highestPoc = INT_MIN;
    4808       // Find greatest POC in DPB for layer 0
    4809       for (TComList<TComPic*>::iterator iterPic = m_pcEncTop->getListPic()->begin(); iterPic != m_pcEncTop->getListPic()->end(); ++iterPic)
    4810       {
    4811         TComPic *dpbPic = *iterPic;
    4812         if (dpbPic->getReconMark() && dpbPic->getLayerId() == 0 && dpbPic->getPOC() > highestPoc)
    4813         {
    4814           highestPoc = dpbPic->getPOC();
    4815         }
    4816       }
    4817       deltaPocVal = (highestPoc - (highestPoc & (maxPocLsb - 1))) + 1*maxPocLsb;
    4818       m_pcEncTop->setCurrPocMsb(deltaPocVal);
    4819     }
    4820     else
    4821     {
    4822       deltaPocVal = m_ppcTEncTop[0]->getCurrPocMsb();  // copy from base layer
    4823     }
    4824     slice->setPocMsbVal(deltaPocVal);
    4825   }
    4826 
    4827   for (UInt layerIdx = 0; layerIdx < numAffectedLayers; layerIdx++)
    4828   {
    4829     UInt lIdx = slice->getVPS()->getLayerIdxInVps(affectedLayerList[layerIdx]);
    4830 
    4831     if (!m_ppcTEncTop[lIdx]->getPocDecrementedInDPBFlag())
    4832     {
    4833       m_ppcTEncTop[lIdx]->setPocDecrementedInDPBFlag(true);
    4834 
    4835       // Decrement value of associatedIrapPoc of the TEncGop object
    4836       m_ppcTEncTop[lIdx]->getGOPEncoder()->m_associatedIRAPPOC -= deltaPocVal;
    4837 
    4838       // Decrememnt the value of m_pocCRA
    4839       m_ppcTEncTop[lIdx]->getGOPEncoder()->m_pocCRA -= deltaPocVal;
    4840 
    4841       TComList<TComPic*>::iterator  iterPic = m_ppcTEncTop[lIdx]->getListPic()->begin();
    4842       while (iterPic != m_ppcTEncTop[lIdx]->getListPic()->end())
    4843 #else
    4844   // Decrement value of associatedIrapPoc of the TEncGop object
    4845   this->m_associatedIRAPPOC -= deltaPocVal;
    4846 
    4847   // Decrememnt the value of m_pocCRA
    4848   this->m_pocCRA -= deltaPocVal;
    4849 
    4850   // Iterate through all pictures in the DPB
    4851   TComList<TComPic*>::iterator  iterPic = getListPic()->begin(); 
    4852   while( iterPic != getListPic()->end() )
    4853 #endif
    4854   {
    4855     TComPic *dpbPic = *iterPic;
    4856    
    4857     if( dpbPic->getReconMark() )
    4858     {
    4859       for(Int i = dpbPic->getNumAllocatedSlice() - 1; i >= 0; i--)
    4860       {
    4861         TComSlice *dpbPicSlice = dpbPic->getSlice( i );
    4862         TComReferencePictureSet *dpbPicRps = dpbPicSlice->getRPS();
    4863 
    4864         // Decrement POC of slice
    4865         dpbPicSlice->setPOC( dpbPicSlice->getPOC() - deltaPocVal );
    4866 
    4867         // Decrement POC value stored in the RPS of each such slice
    4868         for( Int j = dpbPicRps->getNumberOfPictures() - 1; j >= 0; j-- )
    4869         {
    4870           dpbPicRps->setPOC( j, dpbPicRps->getPOC(j) - deltaPocVal );
    4871         }
    4872 
    4873         // Decrement value of refPOC
    4874         dpbPicSlice->decrementRefPocValues( deltaPocVal );
    4875 
    4876         // Update value of associatedIrapPoc of each slice
    4877         dpbPicSlice->setAssociatedIRAPPOC( dpbPicSlice->getAssociatedIRAPPOC() - deltaPocVal );
    4878 
    4879 #if P0297_VPS_POC_LSB_ALIGNED_FLAG
    4880         if (slice->getPocMsbNeeded())
    4881         {
    4882           // this delta value is needed when computing delta POCs in reference picture set initialization
    4883           dpbPicSlice->setPocResetDeltaPoc(dpbPicSlice->getPocResetDeltaPoc() + (deltaPocVal - pocLsbVal));
    4884         }
    4885 #endif
    4886       }
    4887     }
    4888     iterPic++;
    4889   }
    4890 #if P0297_VPS_POC_LSB_ALIGNED_FLAG
    4891     }
    4892   }
    4893 #endif
    4894 
    4895   // Actual POC value before reset
    4896 #if P0297_VPS_POC_LSB_ALIGNED_FLAG
    4897   adjustedPocValue = pocCurr - m_pcEncTop->getPocAdjustmentValue();
    4898 #else
    4899   Int adjustedPocValue = pocCurr - m_pcEncTop->getPocAdjustmentValue();
    4900 #endif
    4901 
    4902   // Set MSB value before reset
    4903   Int tempLsbVal = adjustedPocValue & (maxPocLsb - 1);
    4904 #if P0297_VPS_POC_LSB_ALIGNED_FLAG
    4905   if (!slice->getPocMsbNeeded())  // set poc msb normally if special msb handling is not needed
    4906   {
    4907 #endif
    4908     slice->setPocMsbVal(adjustedPocValue - tempLsbVal);
    4909 #if P0297_VPS_POC_LSB_ALIGNED_FLAG
    4910   }
    4911 #endif
    4912 
    4913   // Set LSB value before reset - this is needed in the case of resetIdc = 2
    4914   slice->setPicOrderCntLsb( tempLsbVal );
    4915 
    4916   // Cumulative delta
    4917 #if P0297_VPS_POC_LSB_ALIGNED_FLAG
    4918   deltaPocVal = origDeltaPocVal;  // restore deltaPoc for correct adjustment value update
    4919 #endif
    4920   m_pcEncTop->setPocAdjustmentValue( m_pcEncTop->getPocAdjustmentValue() + deltaPocVal );
    4921 
    4922 #if P0297_VPS_POC_LSB_ALIGNED_FLAG
    4923   }
    4924 #endif
     4774    pocLsbVal   = (slice->getPocResetIdc() == 3)
     4775      ? slice->getPocLsbVal()
     4776      : pocAdjustValue % maxPocLsb;
     4777    pocMsbDelta = pocAdjustValue - pocLsbVal;
     4778    pocLsbDelta = (slice->getPocResetIdc() == 2 || ( slice->getPocResetIdc() == 3 && slice->getFullPocResetFlag() ))
     4779      ? pocLsbVal
     4780      : 0;
     4781    deltaPocVal = pocMsbDelta  + pocLsbDelta;
     4782
     4783    Int origDeltaPocVal = deltaPocVal;  // original value needed when updating POC adjustment value
     4784
     4785    // IDR picture in base layer, non-IDR picture in other layers, poc_lsb_aligned_flag = 1
     4786    if( slice->getPocMsbNeeded() )
     4787    {
     4788      if (slice->getLayerId() == 0)
     4789      {
     4790        Int highestPoc = INT_MIN;
     4791
     4792        // Find greatest POC in DPB for layer 0
     4793        for (TComList<TComPic*>::iterator iterPic = m_pcEncTop->getListPic()->begin(); iterPic != m_pcEncTop->getListPic()->end(); ++iterPic)
     4794        {
     4795          TComPic *dpbPic = *iterPic;
     4796          if (dpbPic->getReconMark() && dpbPic->getLayerId() == 0 && dpbPic->getPOC() > highestPoc)
     4797          {
     4798            highestPoc = dpbPic->getPOC();
     4799          }
     4800        }
     4801        deltaPocVal = (highestPoc - (highestPoc & (maxPocLsb - 1))) + 1*maxPocLsb;
     4802        m_pcEncTop->setCurrPocMsb(deltaPocVal);
     4803      }
     4804      else
     4805      {
     4806        deltaPocVal = m_ppcTEncTop[0]->getCurrPocMsb();  // copy from base layer
     4807      }
     4808      slice->setPocMsbVal(deltaPocVal);
     4809    }
     4810
     4811    for( UInt layerIdx = 0; layerIdx < numAffectedLayers; layerIdx++ )
     4812    {
     4813      UInt lIdx = slice->getVPS()->getLayerIdxInVps(affectedLayerList[layerIdx]);
     4814
     4815      if( !m_ppcTEncTop[lIdx]->getPocDecrementedInDPBFlag() )
     4816      {
     4817        m_ppcTEncTop[lIdx]->setPocDecrementedInDPBFlag(true);
     4818
     4819        // Decrement value of associatedIrapPoc of the TEncGop object
     4820        m_ppcTEncTop[lIdx]->getGOPEncoder()->m_associatedIRAPPOC -= deltaPocVal;
     4821
     4822        // Decrememnt the value of m_pocCRA
     4823        m_ppcTEncTop[lIdx]->getGOPEncoder()->m_pocCRA -= deltaPocVal;
     4824
     4825        TComList<TComPic*>::iterator  iterPic = m_ppcTEncTop[lIdx]->getListPic()->begin();
     4826        while (iterPic != m_ppcTEncTop[lIdx]->getListPic()->end())
     4827        {
     4828          TComPic *dpbPic = *iterPic;
     4829
     4830          if( dpbPic->getReconMark() )
     4831          {
     4832            for( Int i = dpbPic->getNumAllocatedSlice() - 1; i >= 0; i-- )
     4833            {
     4834              TComSlice *dpbPicSlice = dpbPic->getSlice( i );
     4835              TComReferencePictureSet *dpbPicRps = dpbPicSlice->getRPS();
     4836
     4837              // Decrement POC of slice
     4838              dpbPicSlice->setPOC( dpbPicSlice->getPOC() - deltaPocVal );
     4839
     4840              // Decrement POC value stored in the RPS of each such slice
     4841              for( Int j = dpbPicRps->getNumberOfPictures() - 1; j >= 0; j-- )
     4842              {
     4843                dpbPicRps->setPOC( j, dpbPicRps->getPOC(j) - deltaPocVal );
     4844              }
     4845
     4846              // Decrement value of refPOC
     4847              dpbPicSlice->decrementRefPocValues( deltaPocVal );
     4848
     4849              // Update value of associatedIrapPoc of each slice
     4850              dpbPicSlice->setAssociatedIRAPPOC( dpbPicSlice->getAssociatedIRAPPOC() - deltaPocVal );
     4851
     4852              if( slice->getPocMsbNeeded() )
     4853              {
     4854                // this delta value is needed when computing delta POCs in reference picture set initialization
     4855                dpbPicSlice->setPocResetDeltaPoc(dpbPicSlice->getPocResetDeltaPoc() + (deltaPocVal - pocLsbVal));
     4856              }
     4857            }
     4858          }
     4859          iterPic++;
     4860        }
     4861      }
     4862    }
     4863
     4864    // Actual POC value before reset
     4865    adjustedPocValue = pocCurr - m_pcEncTop->getPocAdjustmentValue();
     4866
     4867    // Set MSB value before reset
     4868    Int tempLsbVal = adjustedPocValue & (maxPocLsb - 1);
     4869    if (!slice->getPocMsbNeeded())  // set poc msb normally if special msb handling is not needed
     4870    {
     4871      slice->setPocMsbVal(adjustedPocValue - tempLsbVal);
     4872    }
     4873
     4874    // Set LSB value before reset - this is needed in the case of resetIdc = 2
     4875    slice->setPicOrderCntLsb( tempLsbVal );
     4876
     4877    // Cumulative delta
     4878    deltaPocVal = origDeltaPocVal;  // restore deltaPoc for correct adjustment value update
     4879
     4880    m_pcEncTop->setPocAdjustmentValue( m_pcEncTop->getPocAdjustmentValue() + deltaPocVal );
     4881  }
    49254882
    49264883  // New LSB value, after reset
    … …  
    49404897  {
    49414898    Int picOrderCntMsb = slice->getCurrMsb( newLsbVal,
    4942                                         slice->getFullPocResetFlag() ? 0 : slice->getPocLsbVal(),
    4943                                         0,
    4944                                         maxPocLsb );
     4899      slice->getFullPocResetFlag() ? 0 : slice->getPocLsbVal(),
     4900      0,
     4901      maxPocLsb );
    49454902    slice->setPOC( picOrderCntMsb + newLsbVal );
    49464903  }
    … …  
    49514908}
    49524909#endif
    4953 
    49544910
    49554911#if O0164_MULTI_LAYER_HRD

  • branches/SHM-dev/source/Lib/TLibEncoder/TEncTop.cpp

    r1185 r1199  
    9494  m_noOutputOfPriorPicsFlags   = false;
    9595#endif
    96 #if P0297_VPS_POC_LSB_ALIGNED_FLAG
    9796  m_pocDecrementedInDPBFlag    = false;
    98 #endif
    9997#endif //SVC_EXTENSION
    10098}

  • branches/SHM-dev/source/Lib/TLibEncoder/TEncTop.h

    r1172 r1199  
    148148#endif
    149149  Int                     m_numAddLayerSets;
    150 #if P0297_VPS_POC_LSB_ALIGNED_FLAG
    151150  Bool                    m_pocDecrementedInDPBFlag;
    152151  Int                     m_currPocMsb;
    153 #endif
    154152  Bool                    m_prevPicHasEos;
    155153#endif //SVC_EXTENSION
    … …  
    270268  Void      setNumAddLayerSets(Int x)             { m_numAddLayerSets = x; }
    271269  Int       getNumAddLayerSets()                  { return m_numAddLayerSets; }
    272 #if P0297_VPS_POC_LSB_ALIGNED_FLAG
    273270  Void      setPocDecrementedInDPBFlag(Bool x)    { m_pocDecrementedInDPBFlag = x; }
    274271  Bool      getPocDecrementedInDPBFlag()          { return m_pocDecrementedInDPBFlag; }
    275272  Void      setCurrPocMsb(Int poc)                { m_currPocMsb = poc; }
    276273  Int       getCurrPocMsb()                       { return m_currPocMsb; }
    277 #endif
    278274#else //SVC_EXTENSION
    279275  Void encode( Bool bEos,
Note: See TracChangeset for help on using the changeset viewer.