Changeset 622 in 3DVCSoftware for trunk/source/Lib/TLibCommon


Ignore:
Timestamp:
11 Sep 2013, 14:40:25 (11 years ago)
Author:
tech
Message:

Merged 8.0-dev0@621 (MV-HEVC 5 HLS).

Location:
trunk/source/Lib/TLibCommon
Files:
18 edited

Legend:

Unmodified
Added
Removed
  • trunk/source/Lib/TLibCommon/CommonDef.h

    r609 r622  
    4848#endif // _MSC_VER > 1000
    4949#include "TypeDef.h"
     50#if H_MV
     51#include <assert.h>
     52#endif
    5053
    5154//! \ingroup TLibCommon
     
    183186    return (t < 0) ? T(-1) : T(1);
    184187}
     188
     189#if H_MV5
     190template <typename T>
     191__inline T gCeilLog2( T val )
     192{
     193  assert( val > 0 );
     194  Int ceilLog2 = 0;
     195  while( val > ( 1 << ceilLog2 ) ) ceilLog2++;
     196  return ceilLog2;
     197}
     198#endif
    185199
    186200#define RemoveBitIncrement( exp ) ( exp >> ( g_bitDepthY - 8 ) )
  • trunk/source/Lib/TLibCommon/ContextTables.h

    r608 r622  
    112112#if H_3D_DIM_DMM
    113113#define NUM_DMM1_DATA_CTX             1       ///< number of context models for DMM1 data
    114 #if !SEC_DMM2_E0146
     114#if !SEC_DMM2_E0146_HHIFIX
    115115#define NUM_DMM2_DATA_CTX             1       ///< number of context models for DMM2 data
    116116#endif
     
    429429  { CNU },
    430430};
    431 #if !SEC_DMM2_E0146
     431#if !SEC_DMM2_E0146_HHIFIX
    432432static const UChar
    433433INIT_DMM2_DATA[3][NUM_DMM2_DATA_CTX] =
  • trunk/source/Lib/TLibCommon/TComDataCU.cpp

    r608 r622  
    120120    m_dmmWedgeTabIdx[i] = NULL;
    121121  }
    122 #if !SEC_DMM2_E0146
     122#if !SEC_DMM2_E0146_HHIFIX
    123123  m_dmm2DeltaEnd    = NULL;
    124124#endif
     
    146146#if H_3D_VSP
    147147  m_piVSPFlag            = NULL;
    148 #if MTK_VSP_FIX_E0172
    149   m_piVSPDir             = NULL;
    150 #endif
    151148#endif
    152149#if H_3D_ARP
     
    200197#if H_3D_VSP
    201198    m_piVSPFlag          = (Char*  )xMalloc(Char,   uiNumPartition);
    202 #if MTK_VSP_FIX_E0172
    203     m_piVSPDir           = (Char*  )xMalloc(Char,   uiNumPartition);
    204 #endif
    205199#endif
    206200    m_puhLumaIntraDir    = (UChar* )xMalloc(UChar,  uiNumPartition);
     
    280274      m_dmmWedgeTabIdx[i]    = (UInt*)xMalloc(UInt, uiNumPartition);
    281275    }
    282 #if !SEC_DMM2_E0146
     276#if !SEC_DMM2_E0146_HHIFIX
    283277    m_dmm2DeltaEnd    = (Int* )xMalloc(Int,  uiNumPartition);
    284278#endif
     
    363357#if H_3D_VSP
    364358    if ( m_piVSPFlag          ) { xFree(m_piVSPFlag);           m_piVSPFlag         = NULL; }
    365 #if MTK_VSP_FIX_E0172
    366     if ( m_piVSPDir           ) { xFree(m_piVSPDir  );          m_piVSPDir          = NULL; }
    367 #endif
    368359#endif
    369360    if ( m_puhLumaIntraDir    ) { xFree(m_puhLumaIntraDir);     m_puhLumaIntraDir   = NULL; }
     
    419410      if ( m_dmmWedgeTabIdx[i] ) { xFree( m_dmmWedgeTabIdx[i] ); m_dmmWedgeTabIdx[i] = NULL; }
    420411    }
    421 #if !SEC_DMM2_E0146
     412#if !SEC_DMM2_E0146_HHIFIX
    422413    if ( m_dmm2DeltaEnd    ) { xFree( m_dmm2DeltaEnd    ); m_dmm2DeltaEnd    = NULL; }
    423414#endif
     
    573564#if H_3D_VSP
    574565    m_piVSPFlag[ui] = pcFrom->m_piVSPFlag[ui];
    575 #if MTK_VSP_FIX_E0172
    576     m_piVSPDir  [ui] = pcFrom->m_piVSPDir[ui];
    577 #endif
    578566#endif
    579567    m_puhLumaIntraDir[ui]=pcFrom->m_puhLumaIntraDir[ui];
     
    618606#if H_3D_VSP
    619607    memset( m_piVSPFlag         + firstElement, 0,                        numElements * sizeof( *m_piVSPFlag ) );
    620 #if MTK_VSP_FIX_E0172
    621     memset( m_piVSPDir          + firstElement, 0,                        numElements * sizeof( *m_piVSPDir   ) );
    622 #endif
    623608#endif
    624609    memset( m_puhLumaIntraDir   + firstElement, DC_IDX,                   numElements * sizeof( *m_puhLumaIntraDir ) );
     
    646631      memset( m_dmmWedgeTabIdx[i] + firstElement, 0,                      numElements * sizeof( *m_dmmWedgeTabIdx[i] ) );
    647632    }
    648 #if !SEC_DMM2_E0146
     633#if !SEC_DMM2_E0146_HHIFIX
    649634    memset( m_dmm2DeltaEnd      + firstElement, 0,                        numElements * sizeof( *m_dmm2DeltaEnd    ) );
    650635#endif
     
    802787#if H_3D_VSP
    803788      m_piVSPFlag[ui] = 0;
    804 #if MTK_VSP_FIX_E0172
    805       m_piVSPDir  [ui] = 0;
    806 #endif
    807789#endif
    808790      m_puhLumaIntraDir[ui] = DC_IDX;
     
    829811        m_dmmWedgeTabIdx[i] [ui] = 0;
    830812      }
    831 #if !SEC_DMM2_E0146
     813#if !SEC_DMM2_E0146_HHIFIX
    832814      m_dmm2DeltaEnd    [ui] = 0;
    833815#endif
     
    906888#if H_3D_VSP
    907889  memset( m_piVSPFlag,          0, sizeof( Char  ) * m_uiNumPartition );
    908 #if MTK_VSP_FIX_E0172
    909   memset( m_piVSPDir  ,         0, sizeInChar );
    910 #endif
    911890#endif
    912891  memset( m_puhLumaIntraDir,    DC_IDX, iSizeInUchar );
     
    946925    memset( m_dmmWedgeTabIdx[i], 0, sizeof(UInt) * m_uiNumPartition );
    947926  }
    948 #if !SEC_DMM2_E0146
     927#if !SEC_DMM2_E0146_HHIFIX
    949928  memset( m_dmm2DeltaEnd   , 0, sizeof(Int ) * m_uiNumPartition );
    950929#endif
     
    1005984#if H_3D_VSP
    1006985      m_piVSPFlag[ui]=pcCU->m_piVSPFlag[uiPartOffset+ui];
    1007 #if MTK_VSP_FIX_ALIGN_WD_E0172
    1008986      m_pDvInfo[ ui ] = pcCU->m_pDvInfo[uiPartOffset+ui];
    1009 #endif
    1010 #if MTK_VSP_FIX_E0172
    1011       m_piVSPDir[ui]=pcCU->m_piVSPDir[uiPartOffset+ui];
    1012 #endif
    1013987#endif
    1014988      m_puhLumaIntraDir[ui]=pcCU->m_puhLumaIntraDir[uiPartOffset+ui];
     
    10361010        m_dmmWedgeTabIdx[i] [ui] = pcCU->m_dmmWedgeTabIdx[i] [uiPartOffset+ui];
    10371011      }
    1038 #if !SEC_DMM2_E0146
     1012#if !SEC_DMM2_E0146_HHIFIX
    10391013      m_dmm2DeltaEnd    [ui] = pcCU->m_dmm2DeltaEnd   [uiPartOffset+ui];
    10401014#endif
     
    11621136#if H_3D_VSP
    11631137  m_piVSPFlag           = pcCU->getVSPFlag()          + uiPart;
    1164 #if MTK_VSP_FIX_E0172
    1165   m_piVSPDir            = pcCU->getVSPDir  ()         + uiPart;
    1166 #endif
    11671138#endif
    11681139
     
    11961167    m_dmmWedgeTabIdx[i] = pcCU->getDmmWedgeTabIdx( i ) + uiPart;
    11971168  }
    1198 #if !SEC_DMM2_E0146
     1169#if !SEC_DMM2_E0146_HHIFIX
    11991170  m_dmm2DeltaEnd    = pcCU->getDmm2DeltaEnd()    + uiPart;
    12001171#endif
     
    13211292#if H_3D_VSP
    13221293  m_piVSPFlag          = pcCU->getVSPFlag()               + uiAbsPartIdx;
    1323 #if MTK_VSP_FIX_ALIGN_WD_E0172
    13241294  m_pDvInfo            = pcCU->getDvInfo()                + uiAbsPartIdx;
    1325 #endif
    1326 #if MTK_VSP_FIX_E0172
    1327   m_piVSPDir           = pcCU->getVSPDir  ()              + uiAbsPartIdx;
    1328 #endif
    13291295#endif
    13301296
     
    13741340#if H_3D_VSP
    13751341  memcpy( m_piVSPFlag           + uiOffset, pcCU->getVSPFlag(),           sizeof( Char ) * uiNumPartition );
    1376 #if MTK_VSP_FIX_ALIGN_WD_E0172
    13771342  memcpy( m_pDvInfo             + uiOffset, pcCU->getDvInfo(),            sizeof( *m_pDvInfo ) * uiNumPartition );
    1378 #endif
    1379 #if MTK_VSP_FIX_E0172
    1380   memcpy( m_piVSPDir            + uiOffset, pcCU->getVSPDir  (),          sizeInChar );
    1381 #endif
     1343
    13821344#endif
    13831345  memcpy( m_puhLumaIntraDir     + uiOffset, pcCU->getLumaIntraDir(),      iSizeInUchar );
     
    14041366    memcpy( m_dmmWedgeTabIdx[i] + uiOffset, pcCU->getDmmWedgeTabIdx( i ), sizeof(UInt) * uiNumPartition );
    14051367  }
    1406 #if !SEC_DMM2_E0146
     1368#if !SEC_DMM2_E0146_HHIFIX
    14071369  memcpy( m_dmm2DeltaEnd    + uiOffset, pcCU->getDmm2DeltaEnd()   , sizeof(Int ) * uiNumPartition );
    14081370#endif
     
    15091471#if H_3D_VSP
    15101472  memcpy( rpcCU->getVSPFlag()           + m_uiAbsIdxInLCU, m_piVSPFlag,           sizeof( Char ) * m_uiNumPartition );
    1511 #if MTK_VSP_FIX_ALIGN_WD_E0172
    15121473  memcpy( rpcCU->getDvInfo()            + m_uiAbsIdxInLCU, m_pDvInfo,             sizeof( *m_pDvInfo ) * m_uiNumPartition );
    1513 #endif
    1514 #if MTK_VSP_FIX_E0172
    1515   memcpy( rpcCU->getVSPDir  ()          + m_uiAbsIdxInLCU, m_piVSPDir  ,          sizeInChar );
    1516 #endif
    15171474#endif
    15181475  memcpy( rpcCU->getLumaIntraDir()      + m_uiAbsIdxInLCU, m_puhLumaIntraDir,     iSizeInUchar );
     
    15391496    memcpy( rpcCU->getDmmWedgeTabIdx( i ) + m_uiAbsIdxInLCU, m_dmmWedgeTabIdx[i], sizeof(UInt) * m_uiNumPartition );
    15401497  }
    1541 #if !SEC_DMM2_E0146
     1498#if !SEC_DMM2_E0146_HHIFIX
    15421499  memcpy( rpcCU->getDmm2DeltaEnd()    + m_uiAbsIdxInLCU, m_dmm2DeltaEnd   , sizeof(Int ) * m_uiNumPartition );
    15431500#endif
     
    16321589#if H_3D_VSP
    16331590  memcpy( rpcCU->getVSPFlag()           + uiPartOffset, m_piVSPFlag,           sizeof(Char) * uiQNumPart );
    1634 #if MTK_VSP_FIX_E0172
    1635   memcpy( rpcCU->getVSPDir  ()          + uiPartOffset, m_piVSPDir  ,          sizeInChar );
    1636 #endif
    16371591#endif
    16381592  memcpy( rpcCU->getLumaIntraDir()      + uiPartOffset, m_puhLumaIntraDir,     iSizeInUchar );
     
    16581612    memcpy( rpcCU->getDmmWedgeTabIdx( i ) + uiPartOffset, m_dmmWedgeTabIdx[i], sizeof(UInt) * uiQNumPart );
    16591613  }
    1660 #if !SEC_DMM2_E0146
     1614#if !SEC_DMM2_E0146_HHIFIX
    16611615  memcpy( rpcCU->getDmm2DeltaEnd()    + uiPartOffset, m_dmm2DeltaEnd   , sizeof(Int ) * uiQNumPart );
    16621616#endif
     
    27612715  setSubPart<Char>( iVSPFlag, m_piVSPFlag, uiAbsPartIdx, uiDepth, uiPartIdx );
    27622716}
    2763 #if MTK_VSP_FIX_ALIGN_WD_E0172
     2717#if H_3D_VSP
    27642718template<typename T>
    27652719Void TComDataCU::setSubPartT( T uiParameter, T* puhBaseLCU, UInt uiCUAddr, UInt uiCUDepth, UInt uiPUIdx )
     
    28952849  }
    28962850
    2897 }
    2898 #endif
    2899 #if MTK_VSP_FIX_E0172
    2900 Void TComDataCU::setVSPDirSubParts ( Char iVSPDir, UInt uiAbsPartIdx, UInt uiPartIdx, UInt uiDepth )
    2901 {
    2902   setSubPart<Char>( iVSPDir, m_piVSPDir, uiAbsPartIdx, uiDepth, uiPartIdx );
    29032851}
    29042852#endif
     
    33553303 *   false: otherwise
    33563304 */
    3357 #if MTK_VSP_FIX_E0172
    3358 inline Bool TComDataCU::xAddVspCand( UChar ucVspMergePos, Int mrgCandIdx, DisInfo* pDInfo, Int& iCount,
    3359                                     Bool* abCandIsInter, TComMvField* pcMvFieldNeighbours, UChar* puhInterDirNeighbours, Int* vspFlag, Int* vspDir )
    3360 #else
    3361 inline Bool TComDataCU::xAddVspCand( UChar ucVspMergePos, Int mrgCandIdx, DisInfo* pDInfo, Int& iCount,
     3305inline Bool TComDataCU::xAddVspCand( Int mrgCandIdx, DisInfo* pDInfo, Int& iCount,
    33623306                                     Bool* abCandIsInter, TComMvField* pcMvFieldNeighbours, UChar* puhInterDirNeighbours, Int* vspFlag )
    3363 #endif
    3364 {
    3365   if ( ucVspMergePos != H_3D_VSP_POSITION || 0 == m_pcSlice->getViewIndex() || !m_pcSlice->getVPS()->getViewSynthesisPredFlag( m_pcSlice->getLayerIdInVps() ) || m_pcSlice->getIsDepth() )
     3307{
     3308  if ( m_pcSlice->getViewIndex() == 0 || !m_pcSlice->getVPS()->getViewSynthesisPredFlag( m_pcSlice->getLayerIdInVps() ) || m_pcSlice->getIsDepth() )
     3309  {
    33663310    return false;
     3311  }
    33673312
    33683313  Int refViewIdx = pDInfo->m_aVIdxCan;
    33693314  TComPic* picDepth = getSlice()->getIvPic( true, refViewIdx );
     3315 
    33703316  if( picDepth == NULL ) // No depth reference avail
     3317  {
     3318    // Is this allowed to happen? When not an assertion should be added here!
    33713319    return false;
    3372  
    3373   Bool refViewAvailFlag = false;
    3374   UChar predFlag[2] = {0, 0};
    3375   Int  iRefListIdX = 0;
    3376   Int  iRefListIdY = 0;
    3377   Int  i;
    3378 #if MTK_VSP_FIX_ALIGN_WD_E0172
    3379   Int currViewId = m_pcSlice->getViewId();
    3380   Int derivedViewId = -1;
    3381   Int otherViewId = -1;
    3382 #endif
    3383 #if MTK_VSP_FIX_E0172
    3384   Int currViewId = m_pcSlice->getViewId();
    3385   Int derivedViewId = -1;
    3386   Int otherViewId = -1;
    3387 #endif
    3388   for( iRefListIdX = 0; iRefListIdX < 2 && !refViewAvailFlag; iRefListIdX++ )
    3389   {
    3390     RefPicList eRefPicList = RefPicList( iRefListIdX );
    3391     for ( i = 0; i < m_pcSlice->getNumRefIdx(eRefPicList) && !refViewAvailFlag; i++ )
    3392     {
    3393       Int viewIdxRefInList = m_pcSlice->getRefPic(eRefPicList, i)->getViewIndex();
    3394       if ( viewIdxRefInList == refViewIdx )
    3395       {
    3396         refViewAvailFlag = true;
     3320  }
     3321 
     3322  Bool  refViewAvailFlag = false;
     3323  UChar predFlag[2]      = {0, 0}; 
     3324  Int   refListIdY       = 0;   
     3325  Int   viewIdInRefListX = -1;
     3326 
     3327  for( Int iRefListIdX = 0; iRefListIdX < 2 && !refViewAvailFlag; iRefListIdX++ )
     3328  {
     3329    RefPicList eRefPicListX = RefPicList( iRefListIdX );
     3330    for ( Int i = 0; i < m_pcSlice->getNumRefIdx(eRefPicListX) && !refViewAvailFlag; i++ )
     3331    {
     3332      Int viewIdxRefInListX = m_pcSlice->getRefPic(eRefPicListX, i)->getViewIndex();
     3333      if ( viewIdxRefInListX == refViewIdx )
     3334      {
     3335        refViewAvailFlag      = true;
    33973336        predFlag[iRefListIdX] = 1;
    3398 #if MTK_VSP_FIX_ALIGN_WD_E0172
    3399         derivedViewId = m_pcSlice->getRefPic(eRefPicList, i)->getViewId();
    3400 #endif
    3401 #if MTK_VSP_FIX_E0172
    3402         vspDir[iCount] = iRefListIdX;
    3403         derivedViewId = m_pcSlice->getRefPic(eRefPicList, i)->getViewId();
    3404 #endif
    3405         iRefListIdY = 1 - iRefListIdX;
    3406 #if H_3D_FIX_BVSP
     3337        viewIdInRefListX      = m_pcSlice->getRefPic(eRefPicListX, i)->getViewId();
     3338        refListIdY            = 1 - iRefListIdX;
    34073339        pcMvFieldNeighbours[(iCount<<1)+iRefListIdX].setMvField( pDInfo->m_acNBDV, i );
    3408 #else
    3409         pcMvFieldNeighbours[(iCount<<1)+iRefListIdX].setMvField( pDInfo->m_acDoNBDV, i );
    3410 #endif
    34113340#if H_3D_NBDV
    34123341        pcMvFieldNeighbours[(iCount<<1)+iRefListIdX].getMv().setIDVFlag (false);
     
    34183347  if (m_pcSlice->isInterB() && refViewAvailFlag)
    34193348  {
    3420     RefPicList eRefPicList = RefPicList( iRefListIdY );
     3349    RefPicList eRefPicListY = RefPicList( refListIdY );
    34213350    refViewAvailFlag = false;
    3422     for ( i = 0; i < m_pcSlice->getNumRefIdx(eRefPicList) && !refViewAvailFlag; i++ )
    3423     {
    3424       Int viewIdxRefInList = m_pcSlice->getRefPic(eRefPicList, i)->getViewIndex();
    3425       if ( viewIdxRefInList != refViewIdx && viewIdxRefInList != m_pcSlice->getViewIndex() )
     3351    for ( Int i = 0; i < m_pcSlice->getNumRefIdx(eRefPicListY) && !refViewAvailFlag; i++ )
     3352    {
     3353      Int viewIdxRefInListY = m_pcSlice->getRefPic(eRefPicListY, i)->getViewIndex();
     3354      if ( viewIdxRefInListY != refViewIdx && viewIdxRefInListY != m_pcSlice->getViewIndex() )
    34263355      {
    34273356        refViewAvailFlag = true;
    3428         predFlag[iRefListIdY] = 1;
    3429 #if MTK_VSP_FIX_E0172 || MTK_VSP_FIX_ALIGN_WD_E0172
    3430 #if H_3D_FIX_BVSP
     3357        predFlag[refListIdY] = 1;
    34313358        TComMv  cMv = pDInfo->m_acNBDV;
    3432 #else
    3433         TComMv  cMv = pDInfo->m_acDoNBDV;
    3434 #endif
    3435         otherViewId = m_pcSlice->getRefPic( eRefPicList, i)->getViewId();
    3436         Int iScale = xGetDistScaleFactor( currViewId, otherViewId, currViewId, derivedViewId );
     3359       
     3360        Int viewIdInRefListY = m_pcSlice->getRefPic( eRefPicListY, i)->getViewId();
     3361        Int currViewId       = m_pcSlice->getViewId();
     3362       
     3363        //// Following might be added here when MV-HEVC 5 HLS is included (and derivations above removed):
     3364        // Int viewIdInRefListX = m_pcSlice->getVPS()->getViewIdVal( refViewIdx  );
     3365       
     3366        Int iScale      = xGetDistScaleFactor( currViewId, viewIdInRefListY, currViewId, viewIdInRefListX );
     3367       
     3368        // Can iScale == 4096 happen?, I guess not since viewIdInRefListY is always unequal to viewIdInRefListX.
    34373369        if ( iScale != 4096 && m_pcSlice->getVPS()->getIvMvScalingFlag() )
    34383370        {
     
    34453377        }
    34463378        clipMv( cMv );
    3447         pcMvFieldNeighbours[(iCount<<1)+iRefListIdY].setMvField( cMv, i );
    3448 #else
    3449 #if H_3D_FIX_BVSP
    3450         pcMvFieldNeighbours[(iCount<<1)+iRefListIdY].setMvField( pDInfo->m_acNBDV, i );
    3451 #else
    3452         pcMvFieldNeighbours[(iCount<<1)+iRefListIdY].setMvField( pDInfo->m_acDoNBDV, i );
    3453 #endif
    3454 #endif
     3379        pcMvFieldNeighbours[(iCount<<1)+refListIdY].setMvField( cMv, i );
    34553380#if H_3D_NBDV
    3456         pcMvFieldNeighbours[(iCount<<1)+iRefListIdY].getMv().setIDVFlag (false);
     3381        pcMvFieldNeighbours[(iCount<<1)+refListIdY].getMv().setIDVFlag (false);
    34573382#endif
    34583383      }
     
    34613386
    34623387  // Set values to be returned
    3463   abCandIsInter[iCount] = true;
     3388  abCandIsInter        [iCount] = true;
    34643389  puhInterDirNeighbours[iCount] = (predFlag[0] | (predFlag[1] << 1));
    3465   vspFlag[iCount] = 1;
     3390  vspFlag              [iCount] = 1;
    34663391
    34673392  if ( mrgCandIdx == iCount )
     3393  {
    34683394    return true;
     3395  }
    34693396
    34703397  iCount++;
     
    34753402#endif
    34763403
    3477 #if QC_INRIA_MTK_MRG_E0126
    3478 inline Bool TComDataCU::xAddIvMRGCand( Int mrgCandIdx, Int& iCount, Bool* abCandIsInter, TComMvField* pcMvFieldNeighbours, UChar* puhInterDirNeighbours, Int*   iPdmDir, TComMv* acPdmMv,
    3479                                        Int* aiPdmRefIdx, Int iPosDmv, Int* vspFlag )
    3480 {
    3481   for(Int iLoop = 0; iLoop  < 2; iLoop ++ )
    3482   {
     3404#if H_3D_IV_MERGE
     3405inline Bool TComDataCU::xAddIvMRGCand( Int mrgCandIdx, Int& iCount, Bool* abCandIsInter, TComMvField* pcMvFieldNeighbours, UChar* puhInterDirNeighbours, Int* ivCandDir, TComMv* ivCandMv,
     3406                                       Int* ivCandRefIdx, Int iPosIvDC, Int* vspFlag )
     3407{
     3408  for(Int iLoop = 0; iLoop < 2; iLoop ++ )
     3409  {
     3410    // IvDcShift (Derived from spatial Iv neighboring blocks)
    34833411    if( iLoop == 1 )
    34843412    {
    34853413      Int iFirDispCand = -1;
    3486       if (xFirstDmvAvai(iCount, pcMvFieldNeighbours, iPdmDir, iPosDmv, vspFlag, iFirDispCand))
     3414      if (xGetPosFirstAvailDmvCand(iCount, pcMvFieldNeighbours, ivCandDir, iPosIvDC, vspFlag, iFirDispCand))
    34873415      {
    34883416        TComMv cMv;
     
    34943422        }
    34953423        clipMv( cMv );
    3496         abCandIsInter[ iCount ] = true;
     3424        abCandIsInter        [ iCount ] = true;
    34973425        puhInterDirNeighbours[ iCount ] = puhInterDirNeighbours[iFirDispCand];
    3498         pcMvFieldNeighbours[ iCount<<1  ].setMvField(cMv, pcMvFieldNeighbours[( iFirDispCand << 1)].getRefIdx() );
    3499         pcMvFieldNeighbours[ (iCount<<1)+1 ].setMvField(pcMvFieldNeighbours[(iFirDispCand << 1) + 1].getMv(), pcMvFieldNeighbours[( iFirDispCand << 1) + 1].getRefIdx() );
     3426        pcMvFieldNeighbours  [ iCount << 1      ].setMvField(cMv, pcMvFieldNeighbours[( iFirDispCand << 1)].getRefIdx() );
     3427        pcMvFieldNeighbours  [(iCount << 1) + 1 ].setMvField(pcMvFieldNeighbours[(iFirDispCand << 1) + 1].getMv(), pcMvFieldNeighbours[( iFirDispCand << 1) + 1].getRefIdx() );
     3428       
    35003429        if( mrgCandIdx == iCount )
    35013430        {
    35023431          return true;
    35033432        }
     3433
    35043434        iCount++;
    35053435        break;
    35063436      }
    35073437    }
    3508     if(iPdmDir[iLoop + 2])
    3509     {
    3510       abCandIsInter[ iCount ] = true;
    3511       puhInterDirNeighbours[ iCount ] = iPdmDir[iLoop + 2];
    3512       if( ( iPdmDir[iLoop + 2] & 1 ) == 1 )
    3513       {
    3514         pcMvFieldNeighbours[ iCount<<1 ].setMvField( acPdmMv[ (iLoop<<1) + 4 ], aiPdmRefIdx[ (iLoop<<1) + 4 ] );
    3515       }
    3516       if( ( iPdmDir[iLoop + 2] & 2 ) == 2 )
    3517       {
    3518         pcMvFieldNeighbours[ (iCount<<1)+1 ].setMvField( acPdmMv[ (iLoop<<1) + 5 ], aiPdmRefIdx[ (iLoop<<1) + 5 ] );
     3438
     3439    /// iLoop = 0 --> IvMCShift
     3440    /// iLoop = 1 --> IvDCShift  (Derived from IvDC)
     3441    if(ivCandDir[iLoop + 2])
     3442    {
     3443      abCandIsInter        [ iCount ] = true;
     3444      puhInterDirNeighbours[ iCount ] = ivCandDir[iLoop + 2];
     3445      if( ( ivCandDir[iLoop + 2] & 1 ) == 1 )
     3446      {
     3447        pcMvFieldNeighbours[ iCount<<1 ].setMvField( ivCandMv[ (iLoop<<1) + 4 ], ivCandRefIdx[ (iLoop<<1) + 4 ] );
     3448      }
     3449      if( ( ivCandDir[iLoop + 2] & 2 ) == 2 )
     3450      {
     3451        pcMvFieldNeighbours[ (iCount<<1)+1 ].setMvField( ivCandMv[ (iLoop<<1) + 5 ], ivCandRefIdx[ (iLoop<<1) + 5 ] );
    35193452      }
    35203453     
    3521       bool bRemove = false;
    3522       if(!iLoop && iPdmDir[0] > 0)
    3523       {
    3524         if(puhInterDirNeighbours[iCount] == puhInterDirNeighbours[0] && pcMvFieldNeighbours[0]==pcMvFieldNeighbours[(iCount<<1)] && pcMvFieldNeighbours[1]==pcMvFieldNeighbours[(iCount<<1)+1])
     3454      // Prune IvMC vs. IvMcShift
     3455      Bool bRemove = false;     
     3456      if( !iLoop && ivCandDir[0] > 0)
     3457      {
     3458        if(puhInterDirNeighbours[iCount] == puhInterDirNeighbours[0] && pcMvFieldNeighbours[0 ]== pcMvFieldNeighbours[(iCount<<1)] && pcMvFieldNeighbours[1]==pcMvFieldNeighbours[(iCount<<1)+1])
    35253459        {
    3526             bRemove                      = true;
     3460            bRemove                         = true;
    35273461            abCandIsInter        [ iCount ] = false; 
    3528             puhInterDirNeighbours[iCount]  = 0;
     3462            puhInterDirNeighbours[ iCount ] = 0;
    35293463            TComMv  cZeroMv;
    3530             pcMvFieldNeighbours[iCount<<1].setMvField( cZeroMv, NOT_VALID );
    3531             pcMvFieldNeighbours[(iCount<<1)+1].setMvField( cZeroMv, NOT_VALID );
     3464            pcMvFieldNeighbours  [ iCount<<1   ].setMvField( cZeroMv, NOT_VALID );
     3465            pcMvFieldNeighbours  [(iCount<<1)+1].setMvField( cZeroMv, NOT_VALID );
    35323466        }
    35333467      }
     
    35353469      {
    35363470#if H_3D_NBDV
    3537         if(iLoop)
     3471        if(iLoop) // For IvMcShift candidate
    35383472        {
    35393473          pcMvFieldNeighbours[iCount<<1    ].getMv().setIDVFlag (false);
     
    35533487}
    35543488
    3555 inline Bool TComDataCU::xFirstDmvAvai( Int& iCount, TComMvField* pcMvFieldNeighbours, Int* iPdmDir, Int iPosDmv, Int* vspFlag, Int& iFirDispCand )
    3556 {
    3557   for ( Int i = (iPdmDir[0] ? 1: 0); i < iCount; i++ )
    3558   {
    3559     if ( ( i == iPosDmv ) || ( vspFlag[ i ] == 1 ) )
     3489inline Bool TComDataCU::xGetPosFirstAvailDmvCand( Int iCount, TComMvField* pcMvFieldNeighbours, Int* ivCandDir, Int posIvDC, Int* vspFlag, Int& posFirstAvailDmvCand )
     3490{
     3491  // ivCandDir[0] == true --> IvMC is available and excluded in loop over merge list.
     3492  for ( Int currListPos = (ivCandDir[0] ? 1 : 0); currListPos < iCount; currListPos++ )
     3493  {
     3494    if ( ( currListPos == posIvDC ) || ( vspFlag[ currListPos ] == 1 ) )
    35603495    {
    35613496      continue;
    35623497    }
    3563     else if((pcMvFieldNeighbours[i<<1].getRefIdx()!=-1) && (getSlice()->getViewIndex() != getSlice()->getRefPic(RefPicList(0), pcMvFieldNeighbours[i<<1].getRefIdx())->getViewIndex()))
    3564     {
    3565       iFirDispCand = i;
     3498    else if((pcMvFieldNeighbours[currListPos<<1].getRefIdx() != -1 ) && (getSlice()->getViewIndex() != getSlice()->getRefPic(RefPicList(0), pcMvFieldNeighbours[currListPos<<1].getRefIdx())->getViewIndex()))
     3499    {
     3500      posFirstAvailDmvCand = currListPos;
    35663501      return true;
    35673502    }
     
    35823517#if H_3D_VSP
    35833518      , Int* vspFlag
    3584 #if MTK_VSP_FIX_ALIGN_WD_E0172
    35853519      , InheritedVSPDisInfo*  inheritedVSPDisInfo
    3586 #endif
    3587 #if MTK_VSP_FIX_E0172
    3588       , Int* vspDir
    3589 #endif
    35903520#endif
    35913521      , Int& numValidMergeCand, Int mrgCandIdx
     
    35943524  UInt uiAbsPartAddr = m_uiAbsIdxInLCU + uiAbsPartIdx;
    35953525#if H_3D_IV_MERGE
     3526  ////////////////////////////
     3527  //////// INIT LISTS ////////
     3528  ////////////////////////////
    35963529  TComMv cZeroMv;
    35973530  Bool abCandIsInter[ MRG_MAX_NUM_CANDS_MEM ];
     
    36113544  }
    36123545  numValidMergeCand = getSlice()->getMaxNumMergeCand();
     3546#if H_3D
     3547  //////////////////////////////////
     3548  //////// DERIVE LOCATIONS ////////
     3549  //////////////////////////////////
     3550#endif
    36133551  // compute the location of the current PU
    36143552  Int xP, yP, nPSW, nPSH;
     
    36223560  deriveLeftBottomIdxGeneral  ( uiAbsPartIdx, uiPUIdx, uiPartIdxLB );
    36233561#if H_3D_IV_MERGE
    3624   Bool ivMvPredFlag   = getSlice()->getVPS()->getIvMvPredFlag( getSlice()->getLayerIdInVps() );
    3625 
    3626   //===== add merge with predicted depth maps =====
    3627 #if QC_INRIA_MTK_MRG_E0126
    3628   TComMv acPdmMv         [8];
    3629   Int aiPdmRefIdx        [8] = {-1, -1, -1, -1, -1, -1, -1, -1};
    3630   Int iPosDmv                = -1;
    3631 #else
    3632   TComMv  acPdmMv       [4];
    3633   Int     aiPdmRefIdx   [4] = {-1, -1, -1, -1};
    3634 #endif
    3635   Bool    bLeftAvai         = false;
    3636   Int     iPosLeftAbove[2]  = {-1, -1};
    3637 
    3638 
    3639   DisInfo cDisInfo;
    3640 
    3641   cDisInfo.bDV = getDvInfo(uiAbsPartIdx).bDV;
    3642 #if H_3D_NBDV_REF
    3643   cDisInfo.m_acDoNBDV = getDvInfo(uiAbsPartIdx).m_acDoNBDV;
    3644 #endif //H_3D_NBDV_REF
    3645   cDisInfo.m_acNBDV = getDvInfo(uiAbsPartIdx).m_acNBDV;
    3646   cDisInfo.m_aVIdxCan = getDvInfo(uiAbsPartIdx).m_aVIdxCan;
    3647 #if MTK_VSP_FIX_ALIGN_WD_E0172
    3648   for(Int i = 0; i < MRG_MAX_NUM_CANDS_MEM; i++)
    3649   {
    3650     inheritedVSPDisInfo[i].m_acDvInfo = cDisInfo;
    3651   }
    3652 #endif
     3562 
     3563  /////////////////////////////////////////////
     3564  //////// TEXTURE MERGE CANDIDATE (T) ////////
     3565  /////////////////////////////////////////////
     3566
    36533567  if( m_pcSlice->getIsDepth())
    36543568  {
     
    36593573    if ( pcTextureCU && !pcTextureCU->isIntra( uiPartIdxCenter ) )
    36603574    {
    3661 #if MTK_TEXTURE_MRGCAND_BUGFIX_E0182
    36623575      pcTextureCU->getMvField( pcTextureCU, uiPartIdxCenter, REF_PIC_LIST_0, pcMvFieldNeighbours[iCount<<1] );
    36633576      Int iValidDepRef = getPic()->isTextRefValid( REF_PIC_LIST_0, pcMvFieldNeighbours[iCount<<1].getRefIdx() );
     
    36993612        iCount ++;
    37003613      }
    3701 #else
    3702       abCandIsInter[iCount] = true;     
    3703       puhInterDirNeighbours[iCount] = pcTextureCU->getInterDir( uiPartIdxCenter );
    3704 #if MTK_SONY_PROGRESSIVE_MV_COMPRESSION_E0170
    3705       pcTextureCU->getMvField( pcTextureCU, uiPartIdxCenter, REF_PIC_LIST_0, pcMvFieldNeighbours[iCount<<1] );
    3706       if (pcMvFieldNeighbours[iCount<<1].getRefIdx()>=0)
    3707 #else
    3708       if( ( puhInterDirNeighbours[iCount] & 1 ) == 1 )
    3709 #endif
    3710       {
    3711 #if !MTK_SONY_PROGRESSIVE_MV_COMPRESSION_E0170
    3712         pcTextureCU->getMvField( pcTextureCU, uiPartIdxCenter, REF_PIC_LIST_0, pcMvFieldNeighbours[iCount<<1] );
    3713 #endif
    3714         TComMv cMvPred = pcMvFieldNeighbours[iCount<<1].getMv();
    3715 
    3716 #if H_3D_IC
    3717         const TComMv cAdd( 1 << ( 2 - 1 ), 1 << ( 2 - 1 ) );
    3718         cMvPred+=cAdd;
    3719         cMvPred>>=2;
    3720         clipMv(cMvPred);
    3721 #endif
    3722         //pcMvFieldNeighbours[iCount<<1].setMvField(cMvPred,pcMvFieldNeighbours[iCount<<1].getRefIdx());
    3723 #if H_3D //Notes from QC: for BVSP coded blocks, the reference index shall not be equal to -1 due to the adoption of JCT3V-D0191
    3724         pcMvFieldNeighbours[iCount<<1].setMvField(cMvPred,pcMvFieldNeighbours[iCount<<1].getRefIdx());
    3725 #endif
    3726       }
    3727      
    3728       if ( getSlice()->isInterB() )
    3729       {
    3730 #if MTK_SONY_PROGRESSIVE_MV_COMPRESSION_E0170
    3731         pcTextureCU->getMvField( pcTextureCU, uiPartIdxCenter, REF_PIC_LIST_1, pcMvFieldNeighbours[(iCount<<1)+1] );
    3732         if (pcMvFieldNeighbours[(iCount<<1)+1].getRefIdx()>=0)
    3733 #else
    3734         if( ( puhInterDirNeighbours[iCount] & 2 ) == 2 )
    3735 #endif
    3736         {
    3737 #if !MTK_SONY_PROGRESSIVE_MV_COMPRESSION_E0170
    3738           pcTextureCU->getMvField( pcTextureCU, uiPartIdxCenter, REF_PIC_LIST_1, pcMvFieldNeighbours[(iCount<<1)+1] );
    3739 #endif
    3740           TComMv cMvPred = pcMvFieldNeighbours[(iCount<<1)+1].getMv();
    3741 #if H_3D_IC
    3742           const TComMv cAdd( 1 << ( 2 - 1 ), 1 << ( 2 - 1 ) );
    3743           cMvPred+=cAdd;
    3744           cMvPred>>=2;
    3745           clipMv(cMvPred);
    3746 #endif
    3747           pcMvFieldNeighbours[(iCount<<1)+1].setMvField(cMvPred,pcMvFieldNeighbours[(iCount<<1)+1].getRefIdx());
    3748         }
    3749       }
    3750 #if MTK_SONY_PROGRESSIVE_MV_COMPRESSION_E0170
    3751       puhInterDirNeighbours[iCount] = (pcMvFieldNeighbours[iCount<<1].getRefIdx()>=0)?1:0;
    3752       puhInterDirNeighbours[iCount] += (pcMvFieldNeighbours[(iCount<<1)+1].getRefIdx()>=0)?2:0;
    3753 #endif
    3754 #if H_3D_NBDV
    3755       pcMvFieldNeighbours[iCount<<1    ].getMv().setIDVFlag (false);
    3756       pcMvFieldNeighbours[(iCount<<1)+1].getMv().setIDVFlag (false);
    3757 #endif
    3758       if ( mrgCandIdx == iCount )
    3759       {
    3760         return;
    3761       }
    3762       iCount ++;
    3763 #endif//Bug fix
    3764     }
    3765   }
    3766 
    3767 #if QC_INRIA_MTK_MRG_E0126
    3768   Int iPdmDir[4] = {0, 0, 0, 0};
    3769 #else
    3770   Int iPdmDir[2] = {0, 0};
    3771 #endif
     3614    }
     3615  }
     3616
     3617  //////////////////////////////////
     3618  //////// GET DISPARITIES  ////////
     3619  //////////////////////////////////
     3620
     3621  DisInfo cDisInfo = getDvInfo(uiAbsPartIdx);
     3622
     3623  for(Int i = 0; i < MRG_MAX_NUM_CANDS_MEM; i++)
     3624  {
     3625    inheritedVSPDisInfo[i].m_acDvInfo = cDisInfo;
     3626  }
     3627
     3628  /////////////////////////////////////////////////////////////////
     3629  //////// DERIVE IvMC, IvMCShift,IvDCShift, IvDC  Candidates /////
     3630  /////////////////////////////////////////////////////////////////
     3631
     3632  Int  posIvDC          = -1;
     3633  Bool bLeftAvai        = false;
     3634  Int  iPosLeftAbove[2] = {-1, -1};
     3635
     3636
     3637  // { IvMCL0, IvMCL1, IvDCL0, IvDCL1, IvMCL0Shift, IvMCL1Shift, IvDCL0Shift, IvDCL1Shift }; 
     3638  // An enumerator would be appropriate here!
     3639  TComMv ivCandMv    [8];
     3640  Int    ivCandRefIdx[8] = {-1, -1, -1, -1, -1, -1, -1, -1};
     3641
     3642  // { IvMC, IvDC, IvMCShift, IvDCShift }; 
     3643  Int    ivCandDir   [4] = {0, 0, 0, 0};
     3644
     3645  Bool ivMvPredFlag   = getSlice()->getVPS()->getIvMvPredFlag( getSlice()->getLayerIdInVps() );
    37723646 
    37733647  if ( ivMvPredFlag )
    37743648  {
    3775     getInterViewMergeCands(uiPUIdx, aiPdmRefIdx, acPdmMv, &cDisInfo, iPdmDir );
     3649    getInterViewMergeCands(uiPUIdx, ivCandRefIdx, ivCandMv, &cDisInfo, ivCandDir );
    37763650  } 
    3777    
    3778   Int iPdmInterDir;
    3779 
    3780   if( iPdmDir[0] )
     3651 
     3652  ///////////////////////////////////////////////
     3653  //////// INTER VIEW MOTION COMP(IvMC) /////////
     3654  ///////////////////////////////////////////////
     3655
     3656  if( ivCandDir[0] )
    37813657  {
    37823658    abCandIsInter        [ iCount ] = true;
    3783     puhInterDirNeighbours[ iCount ] = iPdmDir[0];
    3784     iPdmInterDir                    = iPdmDir[0];
    3785 
    3786     if( ( iPdmInterDir & 1 ) == 1 )
    3787     {
    3788       pcMvFieldNeighbours[ iCount<<1    ].setMvField( acPdmMv[ 0 ], aiPdmRefIdx[ 0 ] );
    3789     }
    3790     if( ( iPdmInterDir & 2 ) == 2 )
    3791     {
    3792       pcMvFieldNeighbours[(iCount<<1)+1 ].setMvField( acPdmMv[ 1 ], aiPdmRefIdx[ 1 ] );
     3659    puhInterDirNeighbours[ iCount ] = ivCandDir[0];   
     3660
     3661    if( ( ivCandDir[0] & 1 ) == 1 )
     3662    {
     3663      pcMvFieldNeighbours[ iCount<<1    ].setMvField( ivCandMv[ 0 ], ivCandRefIdx[ 0 ] );
     3664    }
     3665    if( ( ivCandDir[0] & 2 ) == 2 )
     3666    {
     3667      pcMvFieldNeighbours[(iCount<<1)+1 ].setMvField( ivCandMv[ 1 ], ivCandRefIdx[ 1 ] );
    37933668    }
    37943669
     
    37993674    iCount ++;
    38003675  }
     3676
    38013677  // early termination
    38023678  if (iCount == getSlice()->getMaxNumMergeCand())
     
    38063682#endif
    38073683
     3684#if H_3D
     3685  ////////////////////////////
     3686  //////// LEFT (A1) /////////
     3687  ////////////////////////////
     3688#endif
    38083689  //left
    38093690  UInt uiLeftPartIdx = 0;
     
    38523733#if H_3D_VSP
    38533734      if (pcCULeft->getVSPFlag(uiLeftPartIdx) == 1)
    3854 #if MTK_VSP_FIX_E0172 || MTK_VSP_FIX_ALIGN_WD_E0172
    3855       {
    3856 #endif
     3735      {
    38573736        vspFlag[iCount] = 1;
    3858 #if MTK_VSP_FIX_ALIGN_WD_E0172
    38593737        xInheritVSPDisInfo(pcCULeft,uiLeftPartIdx,iCount,inheritedVSPDisInfo);
    38603738      }
    38613739#endif
    3862 #if MTK_VSP_FIX_E0172
    3863         vspDir[iCount] = pcCULeft->getVSPDir( uiLeftPartIdx );
    3864       }
    3865 #endif
    3866 #endif
    38673740      if ( mrgCandIdx == iCount )
    38683741      {
     
    38713744      iCount ++;
    38723745    }
    3873 #else
     3746#else // H_3D_IV_MERGE
    38743747    if ( mrgCandIdx == iCount )
    38753748    {
     
    38773750    }
    38783751    iCount ++;
    3879 #endif
     3752#endif // H_3D_IV_MERGE
    38803753  }
    38813754 
     
    38853758    return;
    38863759  }
     3760#if H_3D
     3761  ////////////////////////////
     3762  //////// ABOVE (B1) ////////
     3763  ////////////////////////////
     3764#endif
    38873765  // above
    38883766  UInt uiAbovePartIdx = 0;
     
    39173795        puhInterDirNeighbours[iCount]   = 0;
    39183796
    3919         pcMvFieldNeighbours[iCount<<1].setMvField( cZeroMv, NOT_VALID );
     3797        pcMvFieldNeighbours[iCount<<1]    .setMvField( cZeroMv, NOT_VALID );
    39203798        pcMvFieldNeighbours[(iCount<<1)+1].setMvField( cZeroMv, NOT_VALID );
    39213799        break;
    39223800      }
    39233801    }
     3802
    39243803    if(!bRemoveSpa)
    39253804    {
     
    39313810#if H_3D_VSP
    39323811      if (pcCUAbove->getVSPFlag(uiAbovePartIdx) == 1)
    3933 #if MTK_VSP_FIX_E0172 || MTK_VSP_FIX_ALIGN_WD_E0172
    3934       {
    3935 #endif
     3812      {
     3813
    39363814        vspFlag[iCount] = 1;
    3937 #if MTK_VSP_FIX_ALIGN_WD_E0172
    39383815        xInheritVSPDisInfo(pcCUAbove,uiAbovePartIdx,iCount,inheritedVSPDisInfo);
    39393816      }
    39403817#endif
    3941 #if MTK_VSP_FIX_E0172
    3942         vspDir[iCount] = pcCUAbove->getVSPDir( uiAbovePartIdx );
    3943       }
    3944 #endif
    3945 #endif
    39463818      if ( mrgCandIdx == iCount )
    39473819      {
     
    39503822      iCount ++;
    39513823    }
    3952 #else
     3824#else // H_3D_IV_MERGE
    39533825    if ( mrgCandIdx == iCount )
    39543826    {
     
    39563828    }
    39573829    iCount ++;
    3958 #endif
     3830#endif // H_3D_IV_MERGE
    39593831  }
    39603832  // early termination
     
    39633835    return;
    39643836  }
     3837
     3838#if H_3D
     3839  //////////////////////////////////
     3840  //////// ABOVE RIGHT (B0) ////////
     3841  //////////////////////////////////
     3842#endif
    39653843
    39663844  // above right
     
    39883866#if H_3D_VSP
    39893867    if (pcCUAboveRight->getVSPFlag(uiAboveRightPartIdx) == 1)
    3990 #if MTK_VSP_FIX_E0172 || MTK_VSP_FIX_ALIGN_WD_E0172
    3991     {
    3992 #endif
     3868    {
    39933869      vspFlag[iCount] = 1;
    3994 #if MTK_VSP_FIX_ALIGN_WD_E0172
    39953870      xInheritVSPDisInfo(pcCUAboveRight,uiAboveRightPartIdx,iCount,inheritedVSPDisInfo);
    39963871    }
    3997 #endif
    3998 #if MTK_VSP_FIX_E0172
    3999       vspDir[iCount] = pcCUAboveRight->getVSPDir( uiAboveRightPartIdx);
    4000     }
    4001 #endif
    40023872#endif
    40033873    if ( mrgCandIdx == iCount )
     
    40143884
    40153885#if H_3D_IV_MERGE
    4016   if( iPdmDir[1] )
     3886  /////////////////////////////////////////////
     3887  //////// INTER VIEW DISP COMP (IvDC) ////////
     3888  /////////////////////////////////////////////
     3889
     3890  if( ivCandDir[1] )
    40173891  {
    40183892    assert(iCount < getSlice()->getMaxNumMergeCand());
    40193893    abCandIsInter        [ iCount ] = true;
    4020     puhInterDirNeighbours[ iCount ] = iPdmDir[1];
    4021     if( ( iPdmDir[1] & 1 ) == 1 )
    4022     {
    4023       pcMvFieldNeighbours[ iCount<<1    ].setMvField( acPdmMv[ 2 ], aiPdmRefIdx[ 2 ] );
    4024     }
    4025     if( ( iPdmDir[1] & 2 ) == 2 )
    4026     {
    4027       pcMvFieldNeighbours[(iCount<<1)+1 ].setMvField( acPdmMv[ 3 ], aiPdmRefIdx[ 3 ] );
     3894    puhInterDirNeighbours[ iCount ] = ivCandDir[1];
     3895    if( ( ivCandDir[1] & 1 ) == 1 )
     3896    {
     3897      pcMvFieldNeighbours[ iCount<<1    ].setMvField( ivCandMv[ 2 ], ivCandRefIdx[ 2 ] );
     3898    }
     3899    if( ( ivCandDir[1] & 2 ) == 2 )
     3900    {
     3901      pcMvFieldNeighbours[(iCount<<1)+1 ].setMvField( ivCandMv[ 3 ], ivCandRefIdx[ 3 ] );
    40283902    }
    40293903
     
    40323906    {
    40333907      Int iCnloop = iPosLeftAbove[i];
    4034       if(iCnloop == -1)
     3908      if ( iCnloop == -1 )
     3909      {
    40353910        continue;
     3911      }
    40363912      if(puhInterDirNeighbours[iCount] == puhInterDirNeighbours[iCnloop] && pcMvFieldNeighbours[iCnloop<<1]==pcMvFieldNeighbours[(iCount<<1)] && pcMvFieldNeighbours[(iCnloop<<1)+1]==pcMvFieldNeighbours[(iCount<<1)+1])
    40373913      {
     
    40513927      pcMvFieldNeighbours[(iCount<<1)+1].getMv().setIDVFlag (false);
    40523928#endif
    4053 #if QC_INRIA_MTK_MRG_E0126
    4054       iPosDmv  = iCount;
    4055 #endif
     3929      posIvDC  = iCount;
    40563930      if ( mrgCandIdx == iCount )
    40573931        return;
     
    40653939    }
    40663940  }
    4067 #endif
     3941#endif // H_3D_IV_MERGE
    40683942
    40693943#if H_3D_VSP
    4070 #if MTK_VSP_FIX_E0172
    4071   if ( xAddVspCand( H_3D_VSP_POSITION, mrgCandIdx, &cDisInfo, iCount, abCandIsInter, pcMvFieldNeighbours, puhInterDirNeighbours, vspFlag, vspDir ) )
    4072 #else
    4073   if ( xAddVspCand( H_3D_VSP_POSITION, mrgCandIdx, &cDisInfo, iCount, abCandIsInter, pcMvFieldNeighbours, puhInterDirNeighbours, vspFlag ) )
    4074 #endif
     3944  /////////////////////////////////////////////////
     3945  //////// VIEW SYNTHESIS PREDICTION (VSP) ////////
     3946  /////////////////////////////////////////////////
     3947
     3948  if ( xAddVspCand( mrgCandIdx, &cDisInfo, iCount, abCandIsInter, pcMvFieldNeighbours, puhInterDirNeighbours, vspFlag ) )
     3949  {
    40753950    return;
     3951  }
     3952
    40763953  // early termination
    40773954  if (iCount == getSlice()->getMaxNumMergeCand())
     3955  {
    40783956    return;
     3957  }
     3958#endif
     3959#if H_3D
     3960  ///////////////////////////////////
     3961  //////// LEFT BOTTOM (A0) ////////
     3962  ///////////////////////////////////
    40793963#endif
    40803964
     
    41033987#if H_3D_VSP
    41043988    if (pcCULeftBottom->getVSPFlag(uiLeftBottomPartIdx) == 1)
    4105 #if MTK_VSP_FIX_E0172 || MTK_VSP_FIX_ALIGN_WD_E0172
    4106     {
    4107 #endif
     3989    {
    41083990      vspFlag[iCount] = 1;
    4109 #if MTK_VSP_FIX_ALIGN_WD_E0172
    41103991      xInheritVSPDisInfo(pcCULeftBottom,uiLeftBottomPartIdx,iCount,inheritedVSPDisInfo);
    41113992    }
    4112 #endif
    4113 #if MTK_VSP_FIX_E0172
    4114       vspDir[iCount] = pcCULeftBottom->getVSPDir( uiLeftBottomPartIdx);
    4115     }
    4116 #endif
    41173993#endif
    41183994    if ( mrgCandIdx == iCount )
     
    41274003    return;
    41284004  }
     4005#if H_3D
     4006  ///////////////////////////////////
     4007  //////// LEFT ABOVE (B2) ////////
     4008  ///////////////////////////////////
     4009#endif
     4010
    41294011  // above left
    41304012  if( iCount < 4 )
     
    41544036#if H_3D_VSP
    41554037      if (pcCUAboveLeft->getVSPFlag(uiAboveLeftPartIdx) == 1)
    4156 #if MTK_VSP_FIX_E0172 || MTK_VSP_FIX_ALIGN_WD_E0172
    4157       {
    4158 #endif
     4038      {
    41594039        vspFlag[iCount] = 1;
    4160 #if MTK_VSP_FIX_ALIGN_WD_E0172
    41614040        xInheritVSPDisInfo(pcCUAboveLeft,uiAboveLeftPartIdx,iCount,inheritedVSPDisInfo);
    41624041      }
    4163 #endif
    4164 #if MTK_VSP_FIX_E0172
    4165         vspDir[iCount] = pcCUAboveLeft->getVSPDir( uiAboveLeftPartIdx);
    4166       }
    4167 #endif
    41684042#endif
    41694043      if ( mrgCandIdx == iCount )
     
    41794053    return;
    41804054  }
    4181 #if QC_INRIA_MTK_MRG_E0126
     4055#if H_3D_IV_MERGE
     4056  ////////////////////////////////////////////////////
     4057  //////// SHIFTED IV (IvMCShift + IvDCShift) ////////
     4058  ////////////////////////////////////////////////////
     4059
    41824060  if(  ivMvPredFlag  )
    41834061  {
    4184     if(xAddIvMRGCand( mrgCandIdx,  iCount, abCandIsInter, pcMvFieldNeighbours, puhInterDirNeighbours, iPdmDir, acPdmMv, aiPdmRefIdx, iPosDmv, vspFlag))
     4062    if(xAddIvMRGCand( mrgCandIdx,  iCount, abCandIsInter, pcMvFieldNeighbours, puhInterDirNeighbours, ivCandDir, ivCandMv, ivCandRefIdx, posIvDC, vspFlag))
    41854063    {
    41864064      return;
     
    41924070    }
    41934071  }
     4072#endif
     4073#if H_3D
     4074  /////////////////////////////////
     4075  //////// Collocate (COL) ////////
     4076  /////////////////////////////////
    41944077#endif
    41954078  if ( getSlice()->getEnableTMVPFlag())
     
    43114194      Bool bValid = true;
    43124195      if ( vspFlag[i] == 1 || vspFlag[j] == 1 )
     4196      {
    43134197        bValid = false;
     4198      }
    43144199      if( !m_pcSlice->getVPS()->getViewSynthesisPredFlag( m_pcSlice->getLayerIdInVps() ) )
     4200      {
    43154201        assert(bValid == true);
     4202      }
    43164203#endif
    43174204#if H_3D_VSP
     
    43744261  numValidMergeCand = uiArrayAddr;
    43754262}
    4376 #if MTK_VSP_FIX_ALIGN_WD_E0172
     4263#if H_3D_VSP
    43774264inline Void TComDataCU::xInheritVSPDisInfo(TComDataCU* pcCURef, UInt uiAbsPartIdx, Int iCount, InheritedVSPDisInfo*  inheritedVSPDisInfo)
    43784265{
     
    49434830
    49444831  // use coldir.
     4832#if H_MV5
     4833  TComPic *pColPic = getSlice()->getRefPic( RefPicList(getSlice()->isInterB() ? 1-getSlice()->getColFromL0Flag() : 0), getSlice()->getColRefIdx());
     4834#else
    49454835#if H_MV
    49464836  TComPic *pColPic; 
     
    49554845#else
    49564846  TComPic *pColPic = getSlice()->getRefPic( RefPicList(getSlice()->isInterB() ? 1-getSlice()->getColFromL0Flag() : 0), getSlice()->getColRefIdx());
     4847#endif
    49574848#endif
    49584849  TComDataCU *pColCU = pColPic->getCU( uiCUAddr );
     
    57705661          pDInfo->m_acNBDV = cDispVec;
    57715662          pDInfo->m_aVIdxCan = cIDVInfo.m_aVIdxCan[iList][ curPos ];
    5772 #if !MTK_DVMCP_FIX_E0172
    5773           assert(pDInfo->m_aVIdxCan == 0); //Notes from QC: only works for CTC
    5774 #endif
    57755663#if H_3D_NBDV_REF
    57765664          TComPic* picDepth = getSlice()->getIvPic( true, pDInfo->m_aVIdxCan );
     
    59425830          paIDVInfo->m_acMvCand[iList][ uiMvpDvPos ] = TComMv( cMvPred.getIDVHor(), cMvPred.getIDVVer() );
    59435831          //Notes from QC: DvMCP is implemented in a way that doesnE½t carry the reference view identifier as NBDV. It only works for CTC and needs to be fixed to be aligned with other part of the NBDV design.
    5944 #if MTK_DVMCP_FIX_E0172
    59455832          paIDVInfo->m_aVIdxCan[iList][ uiMvpDvPos ] = cMvPred.getIDVVId();
    5946 #else 
    5947           paIDVInfo->m_aVIdxCan[iList][ uiMvpDvPos ] = 0;
    5948 #endif
    59495833          paIDVInfo->m_bAvailab[iList][ uiMvpDvPos ] = true;
    59505834          paIDVInfo->m_bFound                        = true;
     
    60115895  }
    60125896}
    6013 #if MTK_VSP_FIX_ALIGN_WD_E0172
     5897#if H_3D_VSP
    60145898Void TComDataCU::setDvInfoSubParts( DisInfo cDvInfo, UInt uiAbsPartIdx, UInt uiPUIdx, UInt uiDepth )
    60155899{
     
    61506034TComDataCU::getInterViewMergeCands(UInt uiPartIdx, Int* paiPdmRefIdx, TComMv* pacPdmMv, DisInfo* pDInfo, Int* availableMcDc )
    61516035{
    6152   TComSlice*    pcSlice         = getSlice (); 
    6153   Int iViewIndex = pDInfo->m_aVIdxCan;
     6036  TComSlice*    pcSlice = getSlice (); 
     6037  Int iViewIndex        = pDInfo->m_aVIdxCan;
     6038 
    61546039  //--- get base CU/PU and check prediction mode ---
    61556040  TComPic*    pcBasePic   = pcSlice->getIvPic( false, iViewIndex );
     
    61746059  TComMv      cDv = depthRefineFlag ? pDInfo->m_acDoNBDV : pDInfo->m_acNBDV;
    61756060 
    6176 #if !QC_INRIA_MTK_MRG_E0126
    6177   Int         iBasePosX   = Clip3( 0, pcBaseRec->getWidth () - 1, iCurrPosX + ( (cDv.getHor() + 2 ) >> 2 ) );
    6178   Int         iBasePosY   = Clip3( 0, pcBaseRec->getHeight() - 1, iCurrPosY + ( (cDv.getVer() + 2 ) >> 2 ));
    6179 
    6180   Int         iBaseCUAddr;
    6181   Int         iBaseAbsPartIdx;
    6182   pcBaseRec->getCUAddrAndPartIdx( iBasePosX , iBasePosY , iBaseCUAddr, iBaseAbsPartIdx );
    6183 
    6184   TComDataCU* pcBaseCU    = pcBasePic->getCU( iBaseCUAddr );
    6185 #endif
    6186 #if QC_INRIA_MTK_MRG_E0126
    61876061  Bool abPdmAvailable[8] =  {false, false, false, false, false, false, false, false};
    6188 #else
    6189   Bool abPdmAvailable[4] = {false, false, false, false};
    6190 #endif
    61916062#if H_3D_NBDV
    6192 #if QC_INRIA_MTK_MRG_E0126
    61936063  for( Int i = 0; i < 8; i++)
    6194 #else
    6195   for( Int i = 0; i < 4; i++)
    6196 #endif
    61976064  {
    61986065    pacPdmMv[i].setIDVFlag   (false);
    61996066  }
    62006067#endif
    6201 #if QC_INRIA_MTK_MRG_E0126
    6202   for(Int iLoopCan = 0; iLoopCan < 2; iLoopCan ++)
    6203   {
     6068
     6069  ////////////////////////////////
     6070  /////// IvMC + IvMCShift ///////
     6071  ////////////////////////////////
     6072
     6073  for(Int iLoopCan = 0; iLoopCan < 2; iLoopCan ++) 
     6074  {
     6075    // iLoopCan == 0 --> IvMC
     6076    // iLoopCan == 1 --> IvMCShift
     6077
    62046078    Int         iBaseCUAddr;
    62056079    Int         iBaseAbsPartIdx;
    62066080
    6207     Int offsetW = (iLoopCan == 0) ? 0 : ( ((iWidth/2)*4) + 4 );
     6081    Int offsetW = (iLoopCan == 0) ? 0 : ( ((iWidth /2)*4) + 4 );
    62086082    Int offsetH = (iLoopCan == 0) ? 0 : ( ((iHeight/2)*4) + 4 );
    6209    
     6083
    62106084    Int         iBasePosX   = Clip3( 0, pcBaseRec->getWidth () - 1, iCurrPosX + ( (cDv.getHor() + offsetW + 2 ) >> 2 ) );
    62116085    Int         iBasePosY   = Clip3( 0, pcBaseRec->getHeight() - 1, iCurrPosY + ( (cDv.getVer() + offsetH + 2 ) >> 2 ) );
     
    62136087
    62146088    TComDataCU* pcBaseCU    = pcBasePic->getCU( iBaseCUAddr );
    6215 #endif
    6216   if(!( pcBaseCU->getPredictionMode( iBaseAbsPartIdx ) == MODE_INTRA ))
    6217   {
    6218     for( UInt uiCurrRefListId = 0; uiCurrRefListId < 2; uiCurrRefListId++ )
    6219     {
    6220       RefPicList  eCurrRefPicList = RefPicList( uiCurrRefListId );
    6221 
    6222       Bool stopLoop = false;
    6223       for(Int iLoop = 0; iLoop < 2 && !stopLoop; ++iLoop)
    6224       {
    6225         RefPicList eBaseRefPicList = (iLoop ==1)? RefPicList( 1 -  uiCurrRefListId ) : RefPicList( uiCurrRefListId );
    6226         TComMvField cBaseMvField;
    6227         pcBaseCU->getMvField( pcBaseCU, iBaseAbsPartIdx, eBaseRefPicList, cBaseMvField );
    6228         Int         iBaseRefIdx     = cBaseMvField.getRefIdx();
    6229         if (iBaseRefIdx >= 0)
     6089    if(!( pcBaseCU->getPredictionMode( iBaseAbsPartIdx ) == MODE_INTRA ))
     6090    {
     6091      // Loop reference picture list of current slice (X in spec).
     6092      for( UInt uiCurrRefListId = 0; uiCurrRefListId < 2; uiCurrRefListId++ )       
     6093      {
     6094        RefPicList  eCurrRefPicList = RefPicList( uiCurrRefListId );
     6095
     6096        Bool stopLoop = false;
     6097        // Loop reference picture list of candidate slice (Y in spec)
     6098        for(Int iLoop = 0; iLoop < 2 && !stopLoop; ++iLoop)
    62306099        {
    6231           Int iBaseRefPOC = pcBaseCU->getSlice()->getRefPOC(eBaseRefPicList, iBaseRefIdx);
    6232           if (iBaseRefPOC != pcSlice->getPOC())   
     6100          RefPicList eBaseRefPicList = (iLoop ==1)? RefPicList( 1 -  uiCurrRefListId ) : RefPicList( uiCurrRefListId );
     6101          TComMvField cBaseMvField;
     6102          pcBaseCU->getMvField( pcBaseCU, iBaseAbsPartIdx, eBaseRefPicList, cBaseMvField );
     6103          Int         iBaseRefIdx     = cBaseMvField.getRefIdx();
     6104          if (iBaseRefIdx >= 0)
    62336105          {
    6234             for (Int iPdmRefIdx = 0; iPdmRefIdx < pcSlice->getNumRefIdx( eCurrRefPicList ); iPdmRefIdx++)
     6106            Int iBaseRefPOC = pcBaseCU->getSlice()->getRefPOC(eBaseRefPicList, iBaseRefIdx);
     6107            if (iBaseRefPOC != pcSlice->getPOC())   
    62356108            {
    6236               if (iBaseRefPOC == pcSlice->getRefPOC(eCurrRefPicList, iPdmRefIdx))
     6109              for (Int iPdmRefIdx = 0; iPdmRefIdx < pcSlice->getNumRefIdx( eCurrRefPicList ); iPdmRefIdx++)
    62376110              {
    6238 #if QC_INRIA_MTK_MRG_E0126
     6111                if (iBaseRefPOC == pcSlice->getRefPOC(eCurrRefPicList, iPdmRefIdx))
     6112                {
    62396113                  abPdmAvailable[ (uiCurrRefListId + (iLoopCan<<2)) ] = true;
    62406114                  TComMv cMv(cBaseMvField.getHor(), cBaseMvField.getVer());
     
    62436117                  cMv.setIDVHor    (cDv.getHor());                 
    62446118                  cMv.setIDVVer    (cDv.getVer()); 
    6245 #if MTK_DVMCP_FIX_E0172
    62466119                  cMv.setIDVVId    (iViewIndex);
    6247 #endif
    62486120#endif
    62496121                  clipMv( cMv );
    62506122                  paiPdmRefIdx  [ (uiCurrRefListId + (iLoopCan<<2)) ] = iPdmRefIdx;
    62516123                  pacPdmMv      [ (uiCurrRefListId + (iLoopCan<<2)) ] = cMv;
    6252 #else
    6253                 abPdmAvailable[ uiCurrRefListId ] = true;
    6254                 TComMv cMv(cBaseMvField.getHor(), cBaseMvField.getVer());
    6255 #if H_3D_NBDV
    6256                 cMv.setIDVFlag   (true);
    6257                 cMv.setIDVHor    (cDv.getHor());                 
    6258                 cMv.setIDVVer    (cDv.getVer()); 
    6259 #if MTK_DVMCP_FIX_E0172
    6260                 cMv.setIDVVId    (iViewIndex);
    6261 #endif
    6262 #endif
    6263                 clipMv( cMv );
    6264                 paiPdmRefIdx  [ uiCurrRefListId ] = iPdmRefIdx;
    6265                 pacPdmMv      [ uiCurrRefListId ] = cMv;
    6266 #endif
    6267                 stopLoop = true;
    6268                 break;
     6124                  stopLoop = true;
     6125                  break;
     6126                }
    62696127              }
    62706128            }
     
    62746132    }
    62756133  }
    6276 #if QC_INRIA_MTK_MRG_E0126
    6277   }
    6278 #endif
    6279 #if QC_INRIA_MTK_MRG_E0126
    62806134  for(Int iLoopCan = 0; iLoopCan < 2; iLoopCan ++)
    62816135  {
    62826136    availableMcDc[(iLoopCan << 1)] = ( abPdmAvailable[(iLoopCan<<2)] ? 1 : 0 ) + ( abPdmAvailable[1 + (iLoopCan<<2)] ? 2 : 0);
    62836137  }
    6284 #else
    6285   availableMcDc[0] = ( abPdmAvailable[0] ? 1 : 0 ) + ( abPdmAvailable[1] ? 2 : 0 );
    6286 #endif
     6138 
     6139 
     6140  ////////////////////////////////
     6141  /////// IvDC + IvDCShift ///////
     6142  ////////////////////////////////
     6143 
    62876144  for( Int iRefListId = 0; iRefListId < 2 ; iRefListId++ )
    62886145  {
     
    62916148    for( Int iPdmRefIdx = 0; iPdmRefIdx < iNumRefPics; iPdmRefIdx++ )
    62926149    {
    6293 #if MTK_DIVMC_FIX_E0172
    62946150      if(( pcSlice->getRefPOC( eRefPicListDMV, iPdmRefIdx ) == pcSlice->getPOC()) && (pcSlice->getRefPic( eRefPicListDMV, iPdmRefIdx )->getViewIndex() == pDInfo->m_aVIdxCan))
    6295 #else
    6296       if( pcSlice->getRefPOC( eRefPicListDMV, iPdmRefIdx ) == pcSlice->getPOC())
    6297 #endif
    6298       {
    6299 #if QC_INRIA_MTK_MRG_E0126
     6151      {
    63006152        for(Int iLoopCan = 0; iLoopCan < 2; iLoopCan ++)
    63016153        {
     
    63126164        }
    63136165        break;
    6314 #else
    6315         abPdmAvailable[ iRefListId+2 ] = true;
    6316         paiPdmRefIdx  [ iRefListId+2 ] = iPdmRefIdx;
    6317 
    6318 #if H_3D_NBDV_REF
    6319         TComMv cMv = depthRefineFlag ? pDInfo->m_acDoNBDV : pDInfo->m_acNBDV;
    6320 #endif // H_3D_NBDV_REF
    6321         cMv.setVer(0);
    6322         clipMv( cMv );
    6323         pacPdmMv      [ iRefListId + 2] = cMv;
    6324         break;
    6325 #endif
    6326       }
    6327     }
    6328   }
    6329 #if QC_INRIA_MTK_MRG_E0126
     6166      }
     6167    }
     6168  }
    63306169  for(Int iLoopCan = 0; iLoopCan < 2; iLoopCan ++)
    63316170  {
    63326171    availableMcDc[1 + (iLoopCan << 1)] = ( abPdmAvailable[2 + (iLoopCan<<2)] ? 1 : 0 ) + ( abPdmAvailable[3 + (iLoopCan<<2)] ? 2 : 0 );
    63336172  }
    6334 #else
    6335   availableMcDc[1] = ( abPdmAvailable[2] ? 1 : 0 ) + ( abPdmAvailable[3] ? 2 : 0 );
    6336 #endif
    63376173  return false;
    63386174}
     
    64066242  for( UInt ui = 0; ui < uiCurrPartNumb; ui++ ) { m_dmmWedgeTabIdx[dmmType][uiAbsPartIdx+ui] = tabIdx; }
    64076243}
    6408 #if !SEC_DMM2_E0146
     6244#if !SEC_DMM2_E0146_HHIFIX
    64096245Void  TComDataCU::setDmm2DeltaEndSubParts( Int iDelta, UInt uiAbsPartIdx, UInt uiDepth )
    64106246{
  • trunk/source/Lib/TLibCommon/TComDataCU.h

    r608 r622  
    197197  Char*         m_piVSPFlag;          ///< array of VSP flags to indicate whehter a block uses VSP or not
    198198                                      ///< 0: non-VSP; 1: VSP
    199 #if MTK_VSP_FIX_E0172
    200   Char*         m_piVSPDir;           ///< 0: LIST0; 1: LIST1
    201 #endif
    202199#endif
    203200#if H_3D_ARP
     
    211208#if H_3D_DIM_DMM
    212209  UInt*         m_dmmWedgeTabIdx[DMM_NUM_TYPE];
    213 #if !SEC_DMM2_E0146
     210#if !SEC_DMM2_E0146_HHIFIX
    214211  Int*          m_dmm2DeltaEnd;
    215212#endif
     
    256253  Bool          xAddMVPCandOrder      ( AMVPInfo* pInfo, RefPicList eRefPicList, Int iRefIdx, UInt uiPartUnitIdx, MVP_DIR eDir );
    257254#if H_3D_VSP
    258 #if MTK_VSP_FIX_E0172
    259   Bool          xAddVspCand( UChar ucVspMergePos, Int mrgCandIdx, DisInfo* pDInfo, Int& iCount,
    260                              Bool* abCandIsInter, TComMvField* pcMvFieldNeighbours, UChar* puhInterDirNeighbours, Int* vspFlag, Int* vspDir );
    261 #else
    262   Bool          xAddVspCand( UChar ucVspMergePos, Int mrgCandIdx, DisInfo* pDInfo, Int& iCount,
     255  Bool          xAddVspCand( Int mrgCandIdx, DisInfo* pDInfo, Int& iCount,
    263256                             Bool* abCandIsInter, TComMvField* pcMvFieldNeighbours, UChar* puhInterDirNeighbours, Int* vspFlag );
    264257#endif
    265 #endif
    266 #if QC_INRIA_MTK_MRG_E0126
    267   Bool          xAddIvMRGCand( Int mrgCandIdx, Int& iCount, Bool* abCandIsInter, TComMvField* pcMvFieldNeighbours, UChar* puhInterDirNeighbours, Int*   iPdmDir, TComMv* acPdmMv,
    268                                Int* aiPdmRefIdx, Int iPosDmv, Int* vspFlag );
    269   Bool          xFirstDmvAvai( Int& iCount, TComMvField* pcMvFieldNeighbours, Int*  iPdmDir, Int iPosDmv, Int* vspFlag, Int& iFirDispCand );
     258#if H_3D_IV_MERGE
     259  Bool          xAddIvMRGCand( Int mrgCandIdx, Int& iCount, Bool* abCandIsInter, TComMvField* pcMvFieldNeighbours, UChar* puhInterDirNeighbours, Int*   ivCandDir, TComMv* ivCandMv,
     260                               Int* ivCandRefIdx, Int posIvDC, Int* vspFlag );
     261  Bool          xGetPosFirstAvailDmvCand( Int iCount, TComMvField* pcMvFieldNeighbours, Int*  ivCandDir, Int posIvDC, Int* vspFlag, Int& iFirDispCand );
    270262#endif
    271263
     
    442434  template <typename T>
    443435  Void          setSubPart            ( T bParameter, T* pbBaseLCU, UInt uiCUAddr, UInt uiCUDepth, UInt uiPUIdx );
    444 #if MTK_VSP_FIX_ALIGN_WD_E0172
     436#if H_3D_VSP
    445437  template<typename T>
    446438  Void          setSubPartT           ( T uiParameter, T* puhBaseLCU, UInt uiCUAddr, UInt uiCUDepth, UInt uiPUIdx );
     
    471463#if H_3D_NBDV
    472464  Void          setDvInfoSubParts     ( DisInfo cDvInfo, UInt uiAbsPartIdx, UInt uiDepth );
    473 #if MTK_VSP_FIX_ALIGN_WD_E0172
    474465  Void          setDvInfoSubParts     ( DisInfo cDvInfo, UInt uiAbsPartIdx, UInt uiPartIdx, UInt uiDepth);
    475 #endif
    476466  DisInfo*      getDvInfo             ()                        { return m_pDvInfo;                 }
    477467  DisInfo       getDvInfo             (UInt uiIdx)              { return m_pDvInfo[uiIdx];          }
     
    555545  Void  setDmmWedgeTabIdxSubParts     ( UInt tabIdx, UInt dmmType, UInt uiAbsPartIdx, UInt uiDepth );
    556546
    557 #if !SEC_DMM2_E0146
     547#if !SEC_DMM2_E0146_HHIFIX
    558548  Int*  getDmm2DeltaEnd               ()                      { return m_dmm2DeltaEnd;        }
    559549  Int   getDmm2DeltaEnd               ( UInt uiIdx )          { return m_dmm2DeltaEnd[uiIdx]; }
     
    682672#if H_3D_VSP
    683673                                            , Int* vspFlag
    684 #if MTK_VSP_FIX_ALIGN_WD_E0172
    685674                                            , InheritedVSPDisInfo*  inheritedVSPDisInfo
    686675#endif
    687 #if MTK_VSP_FIX_E0172
    688                                             , Int* vspDir
    689 #endif
    690 #endif
    691676                                            , Int& numValidMergeCand, Int mrgCandIdx = -1 );
    692 #if MTK_VSP_FIX_ALIGN_WD_E0172
    693   inline Void xInheritVSPDisInfo(TComDataCU* pcCURef, UInt uiAbsPartIdx, Int iCount,  InheritedVSPDisInfo*  inheritedVSPDisInfo);
    694 #endif
     677
    695678#if H_3D_VSP
     679  inline Void   xInheritVSPDisInfo(TComDataCU* pcCURef, UInt uiAbsPartIdx, Int iCount,  InheritedVSPDisInfo*  inheritedVSPDisInfo);
     680
    696681  Char*         getVSPFlag        ()                        { return m_piVSPFlag;          }
    697682  Char          getVSPFlag        ( UInt uiIdx )            { return m_piVSPFlag[uiIdx];   }
    698683  Void          setVSPFlag        ( UInt uiIdx, Int n )     { m_piVSPFlag[uiIdx] = n;      }
    699684  Void          setVSPFlagSubParts( Char iVSPFlag, UInt uiAbsPartIdx, UInt uiPartIdx, UInt uiDepth );
    700 #if MTK_VSP_FIX_E0172
    701   Char*         getVSPDir          ()                        { return m_piVSPDir;                           }
    702   Char          getVSPDir          ( UInt uiIdx )            { return m_piVSPDir[uiIdx];                  }
    703   Void          setVSPDir          ( UInt uiIdx, Int n )     { m_piVSPDir[uiIdx] = n;  }
    704   Void          setVSPDirSubParts  ( Char iVSPDir, UInt uiAbsPartIdx, UInt uiPartIdx, UInt uiDepth );
    705 #endif
    706685#endif
    707686  Void          deriveLeftRightTopIdxGeneral  ( UInt uiAbsPartIdx, UInt uiPartIdx, UInt& ruiPartIdxLT, UInt& ruiPartIdxRT );
  • trunk/source/Lib/TLibCommon/TComMotionInfo.h

    r608 r622  
    7777} IDVInfo;
    7878#endif
    79 #if MTK_VSP_FIX_ALIGN_WD_E0172
     79#if H_3D_VSP
    8080typedef struct _InheritedVSPDisCand
    8181{
  • trunk/source/Lib/TLibCommon/TComMv.h

    r608 r622  
    5858  Short m_iIDVHor;   
    5959  Short m_iIDVVer;   
    60 #if MTK_DVMCP_FIX_E0172
    6160  Short m_iIDVVId;  //view index of the IDV
    62 #endif
    6361#endif
    6462public:
     
    7573  , m_iIDVHor(0)
    7674  , m_iIDVVer(0)
    77 #if MTK_DVMCP_FIX_E0172
    7875  , m_iIDVVId(0)
    79 #endif
    8076#endif
    8177  {
     
    8985  , m_iIDVHor(0)
    9086  , m_iIDVVer(0)
    91 #if MTK_DVMCP_FIX_E0172
    92   , m_iIDVVId(0)
    93 #endif
     87  , m_iIDVVId(0)
    9488#endif
    9589  {
     
    106100 #if H_3D_NBDV
    107101   m_bIDV = false; m_iIDVHor = m_iIDVVer = 0;
    108 #if MTK_DVMCP_FIX_E0172
    109102   m_iIDVVId = 0;
    110 #endif
    111103#endif
    112104  }
     
    115107  Void   setIDVVer  (Short i)                    {m_iIDVVer = i;}
    116108  Void   setIDVFlag (Bool b )                    {m_bIDV    = b;}
    117 #if MTK_DVMCP_FIX_E0172
    118109  Void   setIDVVId  (Short i)                    {m_iIDVVId = i;}
    119 #endif
    120110#endif
    121111  // ------------------------------------------------------------------------------------------------------------------
     
    131121  Short getIDVVer () const { return m_iIDVVer;       }
    132122  Bool  getIDVFlag() const { return m_bIDV;          }
    133 #if MTK_DVMCP_FIX_E0172
    134123  Short getIDVVId () const { return m_iIDVVId;       }
    135 #endif
     124
    136125#endif
    137126  // ------------------------------------------------------------------------------------------------------------------
  • trunk/source/Lib/TLibCommon/TComPrediction.cpp

    r608 r622  
    456456        dmmSegmentation = &(g_dmmWedgeLists[ g_aucConvertToBit[iWidth] ][ pcCU->getDmmWedgeTabIdx( dimType, uiAbsPartIdx ) ]);
    457457      } break;
    458 #if !SEC_DMM2_E0146
     458#if !SEC_DMM2_E0146_HHIFIX
    459459    case( DMM2_IDX ):
    460460      {
     
    588588    pcCU->getPartIndexAndSize( iPartIdx, uiPartAddr, iWidth, iHeight );
    589589#if H_3D_VSP
    590     if ( 0 == pcCU->getVSPFlag(uiPartAddr) )
     590    if ( pcCU->getVSPFlag(uiPartAddr) == 0)
    591591    {
    592592#endif
     
    622622    {
    623623      if ( xCheckIdenticalMotion( pcCU, uiPartAddr ) )
     624      {
    624625        xPredInterUniVSP( pcCU, uiPartAddr, iWidth, iHeight, REF_PIC_LIST_0, pcYuvPred );
     626      }
    625627      else
     628      {
    626629        xPredInterBiVSP ( pcCU, uiPartAddr, iWidth, iHeight, pcYuvPred );
     630      }
    627631    }
    628632#endif
     
    635639
    636640#if H_3D_VSP
    637     if ( 0 == pcCU->getVSPFlag(uiPartAddr) )
     641    if ( pcCU->getVSPFlag(uiPartAddr) == 0 )
    638642    {
    639643#endif
     
    669673    {
    670674      if ( xCheckIdenticalMotion( pcCU, uiPartAddr ) )
     675      {
    671676        xPredInterUniVSP( pcCU, uiPartAddr, iWidth, iHeight, REF_PIC_LIST_0, pcYuvPred );
     677      }
    672678      else
     679      {
    673680        xPredInterBiVSP ( pcCU, uiPartAddr, iWidth, iHeight, pcYuvPred );
     681      }
    674682    }
    675683#endif
     
    722730{
    723731  // Get depth reference
    724 #if MTK_VSP_FIX_E0172
    725   Int vspDir = pcCU->getVSPDir( uiPartAddr );
    726   RefPicList privateRefPicList = (vspDir == 0) ? REF_PIC_LIST_0 : REF_PIC_LIST_1;
    727   Int privateRefIdx = pcCU->getCUMvField( privateRefPicList )->getRefIdx( uiPartAddr );
    728   Int depthRefViewIdx = pcCU->getSlice()->getRefPic(privateRefPicList, privateRefIdx)->getViewIndex();
    729 #else
    730   Int depthRefViewIdx = pcCU->getDvInfo(uiPartAddr).m_aVIdxCan;
    731 #endif
     732  Int       depthRefViewIdx = pcCU->getDvInfo(uiPartAddr).m_aVIdxCan;
    732733  TComPic* pRefPicBaseDepth = pcCU->getSlice()->getIvPic (true, depthRefViewIdx );
    733734  assert(pRefPicBaseDepth != NULL);
     
    748749
    749750  // Do compensation
    750 #if MTK_VSP_FIX_ALIGN_WD_E0172
    751751  TComMv cDv  = pcCU->getDvInfo(uiPartAddr).m_acNBDV;
    752 #else
    753 #if MTK_VSP_FIX_E0172
    754   TComMv cDv  = pcCU->getCUMvField( privateRefPicList )->getMv( uiPartAddr );
    755 #else
    756   TComMv cDv  = pcCU->getCUMvField( eRefPicList )->getMv( uiPartAddr ); // cDv is the disparity vector derived from the neighbors
    757 #endif
    758 #endif // end of MTK_VSP_FIX_ALIGN_WD_E0172
    759752  pcCU->clipMv(cDv);
    760753
     
    935928
    936929    if ( iRefIdx[iRefList] < 0 )
     930    {
    937931      continue;
     932    }
    938933    assert( iRefIdx[iRefList] < pcCU->getSlice()->getNumRefIdx(eRefPicList) );
    939934
     
    27732768
    27742769#if H_3D_DIM_DMM
     2770#if !SEC_DMM2_E0146_HHIFIX
    27752771UInt TComPrediction::xPredWedgeFromIntra( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiWidth, UInt uiHeight, Int iDeltaEnd )
    27762772{
     
    27842780  {
    27852781    UInt dimType =  getDimType( pcTempCU->getLumaIntraDir( uiTempPartIdx ) );
    2786 #if SEC_DMM2_E0146
    2787     if( DMM1_IDX == dimType || DMM3_IDX == dimType )
    2788 #else
    27892782    if( DMM1_IDX == dimType || DMM2_IDX == dimType || DMM3_IDX == dimType )
    2790 #endif
    27912783    {
    27922784      // get offset between current and reference block
     
    28132805  {
    28142806    UInt dimType = getDimType( pcTempCU->getLumaIntraDir( uiTempPartIdx ) );
    2815 #if SEC_DMM2_E0146
    2816     if( DMM1_IDX == dimType || DMM3_IDX == dimType )
    2817 #else
    28182807    if( DMM1_IDX == dimType || DMM2_IDX == dimType || DMM3_IDX == dimType )
    2819 #endif
    28202808    {
    28212809      // get offset between current and reference block
     
    28492837  return 0;
    28502838}
     2839#endif
    28512840
    28522841UInt TComPrediction::xPredWedgeFromTex( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiWidth, UInt uiHeight, UInt intraTabIdx )
     
    28582847  Int           uiColTexIntraDir = pcColTexCU->isIntra( uiTexPartIdx ) ? pcColTexCU->getLumaIntraDir( uiTexPartIdx ) : 255;
    28592848
     2849#if LGE_PKU_DMM3_OVERLAP_E0159_HHIFIX
     2850  assert( uiColTexIntraDir > DC_IDX && uiColTexIntraDir < 35 );
     2851  return g_aauiWdgLstM3[g_aucConvertToBit[uiWidth]][uiColTexIntraDir-2].at(intraTabIdx);
     2852#else
    28602853  if( uiColTexIntraDir > DC_IDX && uiColTexIntraDir < 35 ) { return g_aauiWdgLstM3[g_aucConvertToBit[uiWidth]][uiColTexIntraDir-2].at(intraTabIdx); }
    28612854  else                                                     { return g_dmmWedgeNodeLists[(g_aucConvertToBit[uiWidth])].at(intraTabIdx).getPatternIdx(); }
     2855#endif
    28622856}
    28632857
     
    29142908}
    29152909
     2910#if !SEC_DMM2_E0146_HHIFIX
    29162911Void TComPrediction::xGetBlockOffset( TComDataCU* pcCU, UInt uiAbsPartIdx, TComDataCU* pcRefCU, UInt uiRefAbsPartIdx, UInt& ruiOffsetX, UInt& ruiOffsetY )
    29172912{
     
    33023297}
    33033298#endif
     3299#endif
    33043300#if H_3D_DIM_RBC
    33053301Void TComPrediction::xDeltaDCQuantScaleUp( TComDataCU* pcCU, Pel& rDeltaDC )
  • trunk/source/Lib/TLibCommon/TComPrediction.h

    r608 r622  
    154154  Void xAssignBiSegDCs          ( Pel* ptrDst, UInt dstStride, Bool* biSegPattern, Int patternStride, Pel   valDC1, Pel   valDC2 );
    155155#if H_3D_DIM_DMM
     156#if !SEC_DMM2_E0146_HHIFIX
    156157  UInt xPredWedgeFromIntra      ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiWidth, UInt uiHeight, Int iDeltaEnd = 0 );
     158#endif
    157159  UInt xPredWedgeFromTex        ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiWidth, UInt uiHeight, UInt intraTabIdx );
    158160  Void xPredContourFromTex      ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiWidth, UInt uiHeight, TComWedgelet* pcContourWedge );
     
    160162  Void xCopyTextureLumaBlock    ( TComDataCU* pcCU, UInt uiAbsPartIdx, Pel* piDestBlockY, UInt uiWidth, UInt uiHeight );
    161163
     164#if !SEC_DMM2_E0146_HHIFIX
    162165  Void xGetBlockOffset          ( TComDataCU* pcCU, UInt uiAbsPartIdx, TComDataCU* pcRefCU, UInt uiRefAbsPartIdx, UInt& ruiOffsetX, UInt& ruiOffsetY );
    163166  Bool xGetWedgeIntraDirPredData( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiBlockSize, Int& riSlopeX, Int& riSlopeY, UInt& ruiStartPosX, UInt& ruiStartPosY );
    164167  Void xGetWedgeIntraDirStartEnd( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiBlockSize, Int iDeltaX, Int iDeltaY, UInt uiPMSPosX, UInt uiPMSPosY, UChar& ruhXs, UChar& ruhYs, UChar& ruhXe, UChar& ruhYe, Int iDeltaEnd = 0 );
    165168  UInt xGetWedgePatternIdx      ( UInt uiBlockSize, UChar uhXs, UChar uhYs, UChar uhXe, UChar uhYe );
     169#endif
    166170#endif
    167171#if H_3D_DIM_RBC
  • trunk/source/Lib/TLibCommon/TComRdCost.cpp

    r608 r622  
    484484}
    485485
    486 #if SCU_HS_FAST_DEPTH_INTRA_E0238
     486#if SCU_HS_FAST_DEPTH_INTRA_E0238_HHIFIX
    487487
    488488UInt TComRdCost::calcVAR (Pel* pi0, Int stride, Int width, Int height, Int cuDepth)
  • trunk/source/Lib/TLibCommon/TComRdCost.h

    r608 r622  
    235235  UInt    calcHAD(Int bitDepth, Pel* pi0, Int iStride0, Pel* pi1, Int iStride1, Int iWidth, Int iHeight );
    236236 
    237 #if SCU_HS_FAST_DEPTH_INTRA_E0238
     237#if SCU_HS_FAST_DEPTH_INTRA_E0238_HHIFIX
    238238  UInt    calcVAR(Pel* pi0, Int stride, Int width, Int height, Int cuDepth);
    239239#endif 
  • trunk/source/Lib/TLibCommon/TComRom.cpp

    r608 r622  
    347347{ //2x2   4x4   8x8 16x16 32x32 64x64
    348348     0,    7,   10,   11,   11,   13 };
    349 #if LGE_PKU_DMM3_OVERLAP_E0159
     349#if LGE_PKU_DMM3_OVERLAP_E0159_HHIFIX
    350350const UChar g_dmm3IntraTabIdxBits[6] =
    351351{ //2x2   4x4   8x8 16x16 32x32 64x64
     
    380380Bool g_traceTU = true;
    381381Bool g_disableHLSTrace = false;
    382 UInt64 g_stopAtCounter   = 10803;
     382UInt64 g_stopAtCounter       = 48;
     383Bool g_traceCopyBack         = false;
     384Bool g_decTraceDispDer       = false;
     385Bool g_decTraceMvFromMerge   = false;
    383386#endif
    384387#endif
     
    611614std::vector< std::vector< std::vector<UInt> > > g_aauiWdgLstM3;
    612615
     616#if LGE_PKU_DMM3_OVERLAP_E0159_HHIFIX
     617Void initWedgeLists( Bool initNodeList )
     618#else
    613619Void initWedgeLists( Bool initRefinements )
     620#endif
    614621{
    615622  if( !g_dmmWedgeLists.empty() ) return;
     
    624631    g_dmmWedgeRefLists.push_back( acWedgeRefList );
    625632
     633#if LGE_PKU_DMM3_OVERLAP_E0159_HHIFIX
     634    if( initNodeList )
     635    {
     636#endif
    626637    // create WedgeNodeList
    627638    std::vector<TComWedgeNode> acWedgeNodeList;
     
    633644        cWedgeNode.setPatternIdx( uiPos );
    634645
     646#if !LGE_PKU_DMM3_OVERLAP_E0159_HHIFIX
    635647        if( initRefinements )
    636648        {
     649#endif
    637650          UInt uiRefPos = 0;
    638651          for( Int iOffS = -1; iOffS <= 1; iOffS++ )
     
    681694            }
    682695          }
     696#if !LGE_PKU_DMM3_OVERLAP_E0159_HHIFIX
    683697        }
     698#endif
    684699        acWedgeNodeList.push_back( cWedgeNode );
    685700      }
    686701    }
    687702    g_dmmWedgeNodeLists.push_back( acWedgeNodeList );
     703#if LGE_PKU_DMM3_OVERLAP_E0159_HHIFIX
     704  }
     705#endif
    688706  }
    689707  return;
  • trunk/source/Lib/TLibCommon/TComRom.h

    r608 r622  
    174174extern       std::vector< std::vector< std::vector<UInt> > > g_aauiWdgLstM3;
    175175
     176#if LGE_PKU_DMM3_OVERLAP_E0159_HHIFIX
     177Void initWedgeLists( Bool initNodeList = false );
     178#else
    176179Void initWedgeLists( Bool initRefinements = false );
     180#endif
    177181Void createWedgeList( UInt uiWidth, UInt uiHeight, std::vector<TComWedgelet> &racWedgeList, std::vector<TComWedgeRef> &racWedgeRefList, WedgeResolution eWedgeRes );
    178182Void addWedgeletToList( TComWedgelet cWedgelet, std::vector<TComWedgelet> &racWedgeList, std::vector<TComWedgeRef> &racWedgeRefList );
     
    194198
    195199#ifndef ENC_DEC_TRACE
    196 # define ENC_DEC_TRACE 0
     200#define ENC_DEC_TRACE  0
    197201#endif
    198202
     
    220224 extern Bool   g_tracePU;
    221225 extern Bool   g_traceTU;
    222  extern Bool   g_disableHLSTrace;
    223  extern UInt64 g_stopAtCounter;
     226 extern Bool   g_disableHLSTrace;       // USE g_HLSTraceEnable to toggle HLS trace. Not this one!
     227 extern UInt64 g_stopAtCounter;         // Counter to set breakpoint.
     228 extern Bool   g_traceCopyBack;         // Output samples on copy back 
     229 extern Bool   g_decTraceDispDer; // Trace derived disparity vectors (decoder only)
     230 extern Bool   g_decTraceMvFromMerge;   // Trace motion vectors obtained from merge (decoder only)
    224231
    225232#define DTRACE_CU(x,y)             writeToTraceFile( x,y, g_traceCU );
  • trunk/source/Lib/TLibCommon/TComSlice.cpp

    r608 r622  
    101101, m_enableTMVPFlag                ( true )
    102102#if H_MV
     103#if H_MV5
     104, m_refPicSetInterLayer0           ( NULL )
     105, m_refPicSetInterLayer1           ( NULL )
     106#else
    103107, m_refPicSetInterLayer           ( NULL )
     108#endif
    104109, m_layerId                       (0)
    105110, m_viewId                        (0)
     111#if H_MV5
     112, m_viewIndex                     (0)
     113#endif
    106114#if H_3D
     115#if !H_MV5
    107116, m_viewIndex                     (0)
     117#endif
    108118, m_isDepth                       (false)
     119#endif
     120#if H_MV5
     121, m_pocResetFlag                  (false)
    109122#endif
    110123, m_discardableFlag               (false)
    111124, m_interLayerPredEnabledFlag     (false)
    112125, m_numInterLayerRefPicsMinus1    (0)
     126#if !H_MV5
    113127, m_interLayerSamplePredOnlyFlag  (false)
    114128, m_altCollocatedIndicationFlag   (0)
    115129, m_collocatedRefLayerIdx         (0)
     130#endif
    116131#if H_3D_IC
    117132, m_bApplyIC                      ( false )
     
    149164  for (Int i = 0; i < MAX_NUM_LAYERS; i++ )
    150165  {
     166#if H_MV5
     167   m_interLayerPredLayerIdc[ i ] = i;
     168#else
    151169   m_interLayerPredLayerIdc[ i ] = 0;
     170#endif
    152171  }
    153172#endif
     
    162181  {
    163182    if ( m_depthToDisparityB && m_depthToDisparityB[ i ] )
     183    {
    164184      delete[] m_depthToDisparityB [ i ];
     185    }
    165186
    166187    if ( m_depthToDisparityF && m_depthToDisparityF[ i ] )
     188    {
    167189      delete[] m_depthToDisparityF [ i ];
    168190  }
     191  }
    169192
    170193  if ( m_depthToDisparityF )
     194  {
    171195    delete[] m_depthToDisparityF;
     196  }
    172197
    173198  m_depthToDisparityF = NULL;
     
    362387  }
    363388}
    364 #if H_MV
    365 Void TComSlice::setRefPicList( TComList<TComPic*>& rcListPic, std::vector<TComPic*>& refPicSetInterLayer , Bool checkNumPocTotalCurr)
    366 #else
     389#if H_MV5
     390#if !H_MV
    367391#if FIX1071
    368392Void TComSlice::setRefPicList( TComList<TComPic*>& rcListPic, Bool checkNumPocTotalCurr )
     
    370394Void TComSlice::setRefPicList( TComList<TComPic*>& rcListPic )
    371395#endif
    372 #endif
    373396{
    374397#if FIX1071
     
    380403      ::memset( m_apcRefPicList, 0, sizeof (m_apcRefPicList));
    381404      ::memset( m_aiNumRefIdx,   0, sizeof ( m_aiNumRefIdx ));
    382      
     405
    383406      return;
    384407    }
    385    
    386 #if !H_MV
     408
    387409    m_aiNumRefIdx[0] = getNumRefIdx(REF_PIC_LIST_0);
    388410    m_aiNumRefIdx[1] = getNumRefIdx(REF_PIC_LIST_1);
    389 #endif
    390411  }
    391412
     
    411432    }
    412433  }
     434
     435  for(; i < m_pcRPS->getNumberOfNegativePictures()+m_pcRPS->getNumberOfPositivePictures(); i++)
     436  {
     437    if(m_pcRPS->getUsed(i))
     438    {
     439      pcRefPic = xGetRefPic(rcListPic, getPOC()+m_pcRPS->getDeltaPOC(i));
     440      pcRefPic->setIsLongTerm(0);
     441      pcRefPic->getPicYuvRec()->extendPicBorder();
     442      RefPicSetStCurr1[NumPocStCurr1] = pcRefPic;
     443      NumPocStCurr1++;
     444      pcRefPic->setCheckLTMSBPresent(false); 
     445    }
     446  }
     447
     448  for(i = m_pcRPS->getNumberOfNegativePictures()+m_pcRPS->getNumberOfPositivePictures()+m_pcRPS->getNumberOfLongtermPictures()-1; i > m_pcRPS->getNumberOfNegativePictures()+m_pcRPS->getNumberOfPositivePictures()-1 ; i--)
     449  {
     450    if(m_pcRPS->getUsed(i))
     451    {
     452      pcRefPic = xGetLongTermRefPic(rcListPic, m_pcRPS->getPOC(i), m_pcRPS->getCheckLTMSBPresent(i));
     453      pcRefPic->setIsLongTerm(1);
     454      pcRefPic->getPicYuvRec()->extendPicBorder();
     455      RefPicSetLtCurr[NumPocLtCurr] = pcRefPic;
     456      NumPocLtCurr++;
     457    }
     458    if(pcRefPic==NULL)
     459    {
     460      pcRefPic = xGetLongTermRefPic(rcListPic, m_pcRPS->getPOC(i), m_pcRPS->getCheckLTMSBPresent(i));
     461    }
     462    pcRefPic->setCheckLTMSBPresent(m_pcRPS->getCheckLTMSBPresent(i)); 
     463  }
     464
     465  // ref_pic_list_init
     466  TComPic*  rpsCurrList0[MAX_NUM_REF+1];
     467  TComPic*  rpsCurrList1[MAX_NUM_REF+1];
     468  Int numPocTotalCurr = NumPocStCurr0 + NumPocStCurr1 + NumPocLtCurr;
     469
     470#if FIX1071
     471  if (checkNumPocTotalCurr)
     472  {
     473    // The variable NumPocTotalCurr is derived as specified in subclause 7.4.7.2. It is a requirement of bitstream conformance that the following applies to the value of NumPocTotalCurr:
     474    // “ If the current picture is a BLA or CRA picture, the value of NumPocTotalCurr shall be equal to 0.
     475    // “ Otherwise, when the current picture contains a P or B slice, the value of NumPocTotalCurr shall not be equal to 0.
     476    if (getRapPicFlag())
     477    {
     478      assert(numPocTotalCurr == 0);
     479    }
     480
     481    if (m_eSliceType == I_SLICE)
     482    {
     483      ::memset( m_apcRefPicList, 0, sizeof (m_apcRefPicList));
     484      ::memset( m_aiNumRefIdx,   0, sizeof ( m_aiNumRefIdx ));
     485
     486      return;
     487    }
     488
     489    assert(numPocTotalCurr > 0);
     490
     491    m_aiNumRefIdx[0] = getNumRefIdx(REF_PIC_LIST_0);
     492    m_aiNumRefIdx[1] = getNumRefIdx(REF_PIC_LIST_1);
     493  }
     494#endif
     495
     496  Int cIdx = 0;
     497  for ( i=0; i<NumPocStCurr0; i++, cIdx++)
     498  {
     499    rpsCurrList0[cIdx] = RefPicSetStCurr0[i];
     500  }
     501  for ( i=0; i<NumPocStCurr1; i++, cIdx++)
     502  {
     503    rpsCurrList0[cIdx] = RefPicSetStCurr1[i];
     504  }
     505  for ( i=0; i<NumPocLtCurr;  i++, cIdx++)
     506  {
     507    rpsCurrList0[cIdx] = RefPicSetLtCurr[i];
     508  }
     509  assert(cIdx == numPocTotalCurr);
     510
     511  if (m_eSliceType==B_SLICE)
     512  {
     513    cIdx = 0;
     514    for ( i=0; i<NumPocStCurr1; i++, cIdx++)
     515    {
     516      rpsCurrList1[cIdx] = RefPicSetStCurr1[i];
     517    }
     518    for ( i=0; i<NumPocStCurr0; i++, cIdx++)
     519    {
     520      rpsCurrList1[cIdx] = RefPicSetStCurr0[i];
     521    }
     522    for ( i=0; i<NumPocLtCurr;  i++, cIdx++)
     523    {
     524      rpsCurrList1[cIdx] = RefPicSetLtCurr[i];
     525    }
     526    assert(cIdx == numPocTotalCurr);
     527  }
     528
     529  ::memset(m_bIsUsedAsLongTerm, 0, sizeof(m_bIsUsedAsLongTerm));
     530
     531  for (Int rIdx = 0; rIdx < m_aiNumRefIdx[0]; rIdx ++)
     532  {
     533    cIdx = m_RefPicListModification.getRefPicListModificationFlagL0() ? m_RefPicListModification.getRefPicSetIdxL0(rIdx) : rIdx % numPocTotalCurr;
     534    assert(cIdx >= 0 && cIdx < numPocTotalCurr);
     535    m_apcRefPicList[0][rIdx] = rpsCurrList0[ cIdx ];
     536    m_bIsUsedAsLongTerm[0][rIdx] = ( cIdx >= NumPocStCurr0 + NumPocStCurr1 );
     537  }
     538  if ( m_eSliceType != B_SLICE )
     539  {
     540    m_aiNumRefIdx[1] = 0;
     541    ::memset( m_apcRefPicList[1], 0, sizeof(m_apcRefPicList[1]));
     542  }
     543  else
     544  {
     545    for (Int rIdx = 0; rIdx < m_aiNumRefIdx[1]; rIdx ++)
     546    {
     547      cIdx = m_RefPicListModification.getRefPicListModificationFlagL1() ? m_RefPicListModification.getRefPicSetIdxL1(rIdx) : rIdx % numPocTotalCurr;
     548      assert(cIdx >= 0 && cIdx < numPocTotalCurr);
     549      m_apcRefPicList[1][rIdx] = rpsCurrList1[ cIdx ];
     550      m_bIsUsedAsLongTerm[1][rIdx] = ( cIdx >= NumPocStCurr0 + NumPocStCurr1 );
     551    }
     552  }
     553}
     554
     555#else
     556Void TComSlice::getTempRefPicLists( TComList<TComPic*>& rcListPic, std::vector<TComPic*>& refPicSetInterLayer0, std::vector<TComPic*>& refPicSetInterLayer1,                                     
     557                                   std::vector<TComPic*> rpsCurrList[2], std::vector<Bool> usedAsLongTerm[2], Int& numPocTotalCurr, Bool checkNumPocTotalCurr )
     558{
     559  if (!checkNumPocTotalCurr)
     560  {
     561    if (m_eSliceType == I_SLICE)
     562    {     
     563      return;
     564    }   
     565  }
     566
     567  TComPic*  pcRefPic= NULL;
     568  TComPic*  RefPicSetStCurr0[16];
     569  TComPic*  RefPicSetStCurr1[16];
     570  TComPic*  RefPicSetLtCurr[16];
     571  UInt NumPocStCurr0 = 0;
     572  UInt NumPocStCurr1 = 0;
     573  UInt NumPocLtCurr = 0;
     574  Int i;
     575
     576  for(i=0; i < m_pcRPS->getNumberOfNegativePictures(); i++)
     577  {
     578    if(m_pcRPS->getUsed(i))
     579    {
     580      pcRefPic = xGetRefPic(rcListPic, getPOC()+m_pcRPS->getDeltaPOC(i));
     581      pcRefPic->setIsLongTerm(0);
     582      pcRefPic->getPicYuvRec()->extendPicBorder();
     583      RefPicSetStCurr0[NumPocStCurr0] = pcRefPic;
     584      NumPocStCurr0++;
     585      pcRefPic->setCheckLTMSBPresent(false); 
     586    }
     587  }
     588 
     589  for(; i < m_pcRPS->getNumberOfNegativePictures()+m_pcRPS->getNumberOfPositivePictures(); i++)
     590  {
     591    if(m_pcRPS->getUsed(i))
     592    {
     593      pcRefPic = xGetRefPic(rcListPic, getPOC()+m_pcRPS->getDeltaPOC(i));
     594      pcRefPic->setIsLongTerm(0);
     595      pcRefPic->getPicYuvRec()->extendPicBorder();
     596      RefPicSetStCurr1[NumPocStCurr1] = pcRefPic;
     597      NumPocStCurr1++;
     598      pcRefPic->setCheckLTMSBPresent(false); 
     599    }
     600  }
     601 
     602  for(i = m_pcRPS->getNumberOfNegativePictures()+m_pcRPS->getNumberOfPositivePictures()+m_pcRPS->getNumberOfLongtermPictures()-1; i > m_pcRPS->getNumberOfNegativePictures()+m_pcRPS->getNumberOfPositivePictures()-1 ; i--)
     603  {
     604    if(m_pcRPS->getUsed(i))
     605    {
     606      pcRefPic = xGetLongTermRefPic(rcListPic, m_pcRPS->getPOC(i), m_pcRPS->getCheckLTMSBPresent(i));
     607      pcRefPic->setIsLongTerm(1);
     608      pcRefPic->getPicYuvRec()->extendPicBorder();
     609      RefPicSetLtCurr[NumPocLtCurr] = pcRefPic;
     610      NumPocLtCurr++;
     611    }
     612    if(pcRefPic==NULL)
     613    {
     614      pcRefPic = xGetLongTermRefPic(rcListPic, m_pcRPS->getPOC(i), m_pcRPS->getCheckLTMSBPresent(i));
     615    }
     616    pcRefPic->setCheckLTMSBPresent(m_pcRPS->getCheckLTMSBPresent(i)); 
     617  }
     618
     619  Int numPocInterCurr = NumPocStCurr0 + NumPocStCurr1 + NumPocLtCurr;
     620  numPocTotalCurr = numPocInterCurr + getNumActiveRefLayerPics( );
     621  assert( numPocTotalCurr == getNumRpsCurrTempList() );
     622
     623  if (checkNumPocTotalCurr)
     624  {
     625    // The variable NumPocTotalCurr is derived as specified in subclause 7.4.7.2. It is a requirement of bitstream conformance that the following applies to the value of NumPocTotalCurr:
     626    // - If nuh_layer_id is equal to 0 and the current picture is a BLA picture or a CRA picture, the value of NumPocTotalCurr shall be equal to 0.
     627    // - Otherwise, when the current picture contains a P or B slice, the value of NumPocTotalCurr shall not be equal to 0.
     628    if ( getRapPicFlag() && m_layerId == 0 )
     629    {
     630      assert(numPocTotalCurr == 0);
     631    }
     632
     633    if (m_eSliceType == I_SLICE)
     634    {
     635      ::memset( m_apcRefPicList, 0, sizeof (m_apcRefPicList));
     636      ::memset( m_aiNumRefIdx,   0, sizeof ( m_aiNumRefIdx ));
     637     
     638      return;
     639    }
     640   
     641    assert(numPocTotalCurr > 0);
     642   
     643    m_aiNumRefIdx[0] = getNumRefIdx(REF_PIC_LIST_0);
     644    m_aiNumRefIdx[1] = getNumRefIdx(REF_PIC_LIST_1);
     645  }
     646
     647  std::vector<TComPic*>* refPicSetInterLayer[2] = { &refPicSetInterLayer0, &refPicSetInterLayer1};
     648  Int numPocInterLayer[2] = { getNumActiveRefLayerPics0( ), getNumActiveRefLayerPics1( ) };
     649 
     650  TComPic**             refPicSetStCurr    [2] = { RefPicSetStCurr0, RefPicSetStCurr1 };
     651  Int numPocStCurr[2] = { NumPocStCurr0, NumPocStCurr1 };
     652
     653  for (Int li = 0; li < ((m_eSliceType==B_SLICE) ? 2 : 1); li++)
     654  {
     655    rpsCurrList   [li].resize(MAX_NUM_REF+1,NULL );
     656    usedAsLongTerm[li].resize(MAX_NUM_REF+1,false);
     657
     658    Int cIdx = 0;
     659    for ( i=0; i < numPocStCurr[li]; i++, cIdx++)
     660    {
     661      rpsCurrList[li][cIdx] = refPicSetStCurr[li][i];
     662      usedAsLongTerm [li][cIdx] = false; 
     663    }
     664
     665    for ( i=0; i < numPocInterLayer[li];  i++, cIdx++)
     666    {   
     667      rpsCurrList[li][cIdx] = (*refPicSetInterLayer[li])[i];
     668      usedAsLongTerm [li][cIdx] = true; 
     669    }
     670
     671    for ( i=0; i < numPocStCurr[1-li]; i++, cIdx++)
     672    {
     673      rpsCurrList[li][cIdx] = refPicSetStCurr[1-li][i];
     674      usedAsLongTerm [li][cIdx] = false; 
     675    }
     676
     677    for ( i=0; i<NumPocLtCurr;  i++, cIdx++)
     678    {
     679      rpsCurrList[li][cIdx] = RefPicSetLtCurr[i];
     680      usedAsLongTerm [li][cIdx] = true; 
     681    }
     682
     683    for ( i=0; i < numPocInterLayer[1-li];  i++, cIdx++)
     684    {   
     685      assert( cIdx < MAX_NUM_REF );   
     686      rpsCurrList[li][cIdx] = (*refPicSetInterLayer[1-li])[i];
     687      usedAsLongTerm [li][cIdx] = true; 
     688    }
     689
     690    assert(cIdx == numPocTotalCurr);
     691  }
     692}
     693
     694Void TComSlice::setRefPicList( std::vector<TComPic*> rpsCurrList[2], std::vector<Bool> usedAsLongTerm[2], Int numPocTotalCurr, Bool checkNumPocTotalCurr )
     695
     696{
     697  if (!checkNumPocTotalCurr)
     698  {
     699    if (m_eSliceType == I_SLICE)
     700    {
     701      ::memset( m_apcRefPicList, 0, sizeof (m_apcRefPicList));
     702      ::memset( m_aiNumRefIdx,   0, sizeof ( m_aiNumRefIdx ));
     703
     704      return;
     705    }   
     706  }
     707
     708  ::memset(m_bIsUsedAsLongTerm, 0, sizeof(m_bIsUsedAsLongTerm));
     709
     710  for (Int li = 0; li < 2; li++)
     711  {
     712    if ( m_eSliceType == P_SLICE && li == 1 )
     713    {
     714      m_aiNumRefIdx[1] = 0;
     715      ::memset( m_apcRefPicList[1], 0, sizeof(m_apcRefPicList[1]));
     716    }
     717    else
     718    {
     719      for (Int rIdx = 0; rIdx <= (m_aiNumRefIdx[ li ] - 1 ); rIdx ++)
     720      {
     721        Bool listModified             =                m_RefPicListModification.getRefPicListModificationFlagL( li );
     722        Int orgIdx                    = listModified ? m_RefPicListModification.getRefPicSetIdxL(li, rIdx) : (rIdx % numPocTotalCurr);
     723
     724        assert( rpsCurrList[li][ orgIdx ] != NULL );
     725        m_apcRefPicList    [li][rIdx] = rpsCurrList    [li][ orgIdx ];
     726        m_bIsUsedAsLongTerm[li][rIdx] = usedAsLongTerm [li][ orgIdx ] ;
     727      }
     728    }
     729  }
     730}
     731#endif
     732#else
     733#if H_MV
     734Void TComSlice::setRefPicList( TComList<TComPic*>& rcListPic, std::vector<TComPic*>& refPicSetInterLayer , Bool checkNumPocTotalCurr)
     735#else
     736#if FIX1071
     737Void TComSlice::setRefPicList( TComList<TComPic*>& rcListPic, Bool checkNumPocTotalCurr )
     738#else
     739Void TComSlice::setRefPicList( TComList<TComPic*>& rcListPic )
     740#endif
     741#endif
     742{
     743#if FIX1071
     744  if (!checkNumPocTotalCurr)
     745#endif
     746  {
     747    if (m_eSliceType == I_SLICE)
     748    {
     749      ::memset( m_apcRefPicList, 0, sizeof (m_apcRefPicList));
     750      ::memset( m_aiNumRefIdx,   0, sizeof ( m_aiNumRefIdx ));
     751     
     752      return;
     753    }
     754   
     755#if !H_MV
     756    m_aiNumRefIdx[0] = getNumRefIdx(REF_PIC_LIST_0);
     757    m_aiNumRefIdx[1] = getNumRefIdx(REF_PIC_LIST_1);
     758#endif
     759  }
     760
     761  TComPic*  pcRefPic= NULL;
     762  TComPic*  RefPicSetStCurr0[16];
     763  TComPic*  RefPicSetStCurr1[16];
     764  TComPic*  RefPicSetLtCurr[16];
     765  UInt NumPocStCurr0 = 0;
     766  UInt NumPocStCurr1 = 0;
     767  UInt NumPocLtCurr = 0;
     768  Int i;
     769
     770  for(i=0; i < m_pcRPS->getNumberOfNegativePictures(); i++)
     771  {
     772    if(m_pcRPS->getUsed(i))
     773    {
     774      pcRefPic = xGetRefPic(rcListPic, getPOC()+m_pcRPS->getDeltaPOC(i));
     775      pcRefPic->setIsLongTerm(0);
     776      pcRefPic->getPicYuvRec()->extendPicBorder();
     777      RefPicSetStCurr0[NumPocStCurr0] = pcRefPic;
     778      NumPocStCurr0++;
     779      pcRefPic->setCheckLTMSBPresent(false); 
     780    }
     781  }
    413782 
    414783  for(; i < m_pcRPS->getNumberOfNegativePictures()+m_pcRPS->getNumberOfPositivePictures(); i++)
     
    458827    // The variable NumPocTotalCurr is derived as specified in subclause 7.4.7.2. It is a requirement of bitstream conformance that the following applies to the value of NumPocTotalCurr:
    459828#if H_MV
    460     // If nuh_layer_id is equal to 0 and the current picture is a BLA picture or a CRA picture, the value of NumPocTotalCurr shall be equal to 0.
    461     // Otherwise, when the current picture contains a P or B slice, the value of NumPocTotalCurr shall not be equal to 0.
     829    // – If nuh_layer_id is equal to 0 and the current picture is a BLA picture or a CRA picture, the value of NumPocTotalCurr shall be equal to 0.
     830    // – Otherwise, when the current picture contains a P or B slice, the value of NumPocTotalCurr shall not be equal to 0.
    462831    if ( getRapPicFlag() && m_layerId == 0 )
    463832#else
    464     // If the current picture is a BLA or CRA picture, the value of NumPocTotalCurr shall be equal to 0.
    465     // Otherwise, when the current picture contains a P or B slice, the value of NumPocTotalCurr shall not be equal to 0.
     833    // – If the current picture is a BLA or CRA picture, the value of NumPocTotalCurr shall be equal to 0.
     834    // – Otherwise, when the current picture contains a P or B slice, the value of NumPocTotalCurr shall not be equal to 0.
    466835    if (getRapPicFlag())
    467836#endif
     
    593962}
    594963
     964#endif
    595965Int TComSlice::getNumRpsCurrTempList()
    596966{
     
    609979  }
    610980#if H_MV
     981#if !H_MV5
    611982  assert( ( numRpsCurrTempList == 0 ) || getInterRefEnabledInRPLFlag() );
     983#endif
    612984  numRpsCurrTempList = numRpsCurrTempList + getNumActiveRefLayerPics();
    613985#endif
     
    9231295#if H_MV
    9241296  // Additional slice header syntax elements
     1297#if H_MV5
     1298  m_pocResetFlag               = pSrc->m_pocResetFlag;
     1299#endif
    9251300  m_discardableFlag            = pSrc->m_discardableFlag;
    9261301  m_interLayerPredEnabledFlag  = pSrc->m_interLayerPredEnabledFlag;
     
    9311306    m_interLayerPredLayerIdc[ layer ] = pSrc->m_interLayerPredLayerIdc[ layer ];
    9321307  }
    933  
     1308#if !H_MV5
    9341309  m_interLayerSamplePredOnlyFlag = pSrc->m_interLayerSamplePredOnlyFlag;
    9351310  m_altCollocatedIndicationFlag  = pSrc->m_altCollocatedIndicationFlag ;   
     
    9411316    m_interLayerPredLayerIdc[layer] = pSrc->m_interLayerPredLayerIdc[layer];
    9421317  }
     1318#endif
    9431319#endif
    9441320#if H_3D_IC
     
    14051781: m_VPSId                     (  0)
    14061782, m_uiMaxTLayers              (  1)
     1783#if H_MV5
     1784#if H_MV
     1785, m_uiMaxLayersMinus1         (  0)
     1786#else
    14071787, m_uiMaxLayers               (  1)
     1788#endif
     1789#else
     1790, m_uiMaxLayers               (  1)
     1791#endif
    14081792, m_bTemporalIdNestingFlag    (false)
    14091793, m_numHrdParameters          (  0)
     
    14161800, m_hrdOpSetIdx               (NULL)
    14171801, m_cprmsPresentFlag          (NULL)
     1802#if H_MV5
     1803#if H_MV
     1804, m_vpsVUI                 (  NULL )
     1805#endif
     1806#endif
    14181807{
    14191808  for( Int i = 0; i < MAX_TLAYER; i++)
     
    14591848
    14601849  m_avcBaseLayerFlag = false;
     1850#if H_MV5
     1851  m_vpsVuiOffset     = 0;
     1852#endif
    14611853  m_splittingFlag    = false;
    14621854 
    14631855  for( Int i = 0; i < MAX_NUM_SCALABILITY_TYPES; i++ )
    14641856  {
     1857#if H_MV5
     1858    m_scalabilityMaskFlag[i] = false;
     1859#else
    14651860    m_scalabilityMask[i] = false;
     1861#endif
    14661862    m_dimensionIdLen [i]  = -1;
    14671863  }
     
    14891885    m_layerIdInNuh      [i] = ( i == 0 ) ? 0 : -1;
    14901886    m_numDirectRefLayers[i] = 0;
     1887#if H_MV5
     1888    m_maxTidIlRefPicPlus1[i] = 7;
     1889    m_vpsRepFormatIdx    [i] = 0;
     1890    m_repFormat          [i] = NULL;
     1891    m_viewIdVal          [i] = 0;
     1892#else
    14911893    m_maxTidIlRefPicPlus1[i] = -1;
     1894#endif
     1895
    14921896#if H_3D
    14931897    m_viewIndex         [i] = -1;
     
    15101914    }
    15111915#endif
    1512 #if H_3D_TMVP
     1916#if H_3D
    15131917    m_ivMvScalingFlag = true;
    15141918#endif
     
    15311935#endif
    15321936  }
     1937#if H_MV5
     1938  m_vpsVUI = new TComVPSVUI;
     1939#endif
    15331940#if H_3D
    15341941  for( Int i = 0; i < MAX_NUM_LAYERS; i++ )
     
    15561963  if( m_hrdOpSetIdx      != NULL )     delete[] m_hrdOpSetIdx;
    15571964  if( m_cprmsPresentFlag != NULL )     delete[] m_cprmsPresentFlag;
     1965#if H_MV5
     1966#if H_MV
     1967  if ( m_vpsVUI          != NULL )     delete m_vpsVUI;
     1968  for( Int i = 0; i < MAX_NUM_LAYERS; i++ )
     1969  {
     1970    if (m_repFormat[ i ] != NULL )      delete m_repFormat[ i ];   
     1971#if H_3D_DIM_DLT
     1972    if ( m_iDepthValue2Idx[i] != 0 )
     1973    {
     1974       xFree( m_iDepthValue2Idx[i] );
     1975       m_iDepthValue2Idx[i] = 0;
     1976    }
     1977
     1978    if ( m_iIdx2DepthValue[i] != 0 )
     1979    {
     1980      xFree( m_iIdx2DepthValue[i] );
     1981      m_iIdx2DepthValue[i] = 0;
     1982    }
     1983#endif
     1984  }
     1985#endif
     1986#else
    15581987#if H_3D_DIM_DLT
    15591988  for( Int i = 0; i < MAX_NUM_LAYERS; i++ )
     
    15722001    }
    15732002  }
     2003#endif
    15742004#endif
    15752005}
     
    16422072Bool TComVPS::checkVPSExtensionSyntax()
    16432073{
     2074#if H_MV5
     2075  for( Int layer = 1; layer <= getMaxLayersMinus1(); layer++ )
     2076#else
    16442077  for( Int layer = 1; layer < getMaxLayers(); layer++ )
     2078#endif
    16452079  {
    16462080    // check layer_id_in_nuh constraint
     
    16582092{
    16592093  assert( scalType >= 0 && scalType <= MAX_NUM_SCALABILITY_TYPES );
     2094#if H_MV5
     2095  assert( scalType == MAX_NUM_SCALABILITY_TYPES || getScalabilityMaskFlag( scalType ) );
     2096#else
    16602097  assert( scalType == MAX_NUM_SCALABILITY_TYPES || getScalabilityMask( scalType ) );
    1661 
     2098#endif
    16622099  Int scalIdx = 0;
    16632100  for( Int curScalType = 0; curScalType < scalType; curScalType++ )
    16642101  {
     2102#if H_MV5
     2103    scalIdx += ( getScalabilityMaskFlag( curScalType ) ? 1 : 0 );
     2104#else
    16652105    scalIdx += ( getScalabilityMask( curScalType ) ? 1 : 0 );
     2106#endif
     2107
    16662108  }
    16672109
    16682110  return scalIdx;
    16692111}
    1670 
     2112#if H_MV5
     2113Void TComVPS::setScalabilityMaskFlag( UInt val )
     2114{
     2115  for ( Int scalType = 0; scalType < MAX_NUM_SCALABILITY_TYPES; scalType++ )
     2116  {
     2117    setScalabilityMaskFlag( scalType, ( val & (1 << scalType ) ) != 0 );
     2118  }
     2119}
     2120#else
    16712121Void TComVPS::setScalabilityMask( UInt val )
    16722122{
     
    16752125}
    16762126
     2127#endif
     2128
     2129#if H_MV5
     2130Void TComVPS::setRefLayers()
     2131{
     2132  for( Int i = 0; i  <= getMaxLayersMinus1(); i++ )
     2133  {
     2134    Int iNuhLId = getLayerIdInNuh( i );
     2135    m_numDirectRefLayers[ iNuhLId ] = 0;
     2136    for( Int j = 0; j < i; j++ )
     2137    {
     2138      if( getDirectDependencyFlag(i , j) )
     2139      {
     2140        m_refLayerId[ iNuhLId ][m_numDirectRefLayers[ iNuhLId ]++ ] = getLayerIdInNuh( j );
     2141      }
     2142    }
     2143  }
     2144}
     2145
     2146Int TComVPS::getRefLayerId( Int layerIdInNuh, Int idx )
     2147{
     2148  assert( idx >= 0 && idx < m_numDirectRefLayers[layerIdInNuh] );     
     2149  Int refLayerIdInNuh = m_refLayerId[ layerIdInNuh ][ idx ];   
     2150  assert ( refLayerIdInNuh >= 0 );
     2151  return refLayerIdInNuh;
     2152}
     2153
     2154Int TComVPS::getScalabilityId( Int layerIdInVps, ScalabilityType scalType )
     2155{
     2156  return getScalabilityMaskFlag( scalType ) ? getDimensionId( layerIdInVps, scalTypeToScalIdx( scalType ) ) : 0;
     2157}
     2158
     2159#if H_3D
     2160Int TComVPS::getLayerIdInNuh( Int viewIndex, Bool depthFlag )
     2161{
     2162  Int foundLayerIdinNuh = -1;
     2163
     2164  for (Int layerIdInVps = 0 ; layerIdInVps <= getMaxLayersMinus1(); layerIdInVps++ )
     2165  {
     2166    Int layerIdInNuh = getLayerIdInNuh( layerIdInVps );
     2167    if( ( getViewIndex( layerIdInNuh ) == viewIndex ) && ( getDepthId( layerIdInNuh ) == ( depthFlag ? 1 : 0 ) )  )
     2168    {
     2169      foundLayerIdinNuh = layerIdInNuh;
     2170      break;
     2171    }
     2172  }
     2173  assert( foundLayerIdinNuh != -1 );
     2174
     2175  return foundLayerIdinNuh;
     2176}
     2177#endif // H_3D
     2178#else
    16772179Void TComVPS::setRefLayers()
    16782180{
     
    17932295}
    17942296
     2297#endif // H_MV5
     2298
    17952299
    17962300Int TComVPS::xGetDimBitOffset( Int j )
     
    18322336  return numLayersInIdList;
    18332337}
     2338#if H_MV5
     2339Int TComVPS::getNumViews()
     2340{
     2341  Int numViews = 1;
     2342  for( Int i = 0; i <=  getMaxLayersMinus1(); i++ )
     2343  {
     2344    Int lId = getLayerIdInNuh( i );
     2345    if ( i > 0 && ( getViewIndex( lId ) != getScalabilityId( i - 1, VIEW_ORDER_INDEX ) ) )
     2346    {
     2347      numViews++;
     2348    }   
     2349  }
     2350
     2351  return numViews;
     2352}
     2353
     2354Bool TComVPS::getInDirectDependencyFlag( Int depLayeridInVps, Int refLayeridInVps, Int depth /*= 0 */ )
     2355{
     2356  assert( depth < 65 );
     2357  Bool dependentFlag = getDirectDependencyFlag( depLayeridInVps, refLayeridInVps );
     2358
     2359  for( Int i = 0; i < depLayeridInVps && !dependentFlag; i++ )
     2360  {
     2361    if ( getDirectDependencyFlag( depLayeridInVps, i ) )
     2362    {
     2363      dependentFlag = getInDirectDependencyFlag( i, refLayeridInVps, depth++ );
     2364    }
     2365  }
     2366  return dependentFlag;
     2367}
     2368#endif
    18342369#endif // H_MV
    18352370
     
    18822417, m_vuiParameters             ()
    18832418#if H_MV
     2419#if H_MV5
     2420, m_pcVPS                     ( NULL )
     2421, m_spsInferScalingListFlag   ( false )
     2422, m_spsScalingListRefLayerId  ( 0 )
     2423, m_updateRepFormatFlag       ( true )
     2424, m_interViewMvVertConstraintFlag (false)
     2425#else
    18842426, m_interViewMvVertConstraintFlag (false)
    18852427, m_numIlpRestrictedRefLayers ( 0 )
     2428#endif
    18862429#endif
    18872430#if H_3D
     
    18982441  ::memset(m_ltRefPicPocLsbSps, 0, sizeof(m_ltRefPicPocLsbSps));
    18992442  ::memset(m_usedByCurrPicLtSPSFlag, 0, sizeof(m_usedByCurrPicLtSPSFlag));
     2443#if !H_MV5
    19002444#if H_MV
    19012445  for (Int i = 0; i < MAX_NUM_LAYERS; i++ )
     
    19052449    m_minHorizontalCtuOffsetPlus1 [ i ] = 0;
    19062450  }
     2451#endif
    19072452#endif
    19082453}
     
    20582603, m_listsModificationPresentFlag(  0)
    20592604, m_numExtraSliceHeaderBits(0)
     2605#if H_MV5
     2606#if H_MV
     2607, m_ppsInferScalingListFlag(false)
     2608, m_ppsScalingListRefLayerId(0)
     2609#endif
     2610#endif
    20602611{
    20612612  m_scalingList = new TComScalingList;
     
    20772628}
    20782629
     2630#if H_MV5
     2631#if H_MV
     2632Void TComSPS::inferRepFormat( TComVPS* vps, Int layerIdCurr )
     2633{
     2634  if ( layerIdCurr > 0 )
     2635  {
     2636    TComRepFormat* repFormat = vps->getRepFormat( vps->getVpsRepFormatIdx( vps->getLayerIdInVps( layerIdCurr ) ) );
     2637    if ( !getUpdateRepFormatFlag() )
     2638    {       
     2639      setChromaFormatIdc( repFormat->getChromaFormatVpsIdc() );         
     2640      //// ToDo: add when supported:
     2641      // setSeperateColourPlaneFlag( repFormat->getSeparateColourPlaneVpsFlag() ) ;
     2642
     2643      setPicWidthInLumaSamples ( repFormat->getPicWidthVpsInLumaSamples()  );
     2644      setPicHeightInLumaSamples( repFormat->getPicHeightVpsInLumaSamples() );
     2645
     2646      setBitDepthY             ( repFormat->getBitDepthVpsLumaMinus8()   + 8 );
     2647      setQpBDOffsetY           ( (Int) (6*( getBitDepthY() - 8 )) );
     2648
     2649      setBitDepthC             ( repFormat->getBitDepthVpsChromaMinus8() + 8 );
     2650      setQpBDOffsetC           ( (Int) (6* ( getBitDepthC() -8 ) ) );
     2651    }
     2652    else
     2653    {
     2654      assert( getChromaFormatIdc()      <=  repFormat->getChromaFormatVpsIdc()         );
     2655      //// ToDo: add when supported:
     2656      // assert( getSeperateColourPlaneFlag() <=  repFormat->getSeparateColourPlaneVpsFlag() ) ;
     2657
     2658      assert( getPicWidthInLumaSamples()  <= repFormat->getPicWidthVpsInLumaSamples()    );
     2659      assert( getPicHeightInLumaSamples() <= repFormat->getPicHeightVpsInLumaSamples()   );
     2660
     2661      assert( getBitDepthY()              <= repFormat->getBitDepthVpsLumaMinus8()   + 8 );         
     2662      assert( getBitDepthC()              <= repFormat->getBitDepthVpsChromaMinus8() + 8 );
     2663    }
     2664  }
     2665
     2666  // Set conformance window
     2667  Int scal = TComSPS::getWinUnitX( getChromaFormatIdc() ) ;
     2668  getConformanceWindow().scaleOffsets( scal );
     2669  getVuiParameters()->getDefaultDisplayWindow().scaleOffsets( scal );
     2670}
     2671
     2672Void TComSPS::inferScalingList( TComSPS* spsSrc )
     2673{
     2674  if ( getSpsInferScalingListFlag() )
     2675  {
     2676    assert( spsSrc != NULL );
     2677    assert( !spsSrc->getSpsInferScalingListFlag() );             
     2678    getScalingList()->inferFrom( spsSrc->getScalingList() );
     2679  }
     2680}
     2681#endif
     2682#endif
    20792683#if H_3D
    20802684Void
     
    23462950
    23472951#if H_MV
    2348 Void TComSlice::createAndApplyIvReferencePictureSet( TComPicLists* ivPicLists, std::vector<TComPic*>& refPicSetInterLayer )
    2349 {
    2350   refPicSetInterLayer.clear();
     2952#if H_MV5
     2953Void TComSlice::createInterLayerReferencePictureSet( TComPicLists* ivPicLists, std::vector<TComPic*>& refPicSetInterLayer0, std::vector<TComPic*>& refPicSetInterLayer1 )
     2954{
     2955  refPicSetInterLayer0.clear();
     2956  refPicSetInterLayer1.clear();
    23512957
    23522958  for( Int i = 0; i < getNumActiveRefLayerPics(); i++ )
     
    23602966    picRef->getSlice(0)->setReferenced( true );       
    23612967
     2968    Int viewIdCur  = getVPS()->getViewId( getLayerId() );
     2969    Int viewIdZero = getVPS()->getViewId( 0 );
     2970    Int viewIdRef  = getVPS()->getViewId( layerIdRef );
     2971
     2972    if (  ( viewIdCur <= viewIdZero && viewIdCur <= viewIdRef ) || ( viewIdCur >= viewIdZero && viewIdCur >= viewIdRef ) )
     2973    {
     2974      refPicSetInterLayer0.push_back( picRef );
     2975    }
     2976    else
     2977    {
     2978      refPicSetInterLayer1.push_back( picRef );
     2979    }
     2980    // Consider to check here:
     2981    // "If the current picture is a RADL picture, there shall be no entry in the RefPicSetInterLayer0 and RefPicSetInterLayer1 that is a RASL picture. "   
     2982  }
     2983}
     2984#else
     2985Void TComSlice::createAndApplyIvReferencePictureSet( TComPicLists* ivPicLists, std::vector<TComPic*>& refPicSetInterLayer )
     2986{
     2987  refPicSetInterLayer.clear();
     2988
     2989  for( Int i = 0; i < getNumActiveRefLayerPics(); i++ )
     2990  {
     2991    Int layerIdRef = getRefPicLayerId( i );
     2992    TComPic* picRef = ivPicLists->getPic( layerIdRef, getPOC() ) ;
     2993    assert ( picRef != 0 );
     2994
     2995    picRef->getPicYuvRec()->extendPicBorder();
     2996    picRef->setIsLongTerm( true );       
     2997    picRef->getSlice(0)->setReferenced( true );       
     2998
    23622999    // Consider to check here:
    23633000    // "If the current picture is a RADL picture, there shall be no entry in the RefPicSetInterLayer that is a RASL picture. "
     
    23653002  }
    23663003}
    2367 
     3004#endif
     3005
     3006#if H_MV5
     3007Void TComSlice::markIvRefPicsAsShortTerm( std::vector<TComPic*> refPicSetInterLayer0, std::vector<TComPic*> refPicSetInterLayer1 )
     3008{
     3009  // Mark as shortterm
     3010  for ( Int i = 0; i < refPicSetInterLayer0.size(); i++ )
     3011  {
     3012    refPicSetInterLayer0[i]->setIsLongTerm( false );
     3013  }
     3014
     3015  for ( Int i = 0; i < refPicSetInterLayer1.size(); i++ )
     3016  {
     3017    refPicSetInterLayer1[i]->setIsLongTerm( false );
     3018  }
     3019
     3020}
     3021#else
    23683022Void TComSlice::markIvRefPicsAsShortTerm( std::vector<TComPic*> refPicSetInterLayer )
    23693023{
     
    23753029}
    23763030
     3031#endif
    23773032Void TComSlice::markIvRefPicsAsUnused( TComPicLists* ivPicLists, std::vector<Int> targetDecLayerIdSet, TComVPS* vps, Int curLayerId, Int curPoc )
    23783033{
     
    23803035  if (targetDecLayerIdSet.size() == 0 )   
    23813036  {
     3037#if H_MV5
     3038    for ( Int layerIdInVps = 0; layerIdInVps <= vps->getMaxLayersMinus1(); layerIdInVps++ )
     3039#else
    23823040    for ( Int layerIdInVps = 0; layerIdInVps < vps->getMaxLayers(); layerIdInVps++ )
     3041#endif
    23833042    {
    23843043      targetDecLayerIdSet.push_back( vps->getLayerIdInNuh( layerIdInVps ) );
     
    23913050  {
    23923051    if ( targetDecLayerIdSet[ latestDecIdx ] == curLayerId )
     3052    {
    23933053      break;
     3054  }       
    23943055  }       
    23953056
     
    24073068          if ( vps->nuhLayerIdIncluded( targetDecLayerIdSet[ j ] ) )
    24083069          {
     3070#if H_MV5
     3071            for( Int k = 0; k < vpsSlice->getNumDirectRefLayers( targetDecLayerIdSet[ j ] ); k++ )
     3072            {
     3073              if ( targetDecLayerIdSet[ i ] == vpsSlice->getRefLayerId( targetDecLayerIdSet[ j ],  k  ) )
     3074#else
    24093075            Int targetDecLayerIdinVPS = vpsSlice->getLayerIdInVps( targetDecLayerIdSet[ j ] );
    24103076            for( Int k = 0; k < vpsSlice->getNumDirectRefLayers( targetDecLayerIdinVPS ); k++ )
     3077            {
    24113078              if ( targetDecLayerIdSet[ i ] == vpsSlice->getRefLayerId( targetDecLayerIdinVPS,  k  ) )
     3079#endif
     3080              {
    24123081                remainingInterLayerReferencesFlag = true;
    24133082          }
    24143083        }
     3084          }
     3085        }
    24153086        if( !remainingInterLayerReferencesFlag )
     3087        {
    24163088          pcPic->getSlice(0)->setReferenced( false );                   
    24173089      }
     
    24193091  }
    24203092}
    2421 
     3093}
     3094
     3095#if H_MV5
     3096Void TComSlice::printRefPicList()
     3097#else
    24223098Void TComSlice::xPrintRefPicList()
     3099#endif
    24233100
    24243101  for ( Int li = 0; li < 2; li++)
     
    24333110  }
    24343111}
     3112#if !H_MV5
    24353113Int TComSlice::xCeilLog2( Int val )
    24363114{
     
    24403118  return ceilLog2;
    24413119}
     3120#endif
    24423121
    24433122Void TComSlice::markCurrPic( TComPic* currPic )
     
    24543133}
    24553134
     3135#if H_MV5
     3136Void TComSlice::setRefPicSetInterLayer( std::vector<TComPic*>* refPicSetInterLayer0, std::vector<TComPic*>* refPicSetInterLayer1 )
     3137{
     3138  m_refPicSetInterLayer0 = refPicSetInterLayer0;
     3139  m_refPicSetInterLayer1 = refPicSetInterLayer1;
     3140}
     3141
     3142TComPic* TComSlice::getPicFromRefPicSetInterLayer(Int setIdc, Int layerId )
     3143{
     3144  assert ( setIdc == 0 || setIdc == 1);   
     3145  std::vector<TComPic*>* refPicSetInterLayer = ( setIdc == 0 ? m_refPicSetInterLayer0 : m_refPicSetInterLayer1);   
     3146  assert( refPicSetInterLayer != 0 );
     3147 
     3148  TComPic* pcPic = NULL;
     3149  for ( Int i = 0; i < (*refPicSetInterLayer).size(); i++ )
     3150  {
     3151    if ((*refPicSetInterLayer)[ i ]->getLayerId() == layerId )
     3152    {
     3153      pcPic = (*refPicSetInterLayer)[ i ];
     3154    }
     3155  }
     3156
     3157  assert(pcPic != NULL);
     3158  return pcPic;
     3159}
     3160#else
    24563161Void TComSlice::setRefPicSetInterLayer( std::vector<TComPic*>* refPicSetInterLayer )
    24573162{
     
    24743179  return pcPic;
    24753180}
    2476 
     3181#endif
    24773182Int TComSlice::getNumActiveRefLayerPics()
    24783183{
    24793184  Int numActiveRefLayerPics;
    24803185
     3186#if H_MV5
     3187  if( getLayerId() == 0 || getVPS()->getNumDirectRefLayers( getLayerId() ) ==  0 )
     3188  {
     3189    numActiveRefLayerPics = 0;
     3190  }
     3191  else if (getVPS()->getAllRefLayersActiveFlag() )
     3192  {
     3193    numActiveRefLayerPics = getVPS()->getNumDirectRefLayers( getLayerId() );
     3194  }
     3195  else if ( !getInterLayerPredEnabledFlag() )
     3196  {
     3197    numActiveRefLayerPics = 0;
     3198  }
     3199  else if( getVPS()->getMaxOneActiveRefLayerFlag() || getVPS()->getNumDirectRefLayers( getLayerId() ) == 1 )
     3200#else
    24813201  if( getLayerId() == 0 || getVPS()->getNumDirectRefLayers( getLayerIdInVps() ) ==  0 || !getInterLayerPredEnabledFlag() )
    24823202  {
     
    24843204  }
    24853205  else if( getVPS()->getMaxOneActiveRefLayerFlag() || getVPS()->getNumDirectRefLayers( getLayerIdInVps() ) == 1 )
     3206#endif
    24863207  {
    24873208    numActiveRefLayerPics = 1;
     
    24963217Int TComSlice::getRefPicLayerId( Int i )
    24973218{
     3219#if H_MV5
     3220  return getVPS()->getRefLayerId( getLayerId(), getInterLayerPredLayerIdc( i ) );
     3221#else
    24983222  return getVPS()->getRefLayerId( getLayerIdInVps(), getInterLayerPredLayerIdc( i ) );
    2499 }
    2500 
     3223#endif
     3224}
     3225
     3226#if !H_MV5
    25013227Void TComSlice::setActiveMotionPredRefLayers()
    25023228{
     
    25273253  return interRefEnabledInRPLFlag;
    25283254}
     3255#endif
    25293256#if H_3D_ARP
    25303257Void TComSlice::setARPStepNum()                                 
     
    28043531}
    28053532
     3533#if H_MV5
     3534#if H_MV
     3535Void TComScalingList::inferFrom( TComScalingList* srcScLi )
     3536{
     3537  for(Int sizeId = 0; sizeId < SCALING_LIST_SIZE_NUM; sizeId++)
     3538  {
     3539    for(Int listId = 0; listId <  g_scalingListNum[sizeId]; listId++)
     3540    {
     3541      setRefMatrixId  (sizeId,listId, srcScLi->getRefMatrixId  (sizeId,listId));
     3542      setScalingListDC(sizeId,listId, srcScLi->getScalingListDC(sizeId,listId));         
     3543      ::memcpy(getScalingListAddress(sizeId, listId),srcScLi->getScalingListAddress(sizeId, listId),sizeof(Int)*min(MAX_MATRIX_COEF_NUM,(Int)g_scalingListSize[sizeId]));
     3544    }
     3545  }
     3546}
     3547#endif
     3548#endif
    28063549/** initialization process of quantization matrix array
    28073550 */
     
    28933636, m_ppsMap(MAX_NUM_PPS)
    28943637, m_activeVPSId(-1)
     3638#if H_MV5
     3639#if !H_MV
    28953640, m_activeSPSId(-1)
    28963641, m_activePPSId(-1)
    28973642{
     3643#else
     3644{
     3645  for (Int i = 0; i < MAX_NUM_LAYERS; i++ )
     3646  {
     3647    m_activeSPSId[ i ] = -1;
     3648    m_activePPSId[ i ] = -1;
     3649  }
     3650#endif
     3651#else
     3652, m_activeSPSId(-1)
     3653, m_activePPSId(-1)
     3654{
     3655#endif
    28983656}
    28993657
     
    29053663//! activate a SPS from a active parameter sets SEI message
    29063664//! \returns true, if activation is successful
     3665#if H_MV5
     3666#if H_MV
     3667Bool ParameterSetManager::activateSPSWithSEI(Int spsId, Int layerId )
     3668#else
    29073669Bool ParameterSetManager::activateSPSWithSEI(Int spsId)
     3670#endif
     3671#else
     3672Bool ParameterSetManager::activateSPSWithSEI(Int spsId)
     3673#endif
    29083674{
    29093675  TComSPS *sps = m_spsMap.getPS(spsId);
     
    29143680    {
    29153681      m_activeVPSId = vpsId;
     3682#if !H_MV5
    29163683      m_activeSPSId = spsId;
     3684#else
     3685#if H_MV
     3686      m_activeSPSId[ layerId ] = spsId;
     3687#else
     3688      m_activeSPSId = spsId;
     3689#endif
     3690#endif
    29173691      return true;
    29183692    }
     
    29313705//! activate a PPS and depending on isIDR parameter also SPS and VPS
    29323706//! \returns true, if activation is successful
     3707#if H_MV5
     3708#if H_MV
     3709Bool ParameterSetManager::activatePPS(Int ppsId, Bool isIRAP, Int layerId )
     3710#else
     3711Bool ParameterSetManager::activatePPS(Int ppsId, Bool isIRAP)
     3712#endif
     3713{
     3714  TComPPS *pps = m_ppsMap.getPS(ppsId);
     3715  if (pps)
     3716  {
     3717    Int spsId = pps->getSPSId();
     3718#if H_MV
     3719    if (!isIRAP && (spsId != m_activeSPSId[ layerId ]))
     3720#else
     3721    if (!isIRAP && (spsId != m_activeSPSId))
     3722#endif
     3723    {
     3724      printf("Warning: tried to activate PPS referring to a inactive SPS at non-IRAP.");
     3725      return false;
     3726    }
     3727
     3728    TComSPS *sps = m_spsMap.getPS(spsId);
     3729    if (sps)
     3730    {
     3731      Int vpsId = sps->getVPSId();
     3732      if (!isIRAP && (vpsId != m_activeVPSId))
     3733      {
     3734        printf("Warning: tried to activate PPS referring to a inactive VPS at non-IRAP.");
     3735        return false;
     3736      }
     3737      if (m_vpsMap.getPS(vpsId))
     3738      {
     3739#if H_MV
     3740        m_activePPSId[ layerId ] = ppsId;
     3741        m_activeVPSId = vpsId;
     3742        m_activeSPSId[ layerId ] = spsId;
     3743#else
     3744        m_activePPSId = ppsId;
     3745        m_activeVPSId = vpsId;
     3746        m_activeSPSId = spsId;
     3747#endif
     3748#else
    29333749Bool ParameterSetManager::activatePPS(Int ppsId, Bool isIRAP)
    29343750{
     
    29603776        m_activeVPSId = vpsId;
    29613777        m_activeSPSId = spsId;
     3778#endif
    29623779        return true;
    29633780      }
     
    30093826}
    30103827#endif
    3011 #if SIGNAL_BITRATE_PICRATE_IN_VPS
    3012 TComBitRatePicRateInfo::TComBitRatePicRateInfo()
    3013 {
    3014   ::memset(m_bitRateInfoPresentFlag, 0, sizeof(m_bitRateInfoPresentFlag));
    3015   ::memset(m_picRateInfoPresentFlag, 0, sizeof(m_picRateInfoPresentFlag));
    3016   ::memset(m_avgBitRate,             0, sizeof(m_avgBitRate));
    3017   ::memset(m_maxBitRate,             0, sizeof(m_maxBitRate));
    3018   ::memset(m_constantPicRateIdc,     0, sizeof(m_constantPicRateIdc));
    3019   ::memset(m_avgPicRate,             0, sizeof(m_avgPicRate));
    3020 }
    3021 #endif
    30223828//! \}
     3829
     3830#if H_MV5
     3831#if H_MV
     3832TComVPSVUI::TComVPSVUI()
     3833{
     3834  m_bitRatePresentVpsFlag = false;
     3835  m_picRatePresentVpsFlag = false;
     3836  for ( Int i = 0; i < MAX_VPS_OP_SETS_PLUS1; i++)
     3837  {   
     3838    for ( Int j = 0; j < MAX_TLAYER; j++)
     3839    {   
     3840      m_bitRatePresentFlag          [i][j] = false;
     3841      m_picRatePresentFlag          [i][j] = false;
     3842      m_avgBitRate                  [i][j] = -1;
     3843      m_maxBitRate                  [i][j] = -1;
     3844      m_constantPicRateIdc          [i][j] = -1;
     3845      m_avgPicRate                  [i][j] = -1;
     3846    }
     3847  }
     3848
     3849  m_ilpRestrictedRefLayersFlag = false;
     3850
     3851  for ( Int i = 0; i < MAX_NUM_LAYERS; i++)
     3852  {         
     3853    for ( Int j = 0; j < MAX_NUM_LAYERS; j++)
     3854    {   
     3855      m_tileBoundariesAlignedFlag   [i][j] = false;
     3856      m_minSpatialSegmentOffsetPlus1[i][j] = 0;
     3857      m_ctuBasedOffsetEnabledFlag   [i][j] = false;
     3858      m_minHorizontalCtuOffsetPlus1 [i][j] = -1;
     3859    }
     3860  }
     3861}
     3862#endif
     3863#endif
  • trunk/source/Lib/TLibCommon/TComSlice.h

    r608 r622  
    169169  Void     processRefMatrix               (UInt sizeId, UInt listId , UInt refListId );
    170170  Bool     xParseScalingList              (Char* pchFile);
     171#if H_MV5
     172#if H_MV
     173  Void     inferFrom                      ( TComScalingList* srcScLi );
     174#endif
     175#endif
    171176
    172177private:
     
    402407};
    403408
     409#if H_MV5
     410#if H_MV
     411class TComVPSVUI
     412{
     413private:
     414  Bool m_bitRatePresentVpsFlag;
     415  Bool m_picRatePresentVpsFlag;
     416  Bool m_bitRatePresentFlag          [MAX_VPS_OP_SETS_PLUS1][MAX_TLAYER];
     417  Bool m_picRatePresentFlag          [MAX_VPS_OP_SETS_PLUS1][MAX_TLAYER];
     418  Int  m_avgBitRate                  [MAX_VPS_OP_SETS_PLUS1][MAX_TLAYER];
     419  Int  m_maxBitRate                  [MAX_VPS_OP_SETS_PLUS1][MAX_TLAYER];
     420  Int  m_constantPicRateIdc          [MAX_VPS_OP_SETS_PLUS1][MAX_TLAYER];
     421  Int  m_avgPicRate                  [MAX_VPS_OP_SETS_PLUS1][MAX_TLAYER];
     422  Bool m_tileBoundariesAlignedFlag   [MAX_NUM_LAYERS][MAX_NUM_LAYERS];
     423  Bool m_ilpRestrictedRefLayersFlag;
     424  Int  m_minSpatialSegmentOffsetPlus1[MAX_NUM_LAYERS][MAX_NUM_LAYERS];
     425  Bool m_ctuBasedOffsetEnabledFlag   [MAX_NUM_LAYERS][MAX_NUM_LAYERS];
     426  Int  m_minHorizontalCtuOffsetPlus1 [MAX_NUM_LAYERS][MAX_NUM_LAYERS];
     427
     428public:
     429  TComVPSVUI();;
     430
     431  Void setBitRatePresentVpsFlag( Bool flag ) { m_bitRatePresentVpsFlag = flag; }
     432  Bool getBitRatePresentVpsFlag(  ) { return m_bitRatePresentVpsFlag; }
     433
     434  Void setPicRatePresentVpsFlag( Bool flag ) { m_picRatePresentVpsFlag = flag; }
     435  Bool getPicRatePresentVpsFlag(  ) { return m_picRatePresentVpsFlag; }
     436
     437  Void setBitRatePresentFlag( Int i, Int j, Bool flag ) { m_bitRatePresentFlag[i][j] = flag; }
     438  Bool getBitRatePresentFlag( Int i, Int j ) { return m_bitRatePresentFlag[i][j]; }
     439
     440  Void setPicRatePresentFlag( Int i, Int j, Bool flag ) { m_picRatePresentFlag[i][j] = flag; }
     441  Bool getPicRatePresentFlag( Int i, Int j ) { return m_picRatePresentFlag[i][j]; }
     442
     443  Void setAvgBitRate( Int i, Int j, Int  val ) { m_avgBitRate[i][j] = val; }
     444  Int  getAvgBitRate( Int i, Int j ) { return m_avgBitRate[i][j]; }
     445
     446  Void setMaxBitRate( Int i, Int j, Int  val ) { m_maxBitRate[i][j] = val; }
     447  Int  getMaxBitRate( Int i, Int j ) { return m_maxBitRate[i][j]; }
     448
     449  Void setConstantPicRateIdc( Int i, Int j, Int  val ) { m_constantPicRateIdc[i][j] = val; }
     450  Int  getConstantPicRateIdc( Int i, Int j ) { return m_constantPicRateIdc[i][j]; }
     451
     452  Void setAvgPicRate( Int i, Int j, Int  val ) { m_avgPicRate[i][j] = val; }
     453  Int  getAvgPicRate( Int i, Int j ) { return m_avgPicRate[i][j]; }
     454
     455  Void setTileBoundariesAlignedFlag( Int i, Int j, Bool flag ) { m_tileBoundariesAlignedFlag[i][j] = flag; }
     456  Bool getTileBoundariesAlignedFlag( Int i, Int j ) { return m_tileBoundariesAlignedFlag[i][j]; }
     457
     458  Void setIlpRestrictedRefLayersFlag( Bool flag ) { m_ilpRestrictedRefLayersFlag = flag; }
     459  Bool getIlpRestrictedRefLayersFlag(  ) { return m_ilpRestrictedRefLayersFlag; }
     460
     461  Void setMinSpatialSegmentOffsetPlus1( Int i, Int j, Int  val ) { m_minSpatialSegmentOffsetPlus1[i][j] = val; }
     462  Int  getMinSpatialSegmentOffsetPlus1( Int i, Int j ) { return m_minSpatialSegmentOffsetPlus1[i][j]; }
     463
     464  Void setCtuBasedOffsetEnabledFlag( Int i, Int j, Bool flag ) { m_ctuBasedOffsetEnabledFlag[i][j] = flag; }
     465  Bool getCtuBasedOffsetEnabledFlag( Int i, Int j ) { return m_ctuBasedOffsetEnabledFlag[i][j]; }
     466
     467  Void setMinHorizontalCtuOffsetPlus1( Int i, Int j, Int  val ) { m_minHorizontalCtuOffsetPlus1[i][j] = val; }
     468  Int  getMinHorizontalCtuOffsetPlus1( Int i, Int j ) { return m_minHorizontalCtuOffsetPlus1[i][j]; }
     469
     470};
     471
     472class TComRepFormat
     473{
     474private:
     475  Int  m_chromaFormatVpsIdc;
     476  Bool m_separateColourPlaneVpsFlag;
     477  Int  m_picWidthVpsInLumaSamples;
     478  Int  m_picHeightVpsInLumaSamples;
     479  Int  m_bitDepthVpsLumaMinus8;
     480  Int  m_bitDepthVpsChromaMinus8;
     481
     482public:
     483  TComRepFormat() { }; 
     484
     485  Void setChromaFormatVpsIdc( Int  val ) { m_chromaFormatVpsIdc = val; }
     486  Int  getChromaFormatVpsIdc(  ) { return m_chromaFormatVpsIdc; }
     487
     488  Void setSeparateColourPlaneVpsFlag( Bool flag ) { m_separateColourPlaneVpsFlag = flag; }
     489  Bool getSeparateColourPlaneVpsFlag(  ) { return m_separateColourPlaneVpsFlag; }
     490
     491  Void setPicWidthVpsInLumaSamples( Int  val ) { m_picWidthVpsInLumaSamples = val; }
     492  Int  getPicWidthVpsInLumaSamples(  ) { return m_picWidthVpsInLumaSamples; }
     493
     494  Void setPicHeightVpsInLumaSamples( Int  val ) { m_picHeightVpsInLumaSamples = val; }
     495  Int  getPicHeightVpsInLumaSamples(  ) { return m_picHeightVpsInLumaSamples; }
     496
     497  Void setBitDepthVpsLumaMinus8( Int  val ) { m_bitDepthVpsLumaMinus8 = val; }
     498  Int  getBitDepthVpsLumaMinus8(  ) { return m_bitDepthVpsLumaMinus8; }
     499
     500  Void setBitDepthVpsChromaMinus8( Int  val ) { m_bitDepthVpsChromaMinus8 = val; }
     501  Int  getBitDepthVpsChromaMinus8(  ) { return m_bitDepthVpsChromaMinus8; }
     502};
     503#endif
     504#endif
     505
    404506class TComVPS
    405507{
     
    407509  Int         m_VPSId;
    408510  UInt        m_uiMaxTLayers;
     511
     512#if H_MV5
     513#if H_MV
     514  UInt        m_uiMaxLayersMinus1;
     515#else
    409516  UInt        m_uiMaxLayers;
     517#endif
     518#else
     519  UInt        m_uiMaxLayers;
     520#endif
    410521  Bool        m_bTemporalIdNestingFlag;
    411522 
     
    440551  /// VPS EXTENSION SYNTAX ELEMENTS
    441552  Bool        m_avcBaseLayerFlag;
     553#if H_MV5
     554  Int         m_vpsVuiOffset;
     555#endif
    442556  Bool        m_splittingFlag;
     557#if H_MV5
     558  Bool        m_scalabilityMaskFlag          [MAX_NUM_SCALABILITY_TYPES];
     559#else
    443560  Bool        m_scalabilityMask          [MAX_NUM_SCALABILITY_TYPES];
     561#endif
    444562  Int         m_dimensionIdLen           [MAX_NUM_SCALABILITY_TYPES];
    445563  Bool        m_vpsNuhLayerIdPresentFlag;
    446564  Int         m_layerIdInNuh             [MAX_NUM_LAYER_IDS];
    447565  Int         m_dimensionId              [MAX_NUM_LAYER_IDS][MAX_NUM_SCALABILITY_TYPES]; 
     566#if H_MV5
     567  Int         m_viewIdLenMinus1;
     568  Int         m_viewIdVal                [MAX_NUM_LAYERS];
     569#endif
    448570  Bool        m_directDependencyFlag     [MAX_NUM_LAYER_IDS][MAX_NUM_LAYER_IDS];
     571#if H_MV5
     572  Bool        m_maxTidRefPresentFlag;
     573#endif
    449574  Int         m_maxTidIlRefPicPlus1      [MAX_NUM_LAYERS];
     575#if H_MV5
     576  Bool        m_allRefLayersActiveFlag;
     577#endif
    450578  Int         m_vpsNumberLayerSetsMinus1;
    451579  Int         m_vpsNumProfileTierLevelMinus1;   
     
    458586  Bool        m_outputLayerFlag          [MAX_VPS_OUTPUTLAYER_SETS][MAX_VPS_NUH_LAYER_ID_PLUS1];
    459587  Int         m_profileLevelTierIdx      [MAX_VPS_OUTPUTLAYER_SETS ];
     588#if H_MV5
     589  Bool        m_repFormatIdxPresentFlag;
     590  Int         m_vpsNumRepFormatsMinus1;
     591  Int         m_vpsRepFormatIdx          [MAX_NUM_LAYERS];
     592  TComRepFormat* m_repFormat             [MAX_NUM_LAYERS];
     593#endif
    460594  Bool        m_maxOneActiveRefLayerFlag;       
     595#if H_MV5
     596  Bool        m_crossLayerIrapAlignedFlag;
     597#endif
    461598  Int         m_directDepTypeLenMinus2;         
     599#if H_MV5
     600  Bool        m_vpsVuiPresentFlag;
     601  TComVPSVUI* m_vpsVUI;
     602#endif
    462603  Int         m_directDependencyType     [MAX_NUM_LAYERS] [MAX_NUM_LAYERS];
    463604
     
    475616  Bool        m_motionPredEnabledFlag    [MAX_NUM_LAYERS][MAX_NUM_LAYERS];
    476617  Int         m_motionPredRefLayerId     [MAX_NUM_LAYERS][MAX_NUM_LAYERS];
     618#if H_MV5
     619  Int         m_viewIndex                [MAX_NUM_LAYERS   ];
     620#else
    477621#if H_3D
    478622  Int         m_viewIndex                [MAX_NUM_LAYERS   ];
     
    480624
    481625  Int         xCeilLog2       ( Int val );
     626#endif
    482627  Int         xGetDimBitOffset( Int j );
    483628 
     629  // VPS EXTENSION 2 SYNTAX ELEMENTS
    484630#if H_3D_ARP
    485631  UInt        m_uiUseAdvResPred          [MAX_NUM_LAYERS   ];
     
    504650  Int*        m_iIdx2DepthValue          [MAX_NUM_LAYERS   ];
    505651#endif
    506 #if H_3D_TMVP
     652#if H_3D
    507653  Bool        m_ivMvScalingFlag;
    508654#endif
     
    535681  Void    setMaxTLayers  (UInt t)             { m_uiMaxTLayers = t; }
    536682 
     683#if H_MV5
     684#if H_MV   
     685  UInt    getMaxLayersMinus1()                { return m_uiMaxLayersMinus1;  };
     686  Void    setMaxLayersMinus1(UInt l)          { m_uiMaxLayersMinus1 = l; }
     687#else
    537688  UInt    getMaxLayers   ()                   { return m_uiMaxLayers;   }
    538689  Void    setMaxLayers   (UInt l)             { m_uiMaxLayers = l; }
     690#endif
     691#else
     692  UInt    getMaxLayers   ()                   { return m_uiMaxLayers;   }
     693  Void    setMaxLayers   (UInt l)             { m_uiMaxLayers = l; }
     694#endif
    539695
    540696  Bool    getTemporalNestingFlag   ()         { return m_bTemporalIdNestingFlag;   }
     
    579735  Bool    getAvcBaseLayerFlag()                                            { return m_avcBaseLayerFlag; }
    580736
     737#if H_MV5
     738  Void    setVpsVuiOffset( Int  val )                                      { m_vpsVuiOffset = val; }
     739  Int     getVpsVuiOffset(  )                                              { return m_vpsVuiOffset; }
     740#endif
     741
    581742  Void    setSplittingFlag( Bool val )                                     { m_splittingFlag = val;  }
    582743  Bool    getSplittingFlag()                                               { return m_splittingFlag; }
    583744
     745#if H_MV5
     746  Void    setScalabilityMaskFlag( UInt val );
     747  Void    setScalabilityMaskFlag( Int scalType, Bool val )                     { m_scalabilityMaskFlag[scalType] = val;  }
     748  Bool    getScalabilityMaskFlag( Int scalType )                               { return m_scalabilityMaskFlag[scalType]; }
     749#else
    584750  Void    setScalabilityMask( UInt val );
    585751
    586752  Void    setScalabilityMask( Int scalType, Bool val )              { m_scalabilityMask[scalType] = val;  }
    587753  Bool    getScalabilityMask( Int scalType )                        { return m_scalabilityMask[scalType]; }
    588 
     754#endif
    589755  Int     getNumScalabilityTypes( );
    590756
     
    603769  Int     getDimensionId( Int layerIdInVps, Int scalIdx )                  { return m_dimensionId[layerIdInVps][scalIdx]; }
    604770
     771#if H_MV5
     772  Void    setViewIdLenMinus1( Int  val )                                   { m_viewIdLenMinus1 = val; }
     773  Int     getViewIdLenMinus1(  )                                           { return m_viewIdLenMinus1; }
     774
     775  Void    setViewIdVal( Int viewOrderIndex, Int  val )                     { m_viewIdVal[viewOrderIndex] = val; }
     776  Int     getViewIdVal( Int viewOrderIndex )                               { return m_viewIdVal[viewOrderIndex]; }
     777#endif
    605778  Void    setDirectDependencyFlag( Int depLayeridInVps, Int refLayeridInVps, Bool val ) { m_directDependencyFlag[depLayeridInVps][refLayeridInVps] = val;  }
    606779  Bool    getDirectDependencyFlag( Int depLayeridInVps, Int refLayeridInVps )           { return m_directDependencyFlag[depLayeridInVps][refLayeridInVps]; }
    607780
     781#if H_MV5
     782  Void    setMaxTidRefPresentFlag( Bool flag )                             { m_maxTidRefPresentFlag = flag; }
     783  Bool    getMaxTidRefPresentFlag(  )                                      { return m_maxTidRefPresentFlag; }
     784#endif
    608785  Void    setMaxTidIlRefPicPlus1( Int layerIdInVps, Int val )              { m_maxTidIlRefPicPlus1[ layerIdInVps ] = val;  }
    609786  Int     getMaxTidIlRefPicPlus1( Int layerIdInVps )                       { return m_maxTidIlRefPicPlus1[ layerIdInVps ]; }
    610  
     787#if H_MV5
     788  Void    setAllRefLayersActiveFlag( Bool flag )                           { m_allRefLayersActiveFlag = flag; }
     789  Bool    getAllRefLayersActiveFlag(  )                                    { return m_allRefLayersActiveFlag; }
     790#endif
    611791  Void    setVpsNumberLayerSetsMinus1( Int val )                           { m_vpsNumberLayerSetsMinus1 = val;  }
    612792  Int     getVpsNumberLayerSetsMinus1( )                                   { return m_vpsNumberLayerSetsMinus1; }
     
    639819  Int     getProfileLevelTierIdx( Int outLayerSetIdx )                     { return m_profileLevelTierIdx[ outLayerSetIdx ]; }
    640820
     821#if H_MV5
     822  Void    setRepFormatIdxPresentFlag( Bool flag )                          { m_repFormatIdxPresentFlag = flag; }
     823  Bool    getRepFormatIdxPresentFlag(  )                                   { return m_repFormatIdxPresentFlag; }
     824
     825  Void    setVpsNumRepFormatsMinus1( Int  val )                            { m_vpsNumRepFormatsMinus1 = val; }
     826  Int     getVpsNumRepFormatsMinus1(  )                                    { return m_vpsNumRepFormatsMinus1; }
     827
     828  Void    setVpsRepFormatIdx( Int i, Int  val )                            { m_vpsRepFormatIdx[i] = val; }
     829  Int     getVpsRepFormatIdx( Int i )                                      { return m_vpsRepFormatIdx[i]; }
     830
     831  Void    setRepFormat( Int i, TComRepFormat* val )                        { m_repFormat[i] = val;  }
     832  TComRepFormat* getRepFormat( Int i )                                     { return m_repFormat[i]; }
     833#endif
    641834  Void    setMaxOneActiveRefLayerFlag( Bool flag)                          { m_maxOneActiveRefLayerFlag = flag; }
    642835  Bool    getMaxOneActiveRefLayerFlag( )                                   { return m_maxOneActiveRefLayerFlag; }
    643 
     836#if H_MV5
     837  Void    setCrossLayerIrapAlignedFlag( Bool flag )                        { m_crossLayerIrapAlignedFlag = flag; }
     838  Bool    getCrossLayerIrapAlignedFlag(  )                                 { return m_crossLayerIrapAlignedFlag; }
     839#endif
    644840  Void    setDirectDepTypeLenMinus2( Int val)                              { m_directDepTypeLenMinus2 = val; }
    645841  Int     getDirectDepTypeLenMinus2( )                                     { return m_directDepTypeLenMinus2; }
     
    647843  Void    setDirectDependencyType( Int depLayeridInVps, Int refLayeridInVps, Int val) { m_directDependencyType[ depLayeridInVps ][ refLayeridInVps ] = val; }
    648844  Int     getDirectDependencyType( Int depLayeridInVps, Int refLayeridInVps)   { return m_directDependencyType[ depLayeridInVps ][ refLayeridInVps ]; }
    649 
    650 
     845#if H_MV5 
     846  Void    setVpsVuiPresentFlag( Bool flag )                                { m_vpsVuiPresentFlag = flag; }
     847  Bool    getVpsVuiPresentFlag(  )                                         { return m_vpsVuiPresentFlag; }
     848
     849  TComVPSVUI* getVPSVUI(  )                                                { return m_vpsVUI;  }
     850#endif
    651851  // VPS EXTENSION SEMANTICS VARIABLES
    652852  Void    setLayerIdInVps( Int layerIdInNuh, Int val )                     { m_layerIdInVps[layerIdInNuh] = val;  }
     
    654854
    655855  Int     getScalabilityId ( Int layerIdInVps, ScalabilityType scalType );
     856#if H_MV5
     857  Int     getViewId        ( Int layerIdInNuh )                            { return m_viewIdVal[ getViewIndex( getLayerIdInVps( layerIdInNuh) )]; }
     858#else
    656859  Int     getViewId  ( Int layerIdInVps )                                  { return getScalabilityId( layerIdInVps, VIEW_ID  ); }
    657860
     861#endif
    658862  Void    setRefLayers();
    659863
     864#if H_MV5
     865  Int     getViewIndex    ( Int layerIdInNuh )                             { return getScalabilityId( getLayerIdInVps(layerIdInNuh), VIEW_ORDER_INDEX  ); }   
     866  Int     getNumViews();
     867
     868  Int     getNumDirectRefLayers( Int layerIdInNuh )                        { return m_numDirectRefLayers[ layerIdInNuh ];  };                               
     869  Int     getRefLayerId        ( Int layerIdInNuh, Int idx );;
     870#else
    660871  Int     getNumDirectRefLayers( Int layerIdInVps )          { return m_numDirectRefLayers[ layerIdInVps ];  };                               
    661872  Int     getRefLayerId        ( Int layerIdInVps, Int idx );;
     
    668879  Bool    getMotionPredEnabledFlag ( Int layerIdInVps, Int idx ) { return m_motionPredEnabledFlag [layerIdInVps][idx]; }
    669880  Int     getMotionPredRefLayerId  ( Int layerIdInVps, Int idx ) { return m_motionPredRefLayerId  [layerIdInVps][idx]; }
    670 
     881#endif 
    671882  Bool    checkVPSExtensionSyntax();
    672883  Int     scalTypeToScalIdx   ( ScalabilityType scalType );
    673884
     885  #if H_MV5
     886Int     getProfileLevelTierIdxLen()                                      { return gCeilLog2( getVpsNumProfileTierLevelMinus1() + 1 ); };       
     887#else
    674888  Int     getProfileLevelTierIdxLen() { return xCeilLog2( getVpsNumProfileTierLevelMinus1() + 1 ); };       
     889#endif
     890
    675891  Int     getNumLayersInIdList              ( Int lsIdx );;
    676892
     
    679895  Int     inferLastDimsionIdLenMinus1();
    680896
     897#if H_MV5
     898  // helpers
     899  Bool    getInDirectDependencyFlag( Int depLayeridInVps, Int refLayeridInVps, Int depth = 0 );
     900#endif
     901  /// VPS EXTENSION 2 SYNTAX ELEMENTS
    681902#if H_3D 
     903#if H_MV5
     904  Int     getDepthId      ( Int layerIdInNuh)                             { return getScalabilityId( getLayerIdInVps(layerIdInNuh), DEPTH_ID ); }
     905#else
    682906  Void    initViewIndex();
    683907  Int     getViewIndex    ( Int layerIdInVps )                             { return m_viewIndex[ layerIdInVps ]; }   
    684908  Int     getDepthId      ( Int layerIdInVps )                             { return getScalabilityId( layerIdInVps, DEPTH_ID ); }
     909#endif
    685910  Int     getLayerIdInNuh( Int viewIndex, Bool depthFlag );   
    686911
     
    716941#endif
    717942
    718 #if H_3D_TMVP
    719943  Bool    getIvMvScalingFlag   (  )                       { return m_ivMvScalingFlag; }
    720944  Void    setIvMvScalingFlag   ( Bool b )                 { m_ivMvScalingFlag = b;    } 
    721 #endif
    722945#if LGE_INTER_SDC_E0156
    723946  Bool    getInterSDCFlag      ( Int layerIdInVps )           { return m_bInterSDCFlag[layerIdInVps]; }
     
    737960  Int           m_winTopOffset;
    738961  Int           m_winBottomOffset;
     962#if H_MV5
     963#if H_MV
     964  Bool          m_scaledFlag;
     965#endif
     966#endif
    739967public:
    740968  Window()
     
    744972  , m_winTopOffset      (0)
    745973  , m_winBottomOffset   (0)
     974#if H_MV5
     975#if H_MV
     976  , m_scaledFlag(true)
     977#endif
     978#endif
    746979  { }
    747980
     
    757990  Void          setWindowBottomOffset(Int val)    { m_winBottomOffset = val; m_enabledFlag = true; }
    758991
     992#if H_MV5
     993#if H_MV
     994  Void          setScaledFlag(Bool flag)          { m_scaledFlag = flag;  }
     995  Bool          getScaledFlag() const             { return m_scaledFlag;  }
     996  Void          scaleOffsets( Int scal )         
     997  {
     998    if (! m_scaledFlag )
     999    {
     1000      m_scaledFlag         = true;
     1001      m_winLeftOffset     *= scal;
     1002      m_winRightOffset    *= scal;
     1003      m_winTopOffset      *= scal;
     1004      m_winBottomOffset   *= scal;
     1005    }
     1006  }
     1007#endif
     1008#endif
    7591009  Void          setWindow(Int offsetLeft, Int offsetLRight, Int offsetLTop, Int offsetLBottom)
    7601010  {
     
    8041054  TComHRD m_hrdParameters;
    8051055  TimingInfo m_timingInfo;
     1056#if !H_MV5
    8061057#if H_MV
    8071058  Bool m_tileBoundariesAlignedFlag;
     1059#endif
    8081060#endif
    8091061
     
    8391091    ,m_log2MaxMvLengthHorizontal(15)
    8401092    ,m_log2MaxMvLengthVertical(15)
     1093#if !H_MV5
    8411094#if H_MV
    8421095    ,m_tileBoundariesAlignedFlag(true)
     1096#endif
    8431097#endif
    8441098  {}
     
    9371191  TComHRD* getHrdParameters                 ()             { return &m_hrdParameters; }
    9381192  TimingInfo* getTimingInfo() { return &m_timingInfo; }
     1193#if !H_MV5
    9391194#if H_MV
    9401195Bool getTileBoundariesAlignedFlag(  ) { return m_tileBoundariesAlignedFlag; }
    9411196  Void setTileBoundariesAlignedFlag( Bool flag ) { m_tileBoundariesAlignedFlag = flag; }
    9421197#endif
     1198#endif
     1199
    9431200};
    9441201
     
    10241281  TComPTL     m_pcPTL;
    10251282#if H_MV
     1283#if H_MV5
     1284  TComVPS*    m_pcVPS;
     1285  // SPS
     1286  Bool        m_spsInferScalingListFlag;
     1287  Int         m_spsScalingListRefLayerId;
     1288  Bool        m_updateRepFormatFlag;
     1289#endif
     1290  // SPS Extension
    10261291  Bool        m_interViewMvVertConstraintFlag;
     1292#if !H_MV5
    10271293  Int         m_numIlpRestrictedRefLayers        ;
    10281294  Int         m_minSpatialSegmentOffsetPlus1[MAX_NUM_LAYERS];
    10291295  Bool        m_ctuBasedOffsetEnabledFlag   [MAX_NUM_LAYERS];
    10301296  Int         m_minHorizontalCtuOffsetPlus1 [MAX_NUM_LAYERS];
     1297#endif
    10311298#endif
    10321299#if H_3D
     
    11651432  TComPTL* getPTL()     { return &m_pcPTL; }
    11661433#if H_MV
     1434#if H_MV5
     1435  Void      setVPS          ( TComVPS* pcVPS ) { m_pcVPS = pcVPS; }
     1436  TComVPS*  getVPS          () { return m_pcVPS; }
     1437
     1438  Void setSpsInferScalingListFlag( Bool flag ) { m_spsInferScalingListFlag = flag; }
     1439  Bool getSpsInferScalingListFlag(  )          { return m_spsInferScalingListFlag; }
     1440
     1441  Void setSpsScalingListRefLayerId( Int  val ) { m_spsScalingListRefLayerId = val; }
     1442  Int  getSpsScalingListRefLayerId(  )         { return m_spsScalingListRefLayerId; }
     1443
     1444  Void setUpdateRepFormatFlag( Bool flag )     { m_updateRepFormatFlag = flag; }
     1445  Bool getUpdateRepFormatFlag(  )              { return m_updateRepFormatFlag; }
     1446#endif
     1447  // SPS Extension
    11671448  Void setInterViewMvVertConstraintFlag(Bool val) { m_interViewMvVertConstraintFlag = val; }
    11681449  Bool getInterViewMvVertConstraintFlag()         { return m_interViewMvVertConstraintFlag;}
    1169 
    1170   ////  sps_extension_vui_parameters( )
     1450#if H_MV5
     1451  // Inference
     1452  Void inferRepFormat( TComVPS* vps, Int layerIdCurr );
     1453
     1454  Void inferScalingList( TComSPS* spsSrc );
     1455#else
    11711456  Void setNumIlpRestrictedRefLayers   ( Int val )        { m_numIlpRestrictedRefLayers         = val;}
    11721457  Int  getNumIlpRestrictedRefLayers   ( )                { return m_numIlpRestrictedRefLayers        ;}
     
    11801465  Void setMinHorizontalCtuOffsetPlus1 ( Int i, Int val )   { m_minHorizontalCtuOffsetPlus1 [ i ] = val;}
    11811466  Int  getMinHorizontalCtuOffsetPlus1 ( Int i )            { return m_minHorizontalCtuOffsetPlus1 [ i ];}
     1467
     1468#endif
    11821469#endif
    11831470#if H_3D_QTLPC
     
    12951582  Int m_numExtraSliceHeaderBits;
    12961583
     1584#if H_MV5
     1585#if H_MV
     1586  Int  m_layerId;
     1587  Bool m_ppsInferScalingListFlag;
     1588  Int  m_ppsScalingListRefLayerId;
     1589#endif
     1590#endif
    12971591public:
    12981592  TComPPS();
     
    14161710  Bool getSliceHeaderExtensionPresentFlag   ()                    { return m_sliceHeaderExtensionPresentFlag; }
    14171711  Void setSliceHeaderExtensionPresentFlag   (Bool val)            { m_sliceHeaderExtensionPresentFlag = val; }
     1712#if H_MV5
     1713#if H_MV
     1714  Void setLayerId( Int  val ) { m_layerId = val; }
     1715  Int  getLayerId(  ) { return m_layerId; }
     1716
     1717  Void setPpsInferScalingListFlag( Bool flag ) { m_ppsInferScalingListFlag = flag; }
     1718  Bool getPpsInferScalingListFlag(  ) { return m_ppsInferScalingListFlag; }
     1719
     1720  Void setPpsScalingListRefLayerId( Int  val ) { m_ppsScalingListRefLayerId = val; }
     1721  Int  getPpsScalingListRefLayerId(  ) { return m_ppsScalingListRefLayerId; }
     1722#endif
     1723#endif
    14181724};
    14191725
     
    14481754  Bool        m_PicOutputFlag;        ///< pic_output_flag
    14491755  Int         m_iPOC;
     1756#if H_MV5
     1757#if H_MV
     1758  Int         m_iPOCBeforeReset;
     1759#endif
     1760#endif
    14501761  Int         m_iLastIDR;
    14511762  static Int  m_prevPOC;
     
    15421853  Bool       m_enableTMVPFlag;
    15431854#if H_MV
     1855#if H_MV5
     1856  std::vector<TComPic*>* m_refPicSetInterLayer0;
     1857  std::vector<TComPic*>* m_refPicSetInterLayer1;
     1858  Int        m_layerId;
     1859  Int        m_viewId;
     1860  Int        m_viewIndex;
     1861#if H_3D
     1862  Bool       m_isDepth;
     1863#endif
     1864#else
    15441865  std::vector<TComPic*>* m_refPicSetInterLayer;
    15451866  Int        m_layerId;
     
    15491870  Bool       m_isDepth;
    15501871#endif
     1872#endif
    15511873
    15521874// Additional slice header syntax elements
     1875#if H_MV5
     1876  Bool       m_pocResetFlag;
     1877#endif
    15531878  Bool       m_discardableFlag;
    15541879  Bool       m_interLayerPredEnabledFlag;
    15551880  Int        m_numInterLayerRefPicsMinus1;
    15561881  Int        m_interLayerPredLayerIdc       [MAX_NUM_LAYERS];
     1882#if !H_MV5
    15571883  Bool       m_interLayerSamplePredOnlyFlag;
    15581884  Bool       m_altCollocatedIndicationFlag;
     
    15621888  Int        m_activeMotionPredRefLayerId   [ MAX_NUM_LAYER_IDS ];
    15631889
     1890#endif
    15641891  Int        m_aaiCodedScale [2][MAX_NUM_LAYERS];
    15651892  Int        m_aaiCodedOffset[2][MAX_NUM_LAYERS];
     
    16401967  TComPic*  getIvPic            ( Bool depthFlag, Int viewIndex){ return  m_ivPicsCurrPoc[ depthFlag ? 1 : 0 ][ viewIndex ]; }
    16411968#endif
    1642 #if H_3D_IV_MERGE
     1969#if H_3D
    16431970  TComPic*  getTexturePic       ()                              { return  m_ivPicsCurrPoc[0][ m_viewIndex ]; }
    16441971#endif
     
    16952022 
    16962023#if H_MV
     2024#if H_MV5
     2025  Void      setPocBeforeReset   ( Int i )                       { m_iPOCBeforeReset = i; }
     2026  Int       getPocBeforeReset   ( )                             { return m_iPOCBeforeReset; }
     2027#endif
    16972028  Int       getRefLayerId        ( RefPicList e, Int iRefIdx)    { return  m_aiRefLayerIdList[e][iRefIdx]; }
    16982029  Void      setRefLayerId        ( Int i, RefPicList e, Int iRefIdx ) { m_aiRefLayerIdList[e][iRefIdx] = i; }
    1699 #endif
    1700 #if H_MV
     2030#if H_MV5
     2031  Void      getTempRefPicLists   ( TComList<TComPic*>& rcListPic, std::vector<TComPic*>& refPicSetInterLayer0, std::vector<TComPic*>& refPicSetInterLayer1,                                     
     2032                                   std::vector<TComPic*> rpsCurrList[2], std::vector<Bool> usedAsLongTerm[2], Int& numPocTotalCurr, Bool checkNumPocTotalCurr = false );
     2033
     2034  Void      setRefPicList        ( std::vector<TComPic*> rpsCurrList[2], std::vector<Bool> usedAsLongTerm[2], Int numPocTotalCurr, Bool checkNumPocTotalCurr = false );
     2035#else
    17012036  Void      setRefPicList       ( TComList<TComPic*>& rcListPic, std::vector<TComPic*>& interLayerRefPicSet , Bool checkNumPocTotalCurr = false );
     2037#endif
    17022038#else
    17032039#if FIX1071
     
    17482084  Void applyReferencePictureSet( TComList<TComPic*>& rcListPic, TComReferencePictureSet *RPSList);
    17492085#if H_MV
     2086#if !H_MV5
    17502087  Void createAndApplyIvReferencePictureSet( TComPicLists* ivPicLists, std::vector<TComPic*>& refPicSetInterLayer );
    17512088  static Void markIvRefPicsAsShortTerm    ( std::vector<TComPic*> refPicSetInterLayer );
     2089#else
     2090  Void createInterLayerReferencePictureSet( TComPicLists* ivPicLists, std::vector<TComPic*>& refPicSetInterLayer0, std::vector<TComPic*>& refPicSetInterLayer1 );
     2091  static Void markIvRefPicsAsShortTerm    ( std::vector<TComPic*> refPicSetInterLayer0, std::vector<TComPic*> refPicSetInterLayer1 );
     2092#endif
    17522093  static Void markCurrPic                 ( TComPic* currPic );;
    17532094  static Void markIvRefPicsAsUnused       ( TComPicLists* ivPicLists, std::vector<Int> targetDecLayerIdSet, TComVPS* vps, Int curLayerId, Int curPoc  );
     2095#if H_MV5
     2096  Void        printRefPicList();
     2097#else
    17542098  Void        xPrintRefPicList();
     2099#endif
    17552100#endif
    17562101  Bool isTemporalLayerSwitchingPoint( TComList<TComPic*>& rcListPic );
     
    18392184  Void      setViewId             ( Int viewId )     { m_viewId = viewId;   }
    18402185  Int       getViewId             ()                 { return m_viewId;     }
     2186#if H_MV5
     2187  Void      setViewIndex          ( Int viewIndex )  { m_viewIndex = viewIndex;   }
     2188  Int       getViewIndex          ()                 { return m_viewIndex;     }
     2189#endif
    18412190#if H_3D
    18422191#if H_3D_TMVP
     
    18452194  Int       getAlterRefIdx          ( RefPicList e )        { return  m_aiAlterRefIdx[e];     }
    18462195#endif
     2196#if !H_MV5
    18472197  Void      setViewIndex          ( Int viewIndex )  { m_viewIndex = viewIndex;   }
    18482198  Int       getViewIndex          ()                 { return m_viewIndex;     }
     2199#endif
    18492200  Void      setIsDepth            ( Bool isDepth )   { m_isDepth = isDepth; }
    18502201  Bool      getIsDepth            ()                 { return m_isDepth; }
     
    18672218#if H_MV
    18682219// Additional slice header syntax elements
     2220
     2221#if H_MV5
     2222  Void setPocResetFlag( Bool flag ) { m_pocResetFlag = flag; }
     2223  Bool getPocResetFlag(  ) { return m_pocResetFlag; }
     2224#endif
     2225
    18692226Void setDiscardableFlag( Bool flag ) { m_discardableFlag = flag; }
    18702227Bool getDiscardableFlag(  ) { return m_discardableFlag; }
     
    18792236Int  getInterLayerPredLayerIdc( Int i ) { return m_interLayerPredLayerIdc[i]; }
    18802237
     2238#if H_MV5
     2239  // Additional variables derived in slice header semantics
     2240  Int  getNumInterLayerRefPicsMinus1Len( ) { return gCeilLog2(  getVPS()->getNumDirectRefLayers( getLayerId() )); }
     2241  Int  getInterLayerPredLayerIdcLen    ( ) { return gCeilLog2(  getVPS()->getNumDirectRefLayers( getLayerId() )); }
     2242
     2243  Int  getNumActiveRefLayerPics( );
     2244
     2245  Int  getNumActiveRefLayerPics0( )        { return (Int) m_refPicSetInterLayer0->size();  };
     2246  Int  getNumActiveRefLayerPics1( )        { return (Int) m_refPicSetInterLayer1->size();  };
     2247
     2248  Int  getRefPicLayerId               ( Int i );
     2249
     2250  Void     setRefPicSetInterLayer       ( std::vector<TComPic*>* refPicSetInterLayer0, std::vector<TComPic*>* refPicSetInterLayer1);
     2251  TComPic* getPicFromRefPicSetInterLayer( Int setIdc, Int layerId );
     2252#else
    18812253Void setInterLayerSamplePredOnlyFlag( Bool flag ) { m_interLayerSamplePredOnlyFlag = flag; }
    18822254Bool getInterLayerSamplePredOnlyFlag(  ) { return m_interLayerSamplePredOnlyFlag; }
     
    19052277TComPic* getPicFromRefPicSetInterLayer( Int layerId );
    19062278
     2279#endif
    19072280#endif
    19082281protected:
     
    19112284TComPic*  xGetLongTermRefPic(TComList<TComPic*>& rcListPic, Int poc, Bool pocHasMsb);
    19122285#if H_MV
     2286#if !H_MV5
    19132287  Int       xCeilLog2( Int val );
     2288#endif
    19142289  TComPic*  xGetInterLayerRefPic( std::vector<TComPic*>& rcListIlPic, Int layerId ); 
    19152290#endif
     
    19932368  //! activate a SPS from a active parameter sets SEI message
    19942369  //! \returns true, if activation is successful
     2370#if !H_MV5
    19952371  Bool activateSPSWithSEI(Int SPSId);
    19962372
     
    20122388  Int m_activeSPSId;
    20132389  Int m_activePPSId;
     2390#else
     2391#if H_MV
     2392  Bool activateSPSWithSEI(Int SPSId, Int layerId );
     2393#else
     2394  Bool activateSPSWithSEI(Int SPSId);
     2395#endif
     2396
     2397  //! activate a PPS and depending on isIDR parameter also SPS and VPS
     2398  //! \returns true, if activation is successful
     2399#if H_MV
     2400  Bool activatePPS(Int ppsId, Bool isIRAP, Int layerId );
     2401#else
     2402  Bool activatePPS(Int ppsId, Bool isIRAP);
     2403#endif
     2404
     2405  TComVPS* getActiveVPS(){ return m_vpsMap.getPS(m_activeVPSId); };
     2406#if H_MV
     2407  TComSPS* getActiveSPS( Int layerId ){ return m_spsMap.getPS( m_activeSPSId[ layerId ] ); };
     2408  TComPPS* getActivePPS( Int layerId ){ return m_ppsMap.getPS( m_activePPSId[ layerId ] ); };
     2409#else
     2410  TComSPS* getActiveSPS(){ return m_spsMap.getPS(m_activeSPSId); };
     2411  TComPPS* getActivePPS(){ return m_ppsMap.getPS(m_activePPSId); };
     2412#endif
     2413protected:
     2414 
     2415  ParameterSetMap<TComVPS> m_vpsMap;
     2416  ParameterSetMap<TComSPS> m_spsMap;
     2417  ParameterSetMap<TComPPS> m_ppsMap;
     2418
     2419  Int m_activeVPSId;
     2420#if H_MV
     2421  Int m_activeSPSId[ MAX_NUM_LAYERS ];
     2422  Int m_activePPSId[ MAX_NUM_LAYERS ];
     2423#else
     2424  Int m_activeSPSId;
     2425  Int m_activePPSId;
     2426#endif
     2427
     2428#endif
    20142429};
    20152430
  • trunk/source/Lib/TLibCommon/TComWedgelet.cpp

    r608 r622  
    175175}
    176176
     177#if !SEC_DMM2_E0146_HHIFIX
    177178Bool TComWedgelet::checkPredDirAbovePossible( UInt uiPredDirBlockSize, UInt uiPredDirBlockOffset )
    178179{
     
    642643  }
    643644}
     645#endif
    644646
    645647Void TComWedgelet::xGenerateWedgePattern()
  • trunk/source/Lib/TLibCommon/TComWedgelet.h

    r608 r622  
    5050enum DIM_IDX
    5151{
    52 #if SEC_DMM2_E0146
     52#if SEC_DMM2_E0146_HHIFIX
    5353  DMM1_IDX = 0,
    5454  DMM3_IDX = 1,
     
    6363#endif
    6464};
    65 #if SEC_DMM2_E0146
     65#if SEC_DMM2_E0146_HHIFIX
    6666#define DMM_NUM_TYPE   3
    6767#else
     
    8686#define DMM_NO_WEDGEINDEX       MAX_UINT
    8787#define DMM_NUM_WEDGE_REFINES   8
    88 #if !SEC_DMM2_E0146
     88#if !SEC_DMM2_E0146_HHIFIX
    8989#define DMM2_DELTAEND_MAX       4
    9090#endif
     
    151151  Bool  checkInvIdentical( Bool* pbRefPattern );
    152152
     153#if !SEC_DMM2_E0146_HHIFIX
    153154  // functions for DMM2 prediction
    154155  Bool  checkPredDirAbovePossible( UInt uiPredDirBlockSize, UInt uiPredDirBlockOffsett );
     
    156157  Void  getPredDirStartEndAbove( UChar& ruhXs, UChar& ruhYs, UChar& ruhXe, UChar& ruhYe, UInt uiPredDirBlockSize, UInt uiPredDirBlockOffset, Int iDeltaEnd );
    157158  Void  getPredDirStartEndLeft ( UChar& ruhXs, UChar& ruhYs, UChar& ruhXe, UChar& ruhYe, UInt uiPredDirBlockSize, UInt uiPredDirBlockOffset, Int iDeltaEnd );
     159#endif
    158160};  // END CLASS DEFINITION TComWedgelet
    159161
  • trunk/source/Lib/TLibCommon/TComYuv.cpp

    r608 r622  
    110110  {
    111111    ::memcpy( pDst, pSrc, sizeof(Pel)*iWidth);
     112
     113#if ENC_DEC_TRACE && H_MV_ENC_DEC_TRAC
     114    if ( g_traceCopyBack && g_nSymbolCounter >= g_stopAtCounter )
     115    {
     116      for ( Int x = 0; x < iWidth; x++)
     117      {     
     118        std::cout << pSrc[ x ] << " " ;
     119      }
     120      std::cout << std::endl;
     121    }
     122#endif
     123
    112124    pDst += iDstStride;
    113125    pSrc += iSrcStride;
  • trunk/source/Lib/TLibCommon/TypeDef.h

    r608 r622  
    9292                                              // QC_CU_NBDV_D0181
    9393                                              // SEC_DEFAULT_DV_D0112
     94                                              // MTK_DVMCP_FIX_E0172               1 // fix the mismatch between software and WD for DV derivation from DVMCP blocks, issue 2 in JCT3V-E0172
    9495#define H_3D_ARP                          1   // Advanced residual prediction (ARP), JCT3V-D0177
    9596#define H_3D_IC                           1   // Illumination Compensation, JCT3V-B0045, JCT3V-C0046, JCT3V-D0060
     
    110111                                              // QC_D0191: Clean up
    111112                                              // LG_D0092: Multiple VSP candidate allowed
    112 
     113                                              // MTK_VSP_FIX_ALIGN_WD_E0172
    113114#define H_3D_IV_MERGE                     1   // Inter-view motion merge candidate
    114115                                              // HHI_INTER_VIEW_MOTION_PRED
     
    119120                                              // QC_AMVP_MRG_UNIFY_IVCAN_C0051     
    120121                                              // TEXTURE MERGING CANDIDATE     , JCT3V-C0137
     122                                              // QC_INRIA_MTK_MRG_E0126           
    121123#define H_3D_TMVP                         1   // QC_TMVP_C0047
    122124                                              // Sony_M23639
     
    161163#define MTK_DIVMC_FIX_E0172               1 // fix the issue of derivation of disparity inter-view merge candidate, issue 5 in JCT3V-E0172
    162164#define MTK_NBDV_TN_FIX_E0172             1 // fix the issue of DV derivation from the temporal neighboring blocks, issue 7 in JCT3V-E0172
    163 #define MTK_DVMCP_FIX_E0172               1 // fix the mismatch between software and WD for DV derivation from DVMCP blocks, issue 2 in JCT3V-E0172
    164 #define MTK_VSP_FIX_ALIGN_WD_E0172        1 // fix the issues related to VSP merge candidate, issue 3, 4 in JCT3V-E0172, using an implementation aligned with WD
    165 
    166 #if !MTK_VSP_FIX_ALIGN_WD_E0172
    167 #define MTK_VSP_FIX_E0172                 1 // fix the issues related to VSP merge candidate, issue 3, 4 in JCT3V-E0172
    168 #endif
    169165#endif // MTK_RVS_BUGFIX_E0172
    170166
     
    175171#endif // H_3D_NBDV
    176172
    177 #if H_3D_IV_MERGE
    178 #define QC_INRIA_MTK_MRG_E0126            1   // additional merge candidates JCT3V-E0126
    179 #endif
    180 
    181173#if H_3D_DIM
    182 #define SEC_DMM2_E0146                    1   // Removal of DMM2 from DMMs
     174#define SEC_DMM2_E0146_HHIFIX             1   // Removal of DMM2 from DMMs
    183175#define ZJU_DEPTH_INTRA_MODE_E0204        1   // Simplified Binarization for depth_intra_mode
    184176#define KWU_SDC_SIMPLE_DC_E0117           1   // Simplified DC calculation for SDC
    185177#define SCU_HS_DMM4_REMOVE_DIV_E0242      1   // DMM4 Division Removal
    186 #define SCU_HS_FAST_DEPTH_INTRA_E0238     1   // Fast DMM and RBC Mode Selection
     178#define SCU_HS_FAST_DEPTH_INTRA_E0238_HHIFIX     1   // Fast DMM and RBC Mode Selection
    187179#endif
    188180
     
    215207
    216208
    217 
    218 
     209/// FIXES
     210#if H_MV
     211#define H_MV_FIX_LID_PIC_HASH_SEI_T40                      1   // Fix wrong layer_id in decoded picture hash SEI
     212#define H_MV5                                              1   // Update to MV-HEVC 5 HLS
     213#endif
    219214/////////////////////////////////////////////////////////////////////////////////////////
    220215///////////////////////////////////   DERIVED DEFINES /////////////////////////////////// 
     
    265260#endif
    266261#if H_3D_DIM_DMM
    267 #define LGE_PKU_DMM3_OVERLAP_E0159        1   // Removal of overlap between DMM3 and DMM1
     262#define LGE_PKU_DMM3_OVERLAP_E0159_HHIFIX 1   // Removal of overlap between DMM3 and DMM1
    268263#endif
    269264#endif
     
    271266///// ***** VIEW SYNTHESIS PREDICTION *********
    272267#if H_3D_VSP
    273 #define H_3D_VSP_POSITION                 3   // The only supported position
    274268#define H_3D_VSP_BLOCKSIZE                4   // Supported values: 1, 2, and 4
    275269#if H_3D_VSP_BLOCKSIZE == 1
     
    799793  enum ScalabilityType
    800794  {
     795#if H_MV5
     796#if H_3D
     797    DEPTH_ID = 0,   
     798#endif   
     799    VIEW_ORDER_INDEX  = 1,
     800#else
    801801    VIEW_ID  = 0,
    802802#if H_3D
    803803    DEPTH_ID = 1,   
    804804#endif   
     805#endif
    805806  };
    806807#endif
Note: See TracChangeset for help on using the changeset viewer.