Changeset 622 in 3DVCSoftware for trunk/source/Lib/TLibCommon
- Timestamp:
- 11 Sep 2013, 14:40:25 (12 years ago)
- Location:
- trunk/source/Lib/TLibCommon
- Files:
-
- 18 edited
Legend:
- Unmodified
- Added
- Removed
-
trunk/source/Lib/TLibCommon/CommonDef.h
r609 r622 48 48 #endif // _MSC_VER > 1000 49 49 #include "TypeDef.h" 50 #if H_MV 51 #include <assert.h> 52 #endif 50 53 51 54 //! \ingroup TLibCommon … … 183 186 return (t < 0) ? T(-1) : T(1); 184 187 } 188 189 #if H_MV5 190 template <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 185 199 186 200 #define RemoveBitIncrement( exp ) ( exp >> ( g_bitDepthY - 8 ) ) -
trunk/source/Lib/TLibCommon/ContextTables.h
r608 r622 112 112 #if H_3D_DIM_DMM 113 113 #define NUM_DMM1_DATA_CTX 1 ///< number of context models for DMM1 data 114 #if !SEC_DMM2_E0146 114 #if !SEC_DMM2_E0146_HHIFIX 115 115 #define NUM_DMM2_DATA_CTX 1 ///< number of context models for DMM2 data 116 116 #endif … … 429 429 { CNU }, 430 430 }; 431 #if !SEC_DMM2_E0146 431 #if !SEC_DMM2_E0146_HHIFIX 432 432 static const UChar 433 433 INIT_DMM2_DATA[3][NUM_DMM2_DATA_CTX] = -
trunk/source/Lib/TLibCommon/TComDataCU.cpp
r608 r622 120 120 m_dmmWedgeTabIdx[i] = NULL; 121 121 } 122 #if !SEC_DMM2_E0146 122 #if !SEC_DMM2_E0146_HHIFIX 123 123 m_dmm2DeltaEnd = NULL; 124 124 #endif … … 146 146 #if H_3D_VSP 147 147 m_piVSPFlag = NULL; 148 #if MTK_VSP_FIX_E0172149 m_piVSPDir = NULL;150 #endif151 148 #endif 152 149 #if H_3D_ARP … … 200 197 #if H_3D_VSP 201 198 m_piVSPFlag = (Char* )xMalloc(Char, uiNumPartition); 202 #if MTK_VSP_FIX_E0172203 m_piVSPDir = (Char* )xMalloc(Char, uiNumPartition);204 #endif205 199 #endif 206 200 m_puhLumaIntraDir = (UChar* )xMalloc(UChar, uiNumPartition); … … 280 274 m_dmmWedgeTabIdx[i] = (UInt*)xMalloc(UInt, uiNumPartition); 281 275 } 282 #if !SEC_DMM2_E0146 276 #if !SEC_DMM2_E0146_HHIFIX 283 277 m_dmm2DeltaEnd = (Int* )xMalloc(Int, uiNumPartition); 284 278 #endif … … 363 357 #if H_3D_VSP 364 358 if ( m_piVSPFlag ) { xFree(m_piVSPFlag); m_piVSPFlag = NULL; } 365 #if MTK_VSP_FIX_E0172366 if ( m_piVSPDir ) { xFree(m_piVSPDir ); m_piVSPDir = NULL; }367 #endif368 359 #endif 369 360 if ( m_puhLumaIntraDir ) { xFree(m_puhLumaIntraDir); m_puhLumaIntraDir = NULL; } … … 419 410 if ( m_dmmWedgeTabIdx[i] ) { xFree( m_dmmWedgeTabIdx[i] ); m_dmmWedgeTabIdx[i] = NULL; } 420 411 } 421 #if !SEC_DMM2_E0146 412 #if !SEC_DMM2_E0146_HHIFIX 422 413 if ( m_dmm2DeltaEnd ) { xFree( m_dmm2DeltaEnd ); m_dmm2DeltaEnd = NULL; } 423 414 #endif … … 573 564 #if H_3D_VSP 574 565 m_piVSPFlag[ui] = pcFrom->m_piVSPFlag[ui]; 575 #if MTK_VSP_FIX_E0172576 m_piVSPDir [ui] = pcFrom->m_piVSPDir[ui];577 #endif578 566 #endif 579 567 m_puhLumaIntraDir[ui]=pcFrom->m_puhLumaIntraDir[ui]; … … 618 606 #if H_3D_VSP 619 607 memset( m_piVSPFlag + firstElement, 0, numElements * sizeof( *m_piVSPFlag ) ); 620 #if MTK_VSP_FIX_E0172621 memset( m_piVSPDir + firstElement, 0, numElements * sizeof( *m_piVSPDir ) );622 #endif623 608 #endif 624 609 memset( m_puhLumaIntraDir + firstElement, DC_IDX, numElements * sizeof( *m_puhLumaIntraDir ) ); … … 646 631 memset( m_dmmWedgeTabIdx[i] + firstElement, 0, numElements * sizeof( *m_dmmWedgeTabIdx[i] ) ); 647 632 } 648 #if !SEC_DMM2_E0146 633 #if !SEC_DMM2_E0146_HHIFIX 649 634 memset( m_dmm2DeltaEnd + firstElement, 0, numElements * sizeof( *m_dmm2DeltaEnd ) ); 650 635 #endif … … 802 787 #if H_3D_VSP 803 788 m_piVSPFlag[ui] = 0; 804 #if MTK_VSP_FIX_E0172805 m_piVSPDir [ui] = 0;806 #endif807 789 #endif 808 790 m_puhLumaIntraDir[ui] = DC_IDX; … … 829 811 m_dmmWedgeTabIdx[i] [ui] = 0; 830 812 } 831 #if !SEC_DMM2_E0146 813 #if !SEC_DMM2_E0146_HHIFIX 832 814 m_dmm2DeltaEnd [ui] = 0; 833 815 #endif … … 906 888 #if H_3D_VSP 907 889 memset( m_piVSPFlag, 0, sizeof( Char ) * m_uiNumPartition ); 908 #if MTK_VSP_FIX_E0172909 memset( m_piVSPDir , 0, sizeInChar );910 #endif911 890 #endif 912 891 memset( m_puhLumaIntraDir, DC_IDX, iSizeInUchar ); … … 946 925 memset( m_dmmWedgeTabIdx[i], 0, sizeof(UInt) * m_uiNumPartition ); 947 926 } 948 #if !SEC_DMM2_E0146 927 #if !SEC_DMM2_E0146_HHIFIX 949 928 memset( m_dmm2DeltaEnd , 0, sizeof(Int ) * m_uiNumPartition ); 950 929 #endif … … 1005 984 #if H_3D_VSP 1006 985 m_piVSPFlag[ui]=pcCU->m_piVSPFlag[uiPartOffset+ui]; 1007 #if MTK_VSP_FIX_ALIGN_WD_E01721008 986 m_pDvInfo[ ui ] = pcCU->m_pDvInfo[uiPartOffset+ui]; 1009 #endif1010 #if MTK_VSP_FIX_E01721011 m_piVSPDir[ui]=pcCU->m_piVSPDir[uiPartOffset+ui];1012 #endif1013 987 #endif 1014 988 m_puhLumaIntraDir[ui]=pcCU->m_puhLumaIntraDir[uiPartOffset+ui]; … … 1036 1010 m_dmmWedgeTabIdx[i] [ui] = pcCU->m_dmmWedgeTabIdx[i] [uiPartOffset+ui]; 1037 1011 } 1038 #if !SEC_DMM2_E0146 1012 #if !SEC_DMM2_E0146_HHIFIX 1039 1013 m_dmm2DeltaEnd [ui] = pcCU->m_dmm2DeltaEnd [uiPartOffset+ui]; 1040 1014 #endif … … 1162 1136 #if H_3D_VSP 1163 1137 m_piVSPFlag = pcCU->getVSPFlag() + uiPart; 1164 #if MTK_VSP_FIX_E01721165 m_piVSPDir = pcCU->getVSPDir () + uiPart;1166 #endif1167 1138 #endif 1168 1139 … … 1196 1167 m_dmmWedgeTabIdx[i] = pcCU->getDmmWedgeTabIdx( i ) + uiPart; 1197 1168 } 1198 #if !SEC_DMM2_E0146 1169 #if !SEC_DMM2_E0146_HHIFIX 1199 1170 m_dmm2DeltaEnd = pcCU->getDmm2DeltaEnd() + uiPart; 1200 1171 #endif … … 1321 1292 #if H_3D_VSP 1322 1293 m_piVSPFlag = pcCU->getVSPFlag() + uiAbsPartIdx; 1323 #if MTK_VSP_FIX_ALIGN_WD_E01721324 1294 m_pDvInfo = pcCU->getDvInfo() + uiAbsPartIdx; 1325 #endif1326 #if MTK_VSP_FIX_E01721327 m_piVSPDir = pcCU->getVSPDir () + uiAbsPartIdx;1328 #endif1329 1295 #endif 1330 1296 … … 1374 1340 #if H_3D_VSP 1375 1341 memcpy( m_piVSPFlag + uiOffset, pcCU->getVSPFlag(), sizeof( Char ) * uiNumPartition ); 1376 #if MTK_VSP_FIX_ALIGN_WD_E01721377 1342 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 1382 1344 #endif 1383 1345 memcpy( m_puhLumaIntraDir + uiOffset, pcCU->getLumaIntraDir(), iSizeInUchar ); … … 1404 1366 memcpy( m_dmmWedgeTabIdx[i] + uiOffset, pcCU->getDmmWedgeTabIdx( i ), sizeof(UInt) * uiNumPartition ); 1405 1367 } 1406 #if !SEC_DMM2_E0146 1368 #if !SEC_DMM2_E0146_HHIFIX 1407 1369 memcpy( m_dmm2DeltaEnd + uiOffset, pcCU->getDmm2DeltaEnd() , sizeof(Int ) * uiNumPartition ); 1408 1370 #endif … … 1509 1471 #if H_3D_VSP 1510 1472 memcpy( rpcCU->getVSPFlag() + m_uiAbsIdxInLCU, m_piVSPFlag, sizeof( Char ) * m_uiNumPartition ); 1511 #if MTK_VSP_FIX_ALIGN_WD_E01721512 1473 memcpy( rpcCU->getDvInfo() + m_uiAbsIdxInLCU, m_pDvInfo, sizeof( *m_pDvInfo ) * m_uiNumPartition ); 1513 #endif1514 #if MTK_VSP_FIX_E01721515 memcpy( rpcCU->getVSPDir () + m_uiAbsIdxInLCU, m_piVSPDir , sizeInChar );1516 #endif1517 1474 #endif 1518 1475 memcpy( rpcCU->getLumaIntraDir() + m_uiAbsIdxInLCU, m_puhLumaIntraDir, iSizeInUchar ); … … 1539 1496 memcpy( rpcCU->getDmmWedgeTabIdx( i ) + m_uiAbsIdxInLCU, m_dmmWedgeTabIdx[i], sizeof(UInt) * m_uiNumPartition ); 1540 1497 } 1541 #if !SEC_DMM2_E0146 1498 #if !SEC_DMM2_E0146_HHIFIX 1542 1499 memcpy( rpcCU->getDmm2DeltaEnd() + m_uiAbsIdxInLCU, m_dmm2DeltaEnd , sizeof(Int ) * m_uiNumPartition ); 1543 1500 #endif … … 1632 1589 #if H_3D_VSP 1633 1590 memcpy( rpcCU->getVSPFlag() + uiPartOffset, m_piVSPFlag, sizeof(Char) * uiQNumPart ); 1634 #if MTK_VSP_FIX_E01721635 memcpy( rpcCU->getVSPDir () + uiPartOffset, m_piVSPDir , sizeInChar );1636 #endif1637 1591 #endif 1638 1592 memcpy( rpcCU->getLumaIntraDir() + uiPartOffset, m_puhLumaIntraDir, iSizeInUchar ); … … 1658 1612 memcpy( rpcCU->getDmmWedgeTabIdx( i ) + uiPartOffset, m_dmmWedgeTabIdx[i], sizeof(UInt) * uiQNumPart ); 1659 1613 } 1660 #if !SEC_DMM2_E0146 1614 #if !SEC_DMM2_E0146_HHIFIX 1661 1615 memcpy( rpcCU->getDmm2DeltaEnd() + uiPartOffset, m_dmm2DeltaEnd , sizeof(Int ) * uiQNumPart ); 1662 1616 #endif … … 2761 2715 setSubPart<Char>( iVSPFlag, m_piVSPFlag, uiAbsPartIdx, uiDepth, uiPartIdx ); 2762 2716 } 2763 #if MTK_VSP_FIX_ALIGN_WD_E01722717 #if H_3D_VSP 2764 2718 template<typename T> 2765 2719 Void TComDataCU::setSubPartT( T uiParameter, T* puhBaseLCU, UInt uiCUAddr, UInt uiCUDepth, UInt uiPUIdx ) … … 2895 2849 } 2896 2850 2897 }2898 #endif2899 #if MTK_VSP_FIX_E01722900 Void TComDataCU::setVSPDirSubParts ( Char iVSPDir, UInt uiAbsPartIdx, UInt uiPartIdx, UInt uiDepth )2901 {2902 setSubPart<Char>( iVSPDir, m_piVSPDir, uiAbsPartIdx, uiDepth, uiPartIdx );2903 2851 } 2904 2852 #endif … … 3355 3303 * false: otherwise 3356 3304 */ 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, 3305 inline Bool TComDataCU::xAddVspCand( Int mrgCandIdx, DisInfo* pDInfo, Int& iCount, 3362 3306 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 { 3366 3310 return false; 3311 } 3367 3312 3368 3313 Int refViewIdx = pDInfo->m_aVIdxCan; 3369 3314 TComPic* picDepth = getSlice()->getIvPic( true, refViewIdx ); 3315 3370 3316 if( picDepth == NULL ) // No depth reference avail 3317 { 3318 // Is this allowed to happen? When not an assertion should be added here! 3371 3319 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; 3397 3336 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; 3407 3339 pcMvFieldNeighbours[(iCount<<1)+iRefListIdX].setMvField( pDInfo->m_acNBDV, i ); 3408 #else3409 pcMvFieldNeighbours[(iCount<<1)+iRefListIdX].setMvField( pDInfo->m_acDoNBDV, i );3410 #endif3411 3340 #if H_3D_NBDV 3412 3341 pcMvFieldNeighbours[(iCount<<1)+iRefListIdX].getMv().setIDVFlag (false); … … 3418 3347 if (m_pcSlice->isInterB() && refViewAvailFlag) 3419 3348 { 3420 RefPicList eRefPicList = RefPicList( iRefListIdY );3349 RefPicList eRefPicListY = RefPicList( refListIdY ); 3421 3350 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() ) 3426 3355 { 3427 3356 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; 3431 3358 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. 3437 3369 if ( iScale != 4096 && m_pcSlice->getVPS()->getIvMvScalingFlag() ) 3438 3370 { … … 3445 3377 } 3446 3378 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 ); 3455 3380 #if H_3D_NBDV 3456 pcMvFieldNeighbours[(iCount<<1)+ iRefListIdY].getMv().setIDVFlag (false);3381 pcMvFieldNeighbours[(iCount<<1)+refListIdY].getMv().setIDVFlag (false); 3457 3382 #endif 3458 3383 } … … 3461 3386 3462 3387 // Set values to be returned 3463 abCandIsInter [iCount] = true;3388 abCandIsInter [iCount] = true; 3464 3389 puhInterDirNeighbours[iCount] = (predFlag[0] | (predFlag[1] << 1)); 3465 vspFlag [iCount] = 1;3390 vspFlag [iCount] = 1; 3466 3391 3467 3392 if ( mrgCandIdx == iCount ) 3393 { 3468 3394 return true; 3395 } 3469 3396 3470 3397 iCount++; … … 3475 3402 #endif 3476 3403 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 3405 inline 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) 3483 3411 if( iLoop == 1 ) 3484 3412 { 3485 3413 Int iFirDispCand = -1; 3486 if (x FirstDmvAvai(iCount, pcMvFieldNeighbours, iPdmDir, iPosDmv, vspFlag, iFirDispCand))3414 if (xGetPosFirstAvailDmvCand(iCount, pcMvFieldNeighbours, ivCandDir, iPosIvDC, vspFlag, iFirDispCand)) 3487 3415 { 3488 3416 TComMv cMv; … … 3494 3422 } 3495 3423 clipMv( cMv ); 3496 abCandIsInter [ iCount ] = true;3424 abCandIsInter [ iCount ] = true; 3497 3425 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 3500 3429 if( mrgCandIdx == iCount ) 3501 3430 { 3502 3431 return true; 3503 3432 } 3433 3504 3434 iCount++; 3505 3435 break; 3506 3436 } 3507 3437 } 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 ] ); 3519 3452 } 3520 3453 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]) 3525 3459 { 3526 bRemove = true;3460 bRemove = true; 3527 3461 abCandIsInter [ iCount ] = false; 3528 puhInterDirNeighbours[ iCount]= 0;3462 puhInterDirNeighbours[ iCount ] = 0; 3529 3463 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 ); 3532 3466 } 3533 3467 } … … 3535 3469 { 3536 3470 #if H_3D_NBDV 3537 if(iLoop) 3471 if(iLoop) // For IvMcShift candidate 3538 3472 { 3539 3473 pcMvFieldNeighbours[iCount<<1 ].getMv().setIDVFlag (false); … … 3553 3487 } 3554 3488 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 ) ) 3489 inline 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 ) ) 3560 3495 { 3561 3496 continue; 3562 3497 } 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; 3566 3501 return true; 3567 3502 } … … 3582 3517 #if H_3D_VSP 3583 3518 , Int* vspFlag 3584 #if MTK_VSP_FIX_ALIGN_WD_E01723585 3519 , InheritedVSPDisInfo* inheritedVSPDisInfo 3586 #endif3587 #if MTK_VSP_FIX_E01723588 , Int* vspDir3589 #endif3590 3520 #endif 3591 3521 , Int& numValidMergeCand, Int mrgCandIdx … … 3594 3524 UInt uiAbsPartAddr = m_uiAbsIdxInLCU + uiAbsPartIdx; 3595 3525 #if H_3D_IV_MERGE 3526 //////////////////////////// 3527 //////// INIT LISTS //////// 3528 //////////////////////////// 3596 3529 TComMv cZeroMv; 3597 3530 Bool abCandIsInter[ MRG_MAX_NUM_CANDS_MEM ]; … … 3611 3544 } 3612 3545 numValidMergeCand = getSlice()->getMaxNumMergeCand(); 3546 #if H_3D 3547 ////////////////////////////////// 3548 //////// DERIVE LOCATIONS //////// 3549 ////////////////////////////////// 3550 #endif 3613 3551 // compute the location of the current PU 3614 3552 Int xP, yP, nPSW, nPSH; … … 3622 3560 deriveLeftBottomIdxGeneral ( uiAbsPartIdx, uiPUIdx, uiPartIdxLB ); 3623 3561 #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 3653 3567 if( m_pcSlice->getIsDepth()) 3654 3568 { … … 3659 3573 if ( pcTextureCU && !pcTextureCU->isIntra( uiPartIdxCenter ) ) 3660 3574 { 3661 #if MTK_TEXTURE_MRGCAND_BUGFIX_E01823662 3575 pcTextureCU->getMvField( pcTextureCU, uiPartIdxCenter, REF_PIC_LIST_0, pcMvFieldNeighbours[iCount<<1] ); 3663 3576 Int iValidDepRef = getPic()->isTextRefValid( REF_PIC_LIST_0, pcMvFieldNeighbours[iCount<<1].getRefIdx() ); … … 3699 3612 iCount ++; 3700 3613 } 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() ); 3772 3646 3773 3647 if ( ivMvPredFlag ) 3774 3648 { 3775 getInterViewMergeCands(uiPUIdx, aiPdmRefIdx, acPdmMv, &cDisInfo, iPdmDir );3649 getInterViewMergeCands(uiPUIdx, ivCandRefIdx, ivCandMv, &cDisInfo, ivCandDir ); 3776 3650 } 3777 3778 Int iPdmInterDir; 3779 3780 if( iPdmDir[0] ) 3651 3652 /////////////////////////////////////////////// 3653 //////// INTER VIEW MOTION COMP(IvMC) ///////// 3654 /////////////////////////////////////////////// 3655 3656 if( ivCandDir[0] ) 3781 3657 { 3782 3658 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 ] ); 3793 3668 } 3794 3669 … … 3799 3674 iCount ++; 3800 3675 } 3676 3801 3677 // early termination 3802 3678 if (iCount == getSlice()->getMaxNumMergeCand()) … … 3806 3682 #endif 3807 3683 3684 #if H_3D 3685 //////////////////////////// 3686 //////// LEFT (A1) ///////// 3687 //////////////////////////// 3688 #endif 3808 3689 //left 3809 3690 UInt uiLeftPartIdx = 0; … … 3852 3733 #if H_3D_VSP 3853 3734 if (pcCULeft->getVSPFlag(uiLeftPartIdx) == 1) 3854 #if MTK_VSP_FIX_E0172 || MTK_VSP_FIX_ALIGN_WD_E0172 3855 { 3856 #endif 3735 { 3857 3736 vspFlag[iCount] = 1; 3858 #if MTK_VSP_FIX_ALIGN_WD_E01723859 3737 xInheritVSPDisInfo(pcCULeft,uiLeftPartIdx,iCount,inheritedVSPDisInfo); 3860 3738 } 3861 3739 #endif 3862 #if MTK_VSP_FIX_E01723863 vspDir[iCount] = pcCULeft->getVSPDir( uiLeftPartIdx );3864 }3865 #endif3866 #endif3867 3740 if ( mrgCandIdx == iCount ) 3868 3741 { … … 3871 3744 iCount ++; 3872 3745 } 3873 #else 3746 #else // H_3D_IV_MERGE 3874 3747 if ( mrgCandIdx == iCount ) 3875 3748 { … … 3877 3750 } 3878 3751 iCount ++; 3879 #endif 3752 #endif // H_3D_IV_MERGE 3880 3753 } 3881 3754 … … 3885 3758 return; 3886 3759 } 3760 #if H_3D 3761 //////////////////////////// 3762 //////// ABOVE (B1) //////// 3763 //////////////////////////// 3764 #endif 3887 3765 // above 3888 3766 UInt uiAbovePartIdx = 0; … … 3917 3795 puhInterDirNeighbours[iCount] = 0; 3918 3796 3919 pcMvFieldNeighbours[iCount<<1] .setMvField( cZeroMv, NOT_VALID );3797 pcMvFieldNeighbours[iCount<<1] .setMvField( cZeroMv, NOT_VALID ); 3920 3798 pcMvFieldNeighbours[(iCount<<1)+1].setMvField( cZeroMv, NOT_VALID ); 3921 3799 break; 3922 3800 } 3923 3801 } 3802 3924 3803 if(!bRemoveSpa) 3925 3804 { … … 3931 3810 #if H_3D_VSP 3932 3811 if (pcCUAbove->getVSPFlag(uiAbovePartIdx) == 1) 3933 #if MTK_VSP_FIX_E0172 || MTK_VSP_FIX_ALIGN_WD_E0172 3934 { 3935 #endif 3812 { 3813 3936 3814 vspFlag[iCount] = 1; 3937 #if MTK_VSP_FIX_ALIGN_WD_E01723938 3815 xInheritVSPDisInfo(pcCUAbove,uiAbovePartIdx,iCount,inheritedVSPDisInfo); 3939 3816 } 3940 3817 #endif 3941 #if MTK_VSP_FIX_E01723942 vspDir[iCount] = pcCUAbove->getVSPDir( uiAbovePartIdx );3943 }3944 #endif3945 #endif3946 3818 if ( mrgCandIdx == iCount ) 3947 3819 { … … 3950 3822 iCount ++; 3951 3823 } 3952 #else 3824 #else // H_3D_IV_MERGE 3953 3825 if ( mrgCandIdx == iCount ) 3954 3826 { … … 3956 3828 } 3957 3829 iCount ++; 3958 #endif 3830 #endif // H_3D_IV_MERGE 3959 3831 } 3960 3832 // early termination … … 3963 3835 return; 3964 3836 } 3837 3838 #if H_3D 3839 ////////////////////////////////// 3840 //////// ABOVE RIGHT (B0) //////// 3841 ////////////////////////////////// 3842 #endif 3965 3843 3966 3844 // above right … … 3988 3866 #if H_3D_VSP 3989 3867 if (pcCUAboveRight->getVSPFlag(uiAboveRightPartIdx) == 1) 3990 #if MTK_VSP_FIX_E0172 || MTK_VSP_FIX_ALIGN_WD_E0172 3991 { 3992 #endif 3868 { 3993 3869 vspFlag[iCount] = 1; 3994 #if MTK_VSP_FIX_ALIGN_WD_E01723995 3870 xInheritVSPDisInfo(pcCUAboveRight,uiAboveRightPartIdx,iCount,inheritedVSPDisInfo); 3996 3871 } 3997 #endif3998 #if MTK_VSP_FIX_E01723999 vspDir[iCount] = pcCUAboveRight->getVSPDir( uiAboveRightPartIdx);4000 }4001 #endif4002 3872 #endif 4003 3873 if ( mrgCandIdx == iCount ) … … 4014 3884 4015 3885 #if H_3D_IV_MERGE 4016 if( iPdmDir[1] ) 3886 ///////////////////////////////////////////// 3887 //////// INTER VIEW DISP COMP (IvDC) //////// 3888 ///////////////////////////////////////////// 3889 3890 if( ivCandDir[1] ) 4017 3891 { 4018 3892 assert(iCount < getSlice()->getMaxNumMergeCand()); 4019 3893 abCandIsInter [ iCount ] = true; 4020 puhInterDirNeighbours[ iCount ] = i PdmDir[1];4021 if( ( i PdmDir[1] & 1 ) == 1 )4022 { 4023 pcMvFieldNeighbours[ iCount<<1 ].setMvField( acPdmMv[ 2 ], aiPdmRefIdx[ 2 ] );4024 } 4025 if( ( i PdmDir[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 ] ); 4028 3902 } 4029 3903 … … 4032 3906 { 4033 3907 Int iCnloop = iPosLeftAbove[i]; 4034 if(iCnloop == -1) 3908 if ( iCnloop == -1 ) 3909 { 4035 3910 continue; 3911 } 4036 3912 if(puhInterDirNeighbours[iCount] == puhInterDirNeighbours[iCnloop] && pcMvFieldNeighbours[iCnloop<<1]==pcMvFieldNeighbours[(iCount<<1)] && pcMvFieldNeighbours[(iCnloop<<1)+1]==pcMvFieldNeighbours[(iCount<<1)+1]) 4037 3913 { … … 4051 3927 pcMvFieldNeighbours[(iCount<<1)+1].getMv().setIDVFlag (false); 4052 3928 #endif 4053 #if QC_INRIA_MTK_MRG_E0126 4054 iPosDmv = iCount; 4055 #endif 3929 posIvDC = iCount; 4056 3930 if ( mrgCandIdx == iCount ) 4057 3931 return; … … 4065 3939 } 4066 3940 } 4067 #endif 3941 #endif // H_3D_IV_MERGE 4068 3942 4069 3943 #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 { 4075 3950 return; 3951 } 3952 4076 3953 // early termination 4077 3954 if (iCount == getSlice()->getMaxNumMergeCand()) 3955 { 4078 3956 return; 3957 } 3958 #endif 3959 #if H_3D 3960 /////////////////////////////////// 3961 //////// LEFT BOTTOM (A0) //////// 3962 /////////////////////////////////// 4079 3963 #endif 4080 3964 … … 4103 3987 #if H_3D_VSP 4104 3988 if (pcCULeftBottom->getVSPFlag(uiLeftBottomPartIdx) == 1) 4105 #if MTK_VSP_FIX_E0172 || MTK_VSP_FIX_ALIGN_WD_E0172 4106 { 4107 #endif 3989 { 4108 3990 vspFlag[iCount] = 1; 4109 #if MTK_VSP_FIX_ALIGN_WD_E01724110 3991 xInheritVSPDisInfo(pcCULeftBottom,uiLeftBottomPartIdx,iCount,inheritedVSPDisInfo); 4111 3992 } 4112 #endif4113 #if MTK_VSP_FIX_E01724114 vspDir[iCount] = pcCULeftBottom->getVSPDir( uiLeftBottomPartIdx);4115 }4116 #endif4117 3993 #endif 4118 3994 if ( mrgCandIdx == iCount ) … … 4127 4003 return; 4128 4004 } 4005 #if H_3D 4006 /////////////////////////////////// 4007 //////// LEFT ABOVE (B2) //////// 4008 /////////////////////////////////// 4009 #endif 4010 4129 4011 // above left 4130 4012 if( iCount < 4 ) … … 4154 4036 #if H_3D_VSP 4155 4037 if (pcCUAboveLeft->getVSPFlag(uiAboveLeftPartIdx) == 1) 4156 #if MTK_VSP_FIX_E0172 || MTK_VSP_FIX_ALIGN_WD_E0172 4157 { 4158 #endif 4038 { 4159 4039 vspFlag[iCount] = 1; 4160 #if MTK_VSP_FIX_ALIGN_WD_E01724161 4040 xInheritVSPDisInfo(pcCUAboveLeft,uiAboveLeftPartIdx,iCount,inheritedVSPDisInfo); 4162 4041 } 4163 #endif4164 #if MTK_VSP_FIX_E01724165 vspDir[iCount] = pcCUAboveLeft->getVSPDir( uiAboveLeftPartIdx);4166 }4167 #endif4168 4042 #endif 4169 4043 if ( mrgCandIdx == iCount ) … … 4179 4053 return; 4180 4054 } 4181 #if QC_INRIA_MTK_MRG_E0126 4055 #if H_3D_IV_MERGE 4056 //////////////////////////////////////////////////// 4057 //////// SHIFTED IV (IvMCShift + IvDCShift) //////// 4058 //////////////////////////////////////////////////// 4059 4182 4060 if( ivMvPredFlag ) 4183 4061 { 4184 if(xAddIvMRGCand( mrgCandIdx, iCount, abCandIsInter, pcMvFieldNeighbours, puhInterDirNeighbours, i PdmDir, acPdmMv, aiPdmRefIdx, iPosDmv, vspFlag))4062 if(xAddIvMRGCand( mrgCandIdx, iCount, abCandIsInter, pcMvFieldNeighbours, puhInterDirNeighbours, ivCandDir, ivCandMv, ivCandRefIdx, posIvDC, vspFlag)) 4185 4063 { 4186 4064 return; … … 4192 4070 } 4193 4071 } 4072 #endif 4073 #if H_3D 4074 ///////////////////////////////// 4075 //////// Collocate (COL) //////// 4076 ///////////////////////////////// 4194 4077 #endif 4195 4078 if ( getSlice()->getEnableTMVPFlag()) … … 4311 4194 Bool bValid = true; 4312 4195 if ( vspFlag[i] == 1 || vspFlag[j] == 1 ) 4196 { 4313 4197 bValid = false; 4198 } 4314 4199 if( !m_pcSlice->getVPS()->getViewSynthesisPredFlag( m_pcSlice->getLayerIdInVps() ) ) 4200 { 4315 4201 assert(bValid == true); 4202 } 4316 4203 #endif 4317 4204 #if H_3D_VSP … … 4374 4261 numValidMergeCand = uiArrayAddr; 4375 4262 } 4376 #if MTK_VSP_FIX_ALIGN_WD_E01724263 #if H_3D_VSP 4377 4264 inline Void TComDataCU::xInheritVSPDisInfo(TComDataCU* pcCURef, UInt uiAbsPartIdx, Int iCount, InheritedVSPDisInfo* inheritedVSPDisInfo) 4378 4265 { … … 4943 4830 4944 4831 // use coldir. 4832 #if H_MV5 4833 TComPic *pColPic = getSlice()->getRefPic( RefPicList(getSlice()->isInterB() ? 1-getSlice()->getColFromL0Flag() : 0), getSlice()->getColRefIdx()); 4834 #else 4945 4835 #if H_MV 4946 4836 TComPic *pColPic; … … 4955 4845 #else 4956 4846 TComPic *pColPic = getSlice()->getRefPic( RefPicList(getSlice()->isInterB() ? 1-getSlice()->getColFromL0Flag() : 0), getSlice()->getColRefIdx()); 4847 #endif 4957 4848 #endif 4958 4849 TComDataCU *pColCU = pColPic->getCU( uiCUAddr ); … … 5770 5661 pDInfo->m_acNBDV = cDispVec; 5771 5662 pDInfo->m_aVIdxCan = cIDVInfo.m_aVIdxCan[iList][ curPos ]; 5772 #if !MTK_DVMCP_FIX_E01725773 assert(pDInfo->m_aVIdxCan == 0); //Notes from QC: only works for CTC5774 #endif5775 5663 #if H_3D_NBDV_REF 5776 5664 TComPic* picDepth = getSlice()->getIvPic( true, pDInfo->m_aVIdxCan ); … … 5942 5830 paIDVInfo->m_acMvCand[iList][ uiMvpDvPos ] = TComMv( cMvPred.getIDVHor(), cMvPred.getIDVVer() ); 5943 5831 //Notes from QC: DvMCP is implemented in a way that doesnE½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_E01725945 5832 paIDVInfo->m_aVIdxCan[iList][ uiMvpDvPos ] = cMvPred.getIDVVId(); 5946 #else5947 paIDVInfo->m_aVIdxCan[iList][ uiMvpDvPos ] = 0;5948 #endif5949 5833 paIDVInfo->m_bAvailab[iList][ uiMvpDvPos ] = true; 5950 5834 paIDVInfo->m_bFound = true; … … 6011 5895 } 6012 5896 } 6013 #if MTK_VSP_FIX_ALIGN_WD_E01725897 #if H_3D_VSP 6014 5898 Void TComDataCU::setDvInfoSubParts( DisInfo cDvInfo, UInt uiAbsPartIdx, UInt uiPUIdx, UInt uiDepth ) 6015 5899 { … … 6150 6034 TComDataCU::getInterViewMergeCands(UInt uiPartIdx, Int* paiPdmRefIdx, TComMv* pacPdmMv, DisInfo* pDInfo, Int* availableMcDc ) 6151 6035 { 6152 TComSlice* pcSlice = getSlice (); 6153 Int iViewIndex = pDInfo->m_aVIdxCan; 6036 TComSlice* pcSlice = getSlice (); 6037 Int iViewIndex = pDInfo->m_aVIdxCan; 6038 6154 6039 //--- get base CU/PU and check prediction mode --- 6155 6040 TComPic* pcBasePic = pcSlice->getIvPic( false, iViewIndex ); … … 6174 6059 TComMv cDv = depthRefineFlag ? pDInfo->m_acDoNBDV : pDInfo->m_acNBDV; 6175 6060 6176 #if !QC_INRIA_MTK_MRG_E01266177 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 #endif6186 #if QC_INRIA_MTK_MRG_E01266187 6061 Bool abPdmAvailable[8] = {false, false, false, false, false, false, false, false}; 6188 #else6189 Bool abPdmAvailable[4] = {false, false, false, false};6190 #endif6191 6062 #if H_3D_NBDV 6192 #if QC_INRIA_MTK_MRG_E01266193 6063 for( Int i = 0; i < 8; i++) 6194 #else6195 for( Int i = 0; i < 4; i++)6196 #endif6197 6064 { 6198 6065 pacPdmMv[i].setIDVFlag (false); 6199 6066 } 6200 6067 #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 6204 6078 Int iBaseCUAddr; 6205 6079 Int iBaseAbsPartIdx; 6206 6080 6207 Int offsetW = (iLoopCan == 0) ? 0 : ( ((iWidth /2)*4)+ 4 );6081 Int offsetW = (iLoopCan == 0) ? 0 : ( ((iWidth /2)*4) + 4 ); 6208 6082 Int offsetH = (iLoopCan == 0) ? 0 : ( ((iHeight/2)*4) + 4 ); 6209 6083 6210 6084 Int iBasePosX = Clip3( 0, pcBaseRec->getWidth () - 1, iCurrPosX + ( (cDv.getHor() + offsetW + 2 ) >> 2 ) ); 6211 6085 Int iBasePosY = Clip3( 0, pcBaseRec->getHeight() - 1, iCurrPosY + ( (cDv.getVer() + offsetH + 2 ) >> 2 ) ); … … 6213 6087 6214 6088 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) 6230 6099 { 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) 6233 6105 { 6234 for (Int iPdmRefIdx = 0; iPdmRefIdx < pcSlice->getNumRefIdx( eCurrRefPicList ); iPdmRefIdx++) 6106 Int iBaseRefPOC = pcBaseCU->getSlice()->getRefPOC(eBaseRefPicList, iBaseRefIdx); 6107 if (iBaseRefPOC != pcSlice->getPOC()) 6235 6108 { 6236 if (iBaseRefPOC == pcSlice->getRefPOC(eCurrRefPicList, iPdmRefIdx))6109 for (Int iPdmRefIdx = 0; iPdmRefIdx < pcSlice->getNumRefIdx( eCurrRefPicList ); iPdmRefIdx++) 6237 6110 { 6238 #if QC_INRIA_MTK_MRG_E0126 6111 if (iBaseRefPOC == pcSlice->getRefPOC(eCurrRefPicList, iPdmRefIdx)) 6112 { 6239 6113 abPdmAvailable[ (uiCurrRefListId + (iLoopCan<<2)) ] = true; 6240 6114 TComMv cMv(cBaseMvField.getHor(), cBaseMvField.getVer()); … … 6243 6117 cMv.setIDVHor (cDv.getHor()); 6244 6118 cMv.setIDVVer (cDv.getVer()); 6245 #if MTK_DVMCP_FIX_E01726246 6119 cMv.setIDVVId (iViewIndex); 6247 #endif6248 6120 #endif 6249 6121 clipMv( cMv ); 6250 6122 paiPdmRefIdx [ (uiCurrRefListId + (iLoopCan<<2)) ] = iPdmRefIdx; 6251 6123 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 } 6269 6127 } 6270 6128 } … … 6274 6132 } 6275 6133 } 6276 #if QC_INRIA_MTK_MRG_E01266277 }6278 #endif6279 #if QC_INRIA_MTK_MRG_E01266280 6134 for(Int iLoopCan = 0; iLoopCan < 2; iLoopCan ++) 6281 6135 { 6282 6136 availableMcDc[(iLoopCan << 1)] = ( abPdmAvailable[(iLoopCan<<2)] ? 1 : 0 ) + ( abPdmAvailable[1 + (iLoopCan<<2)] ? 2 : 0); 6283 6137 } 6284 #else 6285 availableMcDc[0] = ( abPdmAvailable[0] ? 1 : 0 ) + ( abPdmAvailable[1] ? 2 : 0 ); 6286 #endif 6138 6139 6140 //////////////////////////////// 6141 /////// IvDC + IvDCShift /////// 6142 //////////////////////////////// 6143 6287 6144 for( Int iRefListId = 0; iRefListId < 2 ; iRefListId++ ) 6288 6145 { … … 6291 6148 for( Int iPdmRefIdx = 0; iPdmRefIdx < iNumRefPics; iPdmRefIdx++ ) 6292 6149 { 6293 #if MTK_DIVMC_FIX_E01726294 6150 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 { 6300 6152 for(Int iLoopCan = 0; iLoopCan < 2; iLoopCan ++) 6301 6153 { … … 6312 6164 } 6313 6165 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 } 6330 6169 for(Int iLoopCan = 0; iLoopCan < 2; iLoopCan ++) 6331 6170 { 6332 6171 availableMcDc[1 + (iLoopCan << 1)] = ( abPdmAvailable[2 + (iLoopCan<<2)] ? 1 : 0 ) + ( abPdmAvailable[3 + (iLoopCan<<2)] ? 2 : 0 ); 6333 6172 } 6334 #else6335 availableMcDc[1] = ( abPdmAvailable[2] ? 1 : 0 ) + ( abPdmAvailable[3] ? 2 : 0 );6336 #endif6337 6173 return false; 6338 6174 } … … 6406 6242 for( UInt ui = 0; ui < uiCurrPartNumb; ui++ ) { m_dmmWedgeTabIdx[dmmType][uiAbsPartIdx+ui] = tabIdx; } 6407 6243 } 6408 #if !SEC_DMM2_E0146 6244 #if !SEC_DMM2_E0146_HHIFIX 6409 6245 Void TComDataCU::setDmm2DeltaEndSubParts( Int iDelta, UInt uiAbsPartIdx, UInt uiDepth ) 6410 6246 { -
trunk/source/Lib/TLibCommon/TComDataCU.h
r608 r622 197 197 Char* m_piVSPFlag; ///< array of VSP flags to indicate whehter a block uses VSP or not 198 198 ///< 0: non-VSP; 1: VSP 199 #if MTK_VSP_FIX_E0172200 Char* m_piVSPDir; ///< 0: LIST0; 1: LIST1201 #endif202 199 #endif 203 200 #if H_3D_ARP … … 211 208 #if H_3D_DIM_DMM 212 209 UInt* m_dmmWedgeTabIdx[DMM_NUM_TYPE]; 213 #if !SEC_DMM2_E0146 210 #if !SEC_DMM2_E0146_HHIFIX 214 211 Int* m_dmm2DeltaEnd; 215 212 #endif … … 256 253 Bool xAddMVPCandOrder ( AMVPInfo* pInfo, RefPicList eRefPicList, Int iRefIdx, UInt uiPartUnitIdx, MVP_DIR eDir ); 257 254 #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, 263 256 Bool* abCandIsInter, TComMvField* pcMvFieldNeighbours, UChar* puhInterDirNeighbours, Int* vspFlag ); 264 257 #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 ); 270 262 #endif 271 263 … … 442 434 template <typename T> 443 435 Void setSubPart ( T bParameter, T* pbBaseLCU, UInt uiCUAddr, UInt uiCUDepth, UInt uiPUIdx ); 444 #if MTK_VSP_FIX_ALIGN_WD_E0172436 #if H_3D_VSP 445 437 template<typename T> 446 438 Void setSubPartT ( T uiParameter, T* puhBaseLCU, UInt uiCUAddr, UInt uiCUDepth, UInt uiPUIdx ); … … 471 463 #if H_3D_NBDV 472 464 Void setDvInfoSubParts ( DisInfo cDvInfo, UInt uiAbsPartIdx, UInt uiDepth ); 473 #if MTK_VSP_FIX_ALIGN_WD_E0172474 465 Void setDvInfoSubParts ( DisInfo cDvInfo, UInt uiAbsPartIdx, UInt uiPartIdx, UInt uiDepth); 475 #endif476 466 DisInfo* getDvInfo () { return m_pDvInfo; } 477 467 DisInfo getDvInfo (UInt uiIdx) { return m_pDvInfo[uiIdx]; } … … 555 545 Void setDmmWedgeTabIdxSubParts ( UInt tabIdx, UInt dmmType, UInt uiAbsPartIdx, UInt uiDepth ); 556 546 557 #if !SEC_DMM2_E0146 547 #if !SEC_DMM2_E0146_HHIFIX 558 548 Int* getDmm2DeltaEnd () { return m_dmm2DeltaEnd; } 559 549 Int getDmm2DeltaEnd ( UInt uiIdx ) { return m_dmm2DeltaEnd[uiIdx]; } … … 682 672 #if H_3D_VSP 683 673 , Int* vspFlag 684 #if MTK_VSP_FIX_ALIGN_WD_E0172685 674 , InheritedVSPDisInfo* inheritedVSPDisInfo 686 675 #endif 687 #if MTK_VSP_FIX_E0172688 , Int* vspDir689 #endif690 #endif691 676 , 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 695 678 #if H_3D_VSP 679 inline Void xInheritVSPDisInfo(TComDataCU* pcCURef, UInt uiAbsPartIdx, Int iCount, InheritedVSPDisInfo* inheritedVSPDisInfo); 680 696 681 Char* getVSPFlag () { return m_piVSPFlag; } 697 682 Char getVSPFlag ( UInt uiIdx ) { return m_piVSPFlag[uiIdx]; } 698 683 Void setVSPFlag ( UInt uiIdx, Int n ) { m_piVSPFlag[uiIdx] = n; } 699 684 Void setVSPFlagSubParts( Char iVSPFlag, UInt uiAbsPartIdx, UInt uiPartIdx, UInt uiDepth ); 700 #if MTK_VSP_FIX_E0172701 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 #endif706 685 #endif 707 686 Void deriveLeftRightTopIdxGeneral ( UInt uiAbsPartIdx, UInt uiPartIdx, UInt& ruiPartIdxLT, UInt& ruiPartIdxRT ); -
trunk/source/Lib/TLibCommon/TComMotionInfo.h
r608 r622 77 77 } IDVInfo; 78 78 #endif 79 #if MTK_VSP_FIX_ALIGN_WD_E017279 #if H_3D_VSP 80 80 typedef struct _InheritedVSPDisCand 81 81 { -
trunk/source/Lib/TLibCommon/TComMv.h
r608 r622 58 58 Short m_iIDVHor; 59 59 Short m_iIDVVer; 60 #if MTK_DVMCP_FIX_E017261 60 Short m_iIDVVId; //view index of the IDV 62 #endif63 61 #endif 64 62 public: … … 75 73 , m_iIDVHor(0) 76 74 , m_iIDVVer(0) 77 #if MTK_DVMCP_FIX_E017278 75 , m_iIDVVId(0) 79 #endif80 76 #endif 81 77 { … … 89 85 , m_iIDVHor(0) 90 86 , m_iIDVVer(0) 91 #if MTK_DVMCP_FIX_E0172 92 , m_iIDVVId(0) 93 #endif 87 , m_iIDVVId(0) 94 88 #endif 95 89 { … … 106 100 #if H_3D_NBDV 107 101 m_bIDV = false; m_iIDVHor = m_iIDVVer = 0; 108 #if MTK_DVMCP_FIX_E0172109 102 m_iIDVVId = 0; 110 #endif111 103 #endif 112 104 } … … 115 107 Void setIDVVer (Short i) {m_iIDVVer = i;} 116 108 Void setIDVFlag (Bool b ) {m_bIDV = b;} 117 #if MTK_DVMCP_FIX_E0172118 109 Void setIDVVId (Short i) {m_iIDVVId = i;} 119 #endif120 110 #endif 121 111 // ------------------------------------------------------------------------------------------------------------------ … … 131 121 Short getIDVVer () const { return m_iIDVVer; } 132 122 Bool getIDVFlag() const { return m_bIDV; } 133 #if MTK_DVMCP_FIX_E0172134 123 Short getIDVVId () const { return m_iIDVVId; } 135 #endif 124 136 125 #endif 137 126 // ------------------------------------------------------------------------------------------------------------------ -
trunk/source/Lib/TLibCommon/TComPrediction.cpp
r608 r622 456 456 dmmSegmentation = &(g_dmmWedgeLists[ g_aucConvertToBit[iWidth] ][ pcCU->getDmmWedgeTabIdx( dimType, uiAbsPartIdx ) ]); 457 457 } break; 458 #if !SEC_DMM2_E0146 458 #if !SEC_DMM2_E0146_HHIFIX 459 459 case( DMM2_IDX ): 460 460 { … … 588 588 pcCU->getPartIndexAndSize( iPartIdx, uiPartAddr, iWidth, iHeight ); 589 589 #if H_3D_VSP 590 if ( 0 == pcCU->getVSPFlag(uiPartAddr))590 if ( pcCU->getVSPFlag(uiPartAddr) == 0) 591 591 { 592 592 #endif … … 622 622 { 623 623 if ( xCheckIdenticalMotion( pcCU, uiPartAddr ) ) 624 { 624 625 xPredInterUniVSP( pcCU, uiPartAddr, iWidth, iHeight, REF_PIC_LIST_0, pcYuvPred ); 626 } 625 627 else 628 { 626 629 xPredInterBiVSP ( pcCU, uiPartAddr, iWidth, iHeight, pcYuvPred ); 630 } 627 631 } 628 632 #endif … … 635 639 636 640 #if H_3D_VSP 637 if ( 0 == pcCU->getVSPFlag(uiPartAddr))641 if ( pcCU->getVSPFlag(uiPartAddr) == 0 ) 638 642 { 639 643 #endif … … 669 673 { 670 674 if ( xCheckIdenticalMotion( pcCU, uiPartAddr ) ) 675 { 671 676 xPredInterUniVSP( pcCU, uiPartAddr, iWidth, iHeight, REF_PIC_LIST_0, pcYuvPred ); 677 } 672 678 else 679 { 673 680 xPredInterBiVSP ( pcCU, uiPartAddr, iWidth, iHeight, pcYuvPred ); 681 } 674 682 } 675 683 #endif … … 722 730 { 723 731 // 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; 732 733 TComPic* pRefPicBaseDepth = pcCU->getSlice()->getIvPic (true, depthRefViewIdx ); 733 734 assert(pRefPicBaseDepth != NULL); … … 748 749 749 750 // Do compensation 750 #if MTK_VSP_FIX_ALIGN_WD_E0172751 751 TComMv cDv = pcCU->getDvInfo(uiPartAddr).m_acNBDV; 752 #else753 #if MTK_VSP_FIX_E0172754 TComMv cDv = pcCU->getCUMvField( privateRefPicList )->getMv( uiPartAddr );755 #else756 TComMv cDv = pcCU->getCUMvField( eRefPicList )->getMv( uiPartAddr ); // cDv is the disparity vector derived from the neighbors757 #endif758 #endif // end of MTK_VSP_FIX_ALIGN_WD_E0172759 752 pcCU->clipMv(cDv); 760 753 … … 935 928 936 929 if ( iRefIdx[iRefList] < 0 ) 930 { 937 931 continue; 932 } 938 933 assert( iRefIdx[iRefList] < pcCU->getSlice()->getNumRefIdx(eRefPicList) ); 939 934 … … 2773 2768 2774 2769 #if H_3D_DIM_DMM 2770 #if !SEC_DMM2_E0146_HHIFIX 2775 2771 UInt TComPrediction::xPredWedgeFromIntra( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiWidth, UInt uiHeight, Int iDeltaEnd ) 2776 2772 { … … 2784 2780 { 2785 2781 UInt dimType = getDimType( pcTempCU->getLumaIntraDir( uiTempPartIdx ) ); 2786 #if SEC_DMM2_E01462787 if( DMM1_IDX == dimType || DMM3_IDX == dimType )2788 #else2789 2782 if( DMM1_IDX == dimType || DMM2_IDX == dimType || DMM3_IDX == dimType ) 2790 #endif2791 2783 { 2792 2784 // get offset between current and reference block … … 2813 2805 { 2814 2806 UInt dimType = getDimType( pcTempCU->getLumaIntraDir( uiTempPartIdx ) ); 2815 #if SEC_DMM2_E01462816 if( DMM1_IDX == dimType || DMM3_IDX == dimType )2817 #else2818 2807 if( DMM1_IDX == dimType || DMM2_IDX == dimType || DMM3_IDX == dimType ) 2819 #endif2820 2808 { 2821 2809 // get offset between current and reference block … … 2849 2837 return 0; 2850 2838 } 2839 #endif 2851 2840 2852 2841 UInt TComPrediction::xPredWedgeFromTex( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiWidth, UInt uiHeight, UInt intraTabIdx ) … … 2858 2847 Int uiColTexIntraDir = pcColTexCU->isIntra( uiTexPartIdx ) ? pcColTexCU->getLumaIntraDir( uiTexPartIdx ) : 255; 2859 2848 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 2860 2853 if( uiColTexIntraDir > DC_IDX && uiColTexIntraDir < 35 ) { return g_aauiWdgLstM3[g_aucConvertToBit[uiWidth]][uiColTexIntraDir-2].at(intraTabIdx); } 2861 2854 else { return g_dmmWedgeNodeLists[(g_aucConvertToBit[uiWidth])].at(intraTabIdx).getPatternIdx(); } 2855 #endif 2862 2856 } 2863 2857 … … 2914 2908 } 2915 2909 2910 #if !SEC_DMM2_E0146_HHIFIX 2916 2911 Void TComPrediction::xGetBlockOffset( TComDataCU* pcCU, UInt uiAbsPartIdx, TComDataCU* pcRefCU, UInt uiRefAbsPartIdx, UInt& ruiOffsetX, UInt& ruiOffsetY ) 2917 2912 { … … 3302 3297 } 3303 3298 #endif 3299 #endif 3304 3300 #if H_3D_DIM_RBC 3305 3301 Void TComPrediction::xDeltaDCQuantScaleUp( TComDataCU* pcCU, Pel& rDeltaDC ) -
trunk/source/Lib/TLibCommon/TComPrediction.h
r608 r622 154 154 Void xAssignBiSegDCs ( Pel* ptrDst, UInt dstStride, Bool* biSegPattern, Int patternStride, Pel valDC1, Pel valDC2 ); 155 155 #if H_3D_DIM_DMM 156 #if !SEC_DMM2_E0146_HHIFIX 156 157 UInt xPredWedgeFromIntra ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiWidth, UInt uiHeight, Int iDeltaEnd = 0 ); 158 #endif 157 159 UInt xPredWedgeFromTex ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiWidth, UInt uiHeight, UInt intraTabIdx ); 158 160 Void xPredContourFromTex ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiWidth, UInt uiHeight, TComWedgelet* pcContourWedge ); … … 160 162 Void xCopyTextureLumaBlock ( TComDataCU* pcCU, UInt uiAbsPartIdx, Pel* piDestBlockY, UInt uiWidth, UInt uiHeight ); 161 163 164 #if !SEC_DMM2_E0146_HHIFIX 162 165 Void xGetBlockOffset ( TComDataCU* pcCU, UInt uiAbsPartIdx, TComDataCU* pcRefCU, UInt uiRefAbsPartIdx, UInt& ruiOffsetX, UInt& ruiOffsetY ); 163 166 Bool xGetWedgeIntraDirPredData( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiBlockSize, Int& riSlopeX, Int& riSlopeY, UInt& ruiStartPosX, UInt& ruiStartPosY ); 164 167 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 ); 165 168 UInt xGetWedgePatternIdx ( UInt uiBlockSize, UChar uhXs, UChar uhYs, UChar uhXe, UChar uhYe ); 169 #endif 166 170 #endif 167 171 #if H_3D_DIM_RBC -
trunk/source/Lib/TLibCommon/TComRdCost.cpp
r608 r622 484 484 } 485 485 486 #if SCU_HS_FAST_DEPTH_INTRA_E0238 486 #if SCU_HS_FAST_DEPTH_INTRA_E0238_HHIFIX 487 487 488 488 UInt TComRdCost::calcVAR (Pel* pi0, Int stride, Int width, Int height, Int cuDepth) -
trunk/source/Lib/TLibCommon/TComRdCost.h
r608 r622 235 235 UInt calcHAD(Int bitDepth, Pel* pi0, Int iStride0, Pel* pi1, Int iStride1, Int iWidth, Int iHeight ); 236 236 237 #if SCU_HS_FAST_DEPTH_INTRA_E0238 237 #if SCU_HS_FAST_DEPTH_INTRA_E0238_HHIFIX 238 238 UInt calcVAR(Pel* pi0, Int stride, Int width, Int height, Int cuDepth); 239 239 #endif -
trunk/source/Lib/TLibCommon/TComRom.cpp
r608 r622 347 347 { //2x2 4x4 8x8 16x16 32x32 64x64 348 348 0, 7, 10, 11, 11, 13 }; 349 #if LGE_PKU_DMM3_OVERLAP_E0159 349 #if LGE_PKU_DMM3_OVERLAP_E0159_HHIFIX 350 350 const UChar g_dmm3IntraTabIdxBits[6] = 351 351 { //2x2 4x4 8x8 16x16 32x32 64x64 … … 380 380 Bool g_traceTU = true; 381 381 Bool g_disableHLSTrace = false; 382 UInt64 g_stopAtCounter = 10803; 382 UInt64 g_stopAtCounter = 48; 383 Bool g_traceCopyBack = false; 384 Bool g_decTraceDispDer = false; 385 Bool g_decTraceMvFromMerge = false; 383 386 #endif 384 387 #endif … … 611 614 std::vector< std::vector< std::vector<UInt> > > g_aauiWdgLstM3; 612 615 616 #if LGE_PKU_DMM3_OVERLAP_E0159_HHIFIX 617 Void initWedgeLists( Bool initNodeList ) 618 #else 613 619 Void initWedgeLists( Bool initRefinements ) 620 #endif 614 621 { 615 622 if( !g_dmmWedgeLists.empty() ) return; … … 624 631 g_dmmWedgeRefLists.push_back( acWedgeRefList ); 625 632 633 #if LGE_PKU_DMM3_OVERLAP_E0159_HHIFIX 634 if( initNodeList ) 635 { 636 #endif 626 637 // create WedgeNodeList 627 638 std::vector<TComWedgeNode> acWedgeNodeList; … … 633 644 cWedgeNode.setPatternIdx( uiPos ); 634 645 646 #if !LGE_PKU_DMM3_OVERLAP_E0159_HHIFIX 635 647 if( initRefinements ) 636 648 { 649 #endif 637 650 UInt uiRefPos = 0; 638 651 for( Int iOffS = -1; iOffS <= 1; iOffS++ ) … … 681 694 } 682 695 } 696 #if !LGE_PKU_DMM3_OVERLAP_E0159_HHIFIX 683 697 } 698 #endif 684 699 acWedgeNodeList.push_back( cWedgeNode ); 685 700 } 686 701 } 687 702 g_dmmWedgeNodeLists.push_back( acWedgeNodeList ); 703 #if LGE_PKU_DMM3_OVERLAP_E0159_HHIFIX 704 } 705 #endif 688 706 } 689 707 return; -
trunk/source/Lib/TLibCommon/TComRom.h
r608 r622 174 174 extern std::vector< std::vector< std::vector<UInt> > > g_aauiWdgLstM3; 175 175 176 #if LGE_PKU_DMM3_OVERLAP_E0159_HHIFIX 177 Void initWedgeLists( Bool initNodeList = false ); 178 #else 176 179 Void initWedgeLists( Bool initRefinements = false ); 180 #endif 177 181 Void createWedgeList( UInt uiWidth, UInt uiHeight, std::vector<TComWedgelet> &racWedgeList, std::vector<TComWedgeRef> &racWedgeRefList, WedgeResolution eWedgeRes ); 178 182 Void addWedgeletToList( TComWedgelet cWedgelet, std::vector<TComWedgelet> &racWedgeList, std::vector<TComWedgeRef> &racWedgeRefList ); … … 194 198 195 199 #ifndef ENC_DEC_TRACE 196 # define ENC_DEC_TRACE0200 #define ENC_DEC_TRACE 0 197 201 #endif 198 202 … … 220 224 extern Bool g_tracePU; 221 225 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) 224 231 225 232 #define DTRACE_CU(x,y) writeToTraceFile( x,y, g_traceCU ); -
trunk/source/Lib/TLibCommon/TComSlice.cpp
r608 r622 101 101 , m_enableTMVPFlag ( true ) 102 102 #if H_MV 103 #if H_MV5 104 , m_refPicSetInterLayer0 ( NULL ) 105 , m_refPicSetInterLayer1 ( NULL ) 106 #else 103 107 , m_refPicSetInterLayer ( NULL ) 108 #endif 104 109 , m_layerId (0) 105 110 , m_viewId (0) 111 #if H_MV5 112 , m_viewIndex (0) 113 #endif 106 114 #if H_3D 115 #if !H_MV5 107 116 , m_viewIndex (0) 117 #endif 108 118 , m_isDepth (false) 119 #endif 120 #if H_MV5 121 , m_pocResetFlag (false) 109 122 #endif 110 123 , m_discardableFlag (false) 111 124 , m_interLayerPredEnabledFlag (false) 112 125 , m_numInterLayerRefPicsMinus1 (0) 126 #if !H_MV5 113 127 , m_interLayerSamplePredOnlyFlag (false) 114 128 , m_altCollocatedIndicationFlag (0) 115 129 , m_collocatedRefLayerIdx (0) 130 #endif 116 131 #if H_3D_IC 117 132 , m_bApplyIC ( false ) … … 149 164 for (Int i = 0; i < MAX_NUM_LAYERS; i++ ) 150 165 { 166 #if H_MV5 167 m_interLayerPredLayerIdc[ i ] = i; 168 #else 151 169 m_interLayerPredLayerIdc[ i ] = 0; 170 #endif 152 171 } 153 172 #endif … … 162 181 { 163 182 if ( m_depthToDisparityB && m_depthToDisparityB[ i ] ) 183 { 164 184 delete[] m_depthToDisparityB [ i ]; 185 } 165 186 166 187 if ( m_depthToDisparityF && m_depthToDisparityF[ i ] ) 188 { 167 189 delete[] m_depthToDisparityF [ i ]; 168 190 } 191 } 169 192 170 193 if ( m_depthToDisparityF ) 194 { 171 195 delete[] m_depthToDisparityF; 196 } 172 197 173 198 m_depthToDisparityF = NULL; … … 362 387 } 363 388 } 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 367 391 #if FIX1071 368 392 Void TComSlice::setRefPicList( TComList<TComPic*>& rcListPic, Bool checkNumPocTotalCurr ) … … 370 394 Void TComSlice::setRefPicList( TComList<TComPic*>& rcListPic ) 371 395 #endif 372 #endif373 396 { 374 397 #if FIX1071 … … 380 403 ::memset( m_apcRefPicList, 0, sizeof (m_apcRefPicList)); 381 404 ::memset( m_aiNumRefIdx, 0, sizeof ( m_aiNumRefIdx )); 382 405 383 406 return; 384 407 } 385 386 #if !H_MV 408 387 409 m_aiNumRefIdx[0] = getNumRefIdx(REF_PIC_LIST_0); 388 410 m_aiNumRefIdx[1] = getNumRefIdx(REF_PIC_LIST_1); 389 #endif390 411 } 391 412 … … 411 432 } 412 433 } 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 556 Void 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 694 Void 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 734 Void TComSlice::setRefPicList( TComList<TComPic*>& rcListPic, std::vector<TComPic*>& refPicSetInterLayer , Bool checkNumPocTotalCurr) 735 #else 736 #if FIX1071 737 Void TComSlice::setRefPicList( TComList<TComPic*>& rcListPic, Bool checkNumPocTotalCurr ) 738 #else 739 Void 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 } 413 782 414 783 for(; i < m_pcRPS->getNumberOfNegativePictures()+m_pcRPS->getNumberOfPositivePictures(); i++) … … 458 827 // 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: 459 828 #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. 462 831 if ( getRapPicFlag() && m_layerId == 0 ) 463 832 #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. 466 835 if (getRapPicFlag()) 467 836 #endif … … 593 962 } 594 963 964 #endif 595 965 Int TComSlice::getNumRpsCurrTempList() 596 966 { … … 609 979 } 610 980 #if H_MV 981 #if !H_MV5 611 982 assert( ( numRpsCurrTempList == 0 ) || getInterRefEnabledInRPLFlag() ); 983 #endif 612 984 numRpsCurrTempList = numRpsCurrTempList + getNumActiveRefLayerPics(); 613 985 #endif … … 923 1295 #if H_MV 924 1296 // Additional slice header syntax elements 1297 #if H_MV5 1298 m_pocResetFlag = pSrc->m_pocResetFlag; 1299 #endif 925 1300 m_discardableFlag = pSrc->m_discardableFlag; 926 1301 m_interLayerPredEnabledFlag = pSrc->m_interLayerPredEnabledFlag; … … 931 1306 m_interLayerPredLayerIdc[ layer ] = pSrc->m_interLayerPredLayerIdc[ layer ]; 932 1307 } 933 1308 #if !H_MV5 934 1309 m_interLayerSamplePredOnlyFlag = pSrc->m_interLayerSamplePredOnlyFlag; 935 1310 m_altCollocatedIndicationFlag = pSrc->m_altCollocatedIndicationFlag ; … … 941 1316 m_interLayerPredLayerIdc[layer] = pSrc->m_interLayerPredLayerIdc[layer]; 942 1317 } 1318 #endif 943 1319 #endif 944 1320 #if H_3D_IC … … 1405 1781 : m_VPSId ( 0) 1406 1782 , m_uiMaxTLayers ( 1) 1783 #if H_MV5 1784 #if H_MV 1785 , m_uiMaxLayersMinus1 ( 0) 1786 #else 1407 1787 , m_uiMaxLayers ( 1) 1788 #endif 1789 #else 1790 , m_uiMaxLayers ( 1) 1791 #endif 1408 1792 , m_bTemporalIdNestingFlag (false) 1409 1793 , m_numHrdParameters ( 0) … … 1416 1800 , m_hrdOpSetIdx (NULL) 1417 1801 , m_cprmsPresentFlag (NULL) 1802 #if H_MV5 1803 #if H_MV 1804 , m_vpsVUI ( NULL ) 1805 #endif 1806 #endif 1418 1807 { 1419 1808 for( Int i = 0; i < MAX_TLAYER; i++) … … 1459 1848 1460 1849 m_avcBaseLayerFlag = false; 1850 #if H_MV5 1851 m_vpsVuiOffset = 0; 1852 #endif 1461 1853 m_splittingFlag = false; 1462 1854 1463 1855 for( Int i = 0; i < MAX_NUM_SCALABILITY_TYPES; i++ ) 1464 1856 { 1857 #if H_MV5 1858 m_scalabilityMaskFlag[i] = false; 1859 #else 1465 1860 m_scalabilityMask[i] = false; 1861 #endif 1466 1862 m_dimensionIdLen [i] = -1; 1467 1863 } … … 1489 1885 m_layerIdInNuh [i] = ( i == 0 ) ? 0 : -1; 1490 1886 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 1491 1893 m_maxTidIlRefPicPlus1[i] = -1; 1894 #endif 1895 1492 1896 #if H_3D 1493 1897 m_viewIndex [i] = -1; … … 1510 1914 } 1511 1915 #endif 1512 #if H_3D _TMVP1916 #if H_3D 1513 1917 m_ivMvScalingFlag = true; 1514 1918 #endif … … 1531 1935 #endif 1532 1936 } 1937 #if H_MV5 1938 m_vpsVUI = new TComVPSVUI; 1939 #endif 1533 1940 #if H_3D 1534 1941 for( Int i = 0; i < MAX_NUM_LAYERS; i++ ) … … 1556 1963 if( m_hrdOpSetIdx != NULL ) delete[] m_hrdOpSetIdx; 1557 1964 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 1558 1987 #if H_3D_DIM_DLT 1559 1988 for( Int i = 0; i < MAX_NUM_LAYERS; i++ ) … … 1572 2001 } 1573 2002 } 2003 #endif 1574 2004 #endif 1575 2005 } … … 1642 2072 Bool TComVPS::checkVPSExtensionSyntax() 1643 2073 { 2074 #if H_MV5 2075 for( Int layer = 1; layer <= getMaxLayersMinus1(); layer++ ) 2076 #else 1644 2077 for( Int layer = 1; layer < getMaxLayers(); layer++ ) 2078 #endif 1645 2079 { 1646 2080 // check layer_id_in_nuh constraint … … 1658 2092 { 1659 2093 assert( scalType >= 0 && scalType <= MAX_NUM_SCALABILITY_TYPES ); 2094 #if H_MV5 2095 assert( scalType == MAX_NUM_SCALABILITY_TYPES || getScalabilityMaskFlag( scalType ) ); 2096 #else 1660 2097 assert( scalType == MAX_NUM_SCALABILITY_TYPES || getScalabilityMask( scalType ) ); 1661 2098 #endif 1662 2099 Int scalIdx = 0; 1663 2100 for( Int curScalType = 0; curScalType < scalType; curScalType++ ) 1664 2101 { 2102 #if H_MV5 2103 scalIdx += ( getScalabilityMaskFlag( curScalType ) ? 1 : 0 ); 2104 #else 1665 2105 scalIdx += ( getScalabilityMask( curScalType ) ? 1 : 0 ); 2106 #endif 2107 1666 2108 } 1667 2109 1668 2110 return scalIdx; 1669 2111 } 1670 2112 #if H_MV5 2113 Void 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 1671 2121 Void TComVPS::setScalabilityMask( UInt val ) 1672 2122 { … … 1675 2125 } 1676 2126 2127 #endif 2128 2129 #if H_MV5 2130 Void 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 2146 Int 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 2154 Int TComVPS::getScalabilityId( Int layerIdInVps, ScalabilityType scalType ) 2155 { 2156 return getScalabilityMaskFlag( scalType ) ? getDimensionId( layerIdInVps, scalTypeToScalIdx( scalType ) ) : 0; 2157 } 2158 2159 #if H_3D 2160 Int 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 1677 2179 Void TComVPS::setRefLayers() 1678 2180 { … … 1793 2295 } 1794 2296 2297 #endif // H_MV5 2298 1795 2299 1796 2300 Int TComVPS::xGetDimBitOffset( Int j ) … … 1832 2336 return numLayersInIdList; 1833 2337 } 2338 #if H_MV5 2339 Int 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 2354 Bool 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 1834 2369 #endif // H_MV 1835 2370 … … 1882 2417 , m_vuiParameters () 1883 2418 #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 1884 2426 , m_interViewMvVertConstraintFlag (false) 1885 2427 , m_numIlpRestrictedRefLayers ( 0 ) 2428 #endif 1886 2429 #endif 1887 2430 #if H_3D … … 1898 2441 ::memset(m_ltRefPicPocLsbSps, 0, sizeof(m_ltRefPicPocLsbSps)); 1899 2442 ::memset(m_usedByCurrPicLtSPSFlag, 0, sizeof(m_usedByCurrPicLtSPSFlag)); 2443 #if !H_MV5 1900 2444 #if H_MV 1901 2445 for (Int i = 0; i < MAX_NUM_LAYERS; i++ ) … … 1905 2449 m_minHorizontalCtuOffsetPlus1 [ i ] = 0; 1906 2450 } 2451 #endif 1907 2452 #endif 1908 2453 } … … 2058 2603 , m_listsModificationPresentFlag( 0) 2059 2604 , m_numExtraSliceHeaderBits(0) 2605 #if H_MV5 2606 #if H_MV 2607 , m_ppsInferScalingListFlag(false) 2608 , m_ppsScalingListRefLayerId(0) 2609 #endif 2610 #endif 2060 2611 { 2061 2612 m_scalingList = new TComScalingList; … … 2077 2628 } 2078 2629 2630 #if H_MV5 2631 #if H_MV 2632 Void 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 2672 Void 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 2079 2683 #if H_3D 2080 2684 Void … … 2346 2950 2347 2951 #if H_MV 2348 Void TComSlice::createAndApplyIvReferencePictureSet( TComPicLists* ivPicLists, std::vector<TComPic*>& refPicSetInterLayer ) 2349 { 2350 refPicSetInterLayer.clear(); 2952 #if H_MV5 2953 Void TComSlice::createInterLayerReferencePictureSet( TComPicLists* ivPicLists, std::vector<TComPic*>& refPicSetInterLayer0, std::vector<TComPic*>& refPicSetInterLayer1 ) 2954 { 2955 refPicSetInterLayer0.clear(); 2956 refPicSetInterLayer1.clear(); 2351 2957 2352 2958 for( Int i = 0; i < getNumActiveRefLayerPics(); i++ ) … … 2360 2966 picRef->getSlice(0)->setReferenced( true ); 2361 2967 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 2985 Void 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 2362 2999 // Consider to check here: 2363 3000 // "If the current picture is a RADL picture, there shall be no entry in the RefPicSetInterLayer that is a RASL picture. " … … 2365 3002 } 2366 3003 } 2367 3004 #endif 3005 3006 #if H_MV5 3007 Void 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 2368 3022 Void TComSlice::markIvRefPicsAsShortTerm( std::vector<TComPic*> refPicSetInterLayer ) 2369 3023 { … … 2375 3029 } 2376 3030 3031 #endif 2377 3032 Void TComSlice::markIvRefPicsAsUnused( TComPicLists* ivPicLists, std::vector<Int> targetDecLayerIdSet, TComVPS* vps, Int curLayerId, Int curPoc ) 2378 3033 { … … 2380 3035 if (targetDecLayerIdSet.size() == 0 ) 2381 3036 { 3037 #if H_MV5 3038 for ( Int layerIdInVps = 0; layerIdInVps <= vps->getMaxLayersMinus1(); layerIdInVps++ ) 3039 #else 2382 3040 for ( Int layerIdInVps = 0; layerIdInVps < vps->getMaxLayers(); layerIdInVps++ ) 3041 #endif 2383 3042 { 2384 3043 targetDecLayerIdSet.push_back( vps->getLayerIdInNuh( layerIdInVps ) ); … … 2391 3050 { 2392 3051 if ( targetDecLayerIdSet[ latestDecIdx ] == curLayerId ) 3052 { 2393 3053 break; 3054 } 2394 3055 } 2395 3056 … … 2407 3068 if ( vps->nuhLayerIdIncluded( targetDecLayerIdSet[ j ] ) ) 2408 3069 { 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 2409 3075 Int targetDecLayerIdinVPS = vpsSlice->getLayerIdInVps( targetDecLayerIdSet[ j ] ); 2410 3076 for( Int k = 0; k < vpsSlice->getNumDirectRefLayers( targetDecLayerIdinVPS ); k++ ) 3077 { 2411 3078 if ( targetDecLayerIdSet[ i ] == vpsSlice->getRefLayerId( targetDecLayerIdinVPS, k ) ) 3079 #endif 3080 { 2412 3081 remainingInterLayerReferencesFlag = true; 2413 3082 } 2414 3083 } 3084 } 3085 } 2415 3086 if( !remainingInterLayerReferencesFlag ) 3087 { 2416 3088 pcPic->getSlice(0)->setReferenced( false ); 2417 3089 } … … 2419 3091 } 2420 3092 } 2421 3093 } 3094 3095 #if H_MV5 3096 Void TComSlice::printRefPicList() 3097 #else 2422 3098 Void TComSlice::xPrintRefPicList() 3099 #endif 2423 3100 { 2424 3101 for ( Int li = 0; li < 2; li++) … … 2433 3110 } 2434 3111 } 3112 #if !H_MV5 2435 3113 Int TComSlice::xCeilLog2( Int val ) 2436 3114 { … … 2440 3118 return ceilLog2; 2441 3119 } 3120 #endif 2442 3121 2443 3122 Void TComSlice::markCurrPic( TComPic* currPic ) … … 2454 3133 } 2455 3134 3135 #if H_MV5 3136 Void TComSlice::setRefPicSetInterLayer( std::vector<TComPic*>* refPicSetInterLayer0, std::vector<TComPic*>* refPicSetInterLayer1 ) 3137 { 3138 m_refPicSetInterLayer0 = refPicSetInterLayer0; 3139 m_refPicSetInterLayer1 = refPicSetInterLayer1; 3140 } 3141 3142 TComPic* 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 2456 3161 Void TComSlice::setRefPicSetInterLayer( std::vector<TComPic*>* refPicSetInterLayer ) 2457 3162 { … … 2474 3179 return pcPic; 2475 3180 } 2476 3181 #endif 2477 3182 Int TComSlice::getNumActiveRefLayerPics() 2478 3183 { 2479 3184 Int numActiveRefLayerPics; 2480 3185 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 2481 3201 if( getLayerId() == 0 || getVPS()->getNumDirectRefLayers( getLayerIdInVps() ) == 0 || !getInterLayerPredEnabledFlag() ) 2482 3202 { … … 2484 3204 } 2485 3205 else if( getVPS()->getMaxOneActiveRefLayerFlag() || getVPS()->getNumDirectRefLayers( getLayerIdInVps() ) == 1 ) 3206 #endif 2486 3207 { 2487 3208 numActiveRefLayerPics = 1; … … 2496 3217 Int TComSlice::getRefPicLayerId( Int i ) 2497 3218 { 3219 #if H_MV5 3220 return getVPS()->getRefLayerId( getLayerId(), getInterLayerPredLayerIdc( i ) ); 3221 #else 2498 3222 return getVPS()->getRefLayerId( getLayerIdInVps(), getInterLayerPredLayerIdc( i ) ); 2499 } 2500 3223 #endif 3224 } 3225 3226 #if !H_MV5 2501 3227 Void TComSlice::setActiveMotionPredRefLayers() 2502 3228 { … … 2527 3253 return interRefEnabledInRPLFlag; 2528 3254 } 3255 #endif 2529 3256 #if H_3D_ARP 2530 3257 Void TComSlice::setARPStepNum() … … 2804 3531 } 2805 3532 3533 #if H_MV5 3534 #if H_MV 3535 Void 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 2806 3549 /** initialization process of quantization matrix array 2807 3550 */ … … 2893 3636 , m_ppsMap(MAX_NUM_PPS) 2894 3637 , m_activeVPSId(-1) 3638 #if H_MV5 3639 #if !H_MV 2895 3640 , m_activeSPSId(-1) 2896 3641 , m_activePPSId(-1) 2897 3642 { 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 2898 3656 } 2899 3657 … … 2905 3663 //! activate a SPS from a active parameter sets SEI message 2906 3664 //! \returns true, if activation is successful 3665 #if H_MV5 3666 #if H_MV 3667 Bool ParameterSetManager::activateSPSWithSEI(Int spsId, Int layerId ) 3668 #else 2907 3669 Bool ParameterSetManager::activateSPSWithSEI(Int spsId) 3670 #endif 3671 #else 3672 Bool ParameterSetManager::activateSPSWithSEI(Int spsId) 3673 #endif 2908 3674 { 2909 3675 TComSPS *sps = m_spsMap.getPS(spsId); … … 2914 3680 { 2915 3681 m_activeVPSId = vpsId; 3682 #if !H_MV5 2916 3683 m_activeSPSId = spsId; 3684 #else 3685 #if H_MV 3686 m_activeSPSId[ layerId ] = spsId; 3687 #else 3688 m_activeSPSId = spsId; 3689 #endif 3690 #endif 2917 3691 return true; 2918 3692 } … … 2931 3705 //! activate a PPS and depending on isIDR parameter also SPS and VPS 2932 3706 //! \returns true, if activation is successful 3707 #if H_MV5 3708 #if H_MV 3709 Bool ParameterSetManager::activatePPS(Int ppsId, Bool isIRAP, Int layerId ) 3710 #else 3711 Bool 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 2933 3749 Bool ParameterSetManager::activatePPS(Int ppsId, Bool isIRAP) 2934 3750 { … … 2960 3776 m_activeVPSId = vpsId; 2961 3777 m_activeSPSId = spsId; 3778 #endif 2962 3779 return true; 2963 3780 } … … 3009 3826 } 3010 3827 #endif 3011 #if SIGNAL_BITRATE_PICRATE_IN_VPS3012 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 #endif3022 3828 //! \} 3829 3830 #if H_MV5 3831 #if H_MV 3832 TComVPSVUI::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 169 169 Void processRefMatrix (UInt sizeId, UInt listId , UInt refListId ); 170 170 Bool xParseScalingList (Char* pchFile); 171 #if H_MV5 172 #if H_MV 173 Void inferFrom ( TComScalingList* srcScLi ); 174 #endif 175 #endif 171 176 172 177 private: … … 402 407 }; 403 408 409 #if H_MV5 410 #if H_MV 411 class TComVPSVUI 412 { 413 private: 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 428 public: 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 472 class TComRepFormat 473 { 474 private: 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 482 public: 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 404 506 class TComVPS 405 507 { … … 407 509 Int m_VPSId; 408 510 UInt m_uiMaxTLayers; 511 512 #if H_MV5 513 #if H_MV 514 UInt m_uiMaxLayersMinus1; 515 #else 409 516 UInt m_uiMaxLayers; 517 #endif 518 #else 519 UInt m_uiMaxLayers; 520 #endif 410 521 Bool m_bTemporalIdNestingFlag; 411 522 … … 440 551 /// VPS EXTENSION SYNTAX ELEMENTS 441 552 Bool m_avcBaseLayerFlag; 553 #if H_MV5 554 Int m_vpsVuiOffset; 555 #endif 442 556 Bool m_splittingFlag; 557 #if H_MV5 558 Bool m_scalabilityMaskFlag [MAX_NUM_SCALABILITY_TYPES]; 559 #else 443 560 Bool m_scalabilityMask [MAX_NUM_SCALABILITY_TYPES]; 561 #endif 444 562 Int m_dimensionIdLen [MAX_NUM_SCALABILITY_TYPES]; 445 563 Bool m_vpsNuhLayerIdPresentFlag; 446 564 Int m_layerIdInNuh [MAX_NUM_LAYER_IDS]; 447 565 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 448 570 Bool m_directDependencyFlag [MAX_NUM_LAYER_IDS][MAX_NUM_LAYER_IDS]; 571 #if H_MV5 572 Bool m_maxTidRefPresentFlag; 573 #endif 449 574 Int m_maxTidIlRefPicPlus1 [MAX_NUM_LAYERS]; 575 #if H_MV5 576 Bool m_allRefLayersActiveFlag; 577 #endif 450 578 Int m_vpsNumberLayerSetsMinus1; 451 579 Int m_vpsNumProfileTierLevelMinus1; … … 458 586 Bool m_outputLayerFlag [MAX_VPS_OUTPUTLAYER_SETS][MAX_VPS_NUH_LAYER_ID_PLUS1]; 459 587 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 460 594 Bool m_maxOneActiveRefLayerFlag; 595 #if H_MV5 596 Bool m_crossLayerIrapAlignedFlag; 597 #endif 461 598 Int m_directDepTypeLenMinus2; 599 #if H_MV5 600 Bool m_vpsVuiPresentFlag; 601 TComVPSVUI* m_vpsVUI; 602 #endif 462 603 Int m_directDependencyType [MAX_NUM_LAYERS] [MAX_NUM_LAYERS]; 463 604 … … 475 616 Bool m_motionPredEnabledFlag [MAX_NUM_LAYERS][MAX_NUM_LAYERS]; 476 617 Int m_motionPredRefLayerId [MAX_NUM_LAYERS][MAX_NUM_LAYERS]; 618 #if H_MV5 619 Int m_viewIndex [MAX_NUM_LAYERS ]; 620 #else 477 621 #if H_3D 478 622 Int m_viewIndex [MAX_NUM_LAYERS ]; … … 480 624 481 625 Int xCeilLog2 ( Int val ); 626 #endif 482 627 Int xGetDimBitOffset( Int j ); 483 628 629 // VPS EXTENSION 2 SYNTAX ELEMENTS 484 630 #if H_3D_ARP 485 631 UInt m_uiUseAdvResPred [MAX_NUM_LAYERS ]; … … 504 650 Int* m_iIdx2DepthValue [MAX_NUM_LAYERS ]; 505 651 #endif 506 #if H_3D _TMVP652 #if H_3D 507 653 Bool m_ivMvScalingFlag; 508 654 #endif … … 535 681 Void setMaxTLayers (UInt t) { m_uiMaxTLayers = t; } 536 682 683 #if H_MV5 684 #if H_MV 685 UInt getMaxLayersMinus1() { return m_uiMaxLayersMinus1; }; 686 Void setMaxLayersMinus1(UInt l) { m_uiMaxLayersMinus1 = l; } 687 #else 537 688 UInt getMaxLayers () { return m_uiMaxLayers; } 538 689 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 539 695 540 696 Bool getTemporalNestingFlag () { return m_bTemporalIdNestingFlag; } … … 579 735 Bool getAvcBaseLayerFlag() { return m_avcBaseLayerFlag; } 580 736 737 #if H_MV5 738 Void setVpsVuiOffset( Int val ) { m_vpsVuiOffset = val; } 739 Int getVpsVuiOffset( ) { return m_vpsVuiOffset; } 740 #endif 741 581 742 Void setSplittingFlag( Bool val ) { m_splittingFlag = val; } 582 743 Bool getSplittingFlag() { return m_splittingFlag; } 583 744 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 584 750 Void setScalabilityMask( UInt val ); 585 751 586 752 Void setScalabilityMask( Int scalType, Bool val ) { m_scalabilityMask[scalType] = val; } 587 753 Bool getScalabilityMask( Int scalType ) { return m_scalabilityMask[scalType]; } 588 754 #endif 589 755 Int getNumScalabilityTypes( ); 590 756 … … 603 769 Int getDimensionId( Int layerIdInVps, Int scalIdx ) { return m_dimensionId[layerIdInVps][scalIdx]; } 604 770 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 605 778 Void setDirectDependencyFlag( Int depLayeridInVps, Int refLayeridInVps, Bool val ) { m_directDependencyFlag[depLayeridInVps][refLayeridInVps] = val; } 606 779 Bool getDirectDependencyFlag( Int depLayeridInVps, Int refLayeridInVps ) { return m_directDependencyFlag[depLayeridInVps][refLayeridInVps]; } 607 780 781 #if H_MV5 782 Void setMaxTidRefPresentFlag( Bool flag ) { m_maxTidRefPresentFlag = flag; } 783 Bool getMaxTidRefPresentFlag( ) { return m_maxTidRefPresentFlag; } 784 #endif 608 785 Void setMaxTidIlRefPicPlus1( Int layerIdInVps, Int val ) { m_maxTidIlRefPicPlus1[ layerIdInVps ] = val; } 609 786 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 611 791 Void setVpsNumberLayerSetsMinus1( Int val ) { m_vpsNumberLayerSetsMinus1 = val; } 612 792 Int getVpsNumberLayerSetsMinus1( ) { return m_vpsNumberLayerSetsMinus1; } … … 639 819 Int getProfileLevelTierIdx( Int outLayerSetIdx ) { return m_profileLevelTierIdx[ outLayerSetIdx ]; } 640 820 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 641 834 Void setMaxOneActiveRefLayerFlag( Bool flag) { m_maxOneActiveRefLayerFlag = flag; } 642 835 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 644 840 Void setDirectDepTypeLenMinus2( Int val) { m_directDepTypeLenMinus2 = val; } 645 841 Int getDirectDepTypeLenMinus2( ) { return m_directDepTypeLenMinus2; } … … 647 843 Void setDirectDependencyType( Int depLayeridInVps, Int refLayeridInVps, Int val) { m_directDependencyType[ depLayeridInVps ][ refLayeridInVps ] = val; } 648 844 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 651 851 // VPS EXTENSION SEMANTICS VARIABLES 652 852 Void setLayerIdInVps( Int layerIdInNuh, Int val ) { m_layerIdInVps[layerIdInNuh] = val; } … … 654 854 655 855 Int getScalabilityId ( Int layerIdInVps, ScalabilityType scalType ); 856 #if H_MV5 857 Int getViewId ( Int layerIdInNuh ) { return m_viewIdVal[ getViewIndex( getLayerIdInVps( layerIdInNuh) )]; } 858 #else 656 859 Int getViewId ( Int layerIdInVps ) { return getScalabilityId( layerIdInVps, VIEW_ID ); } 657 860 861 #endif 658 862 Void setRefLayers(); 659 863 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 660 871 Int getNumDirectRefLayers( Int layerIdInVps ) { return m_numDirectRefLayers[ layerIdInVps ]; }; 661 872 Int getRefLayerId ( Int layerIdInVps, Int idx );; … … 668 879 Bool getMotionPredEnabledFlag ( Int layerIdInVps, Int idx ) { return m_motionPredEnabledFlag [layerIdInVps][idx]; } 669 880 Int getMotionPredRefLayerId ( Int layerIdInVps, Int idx ) { return m_motionPredRefLayerId [layerIdInVps][idx]; } 670 881 #endif 671 882 Bool checkVPSExtensionSyntax(); 672 883 Int scalTypeToScalIdx ( ScalabilityType scalType ); 673 884 885 #if H_MV5 886 Int getProfileLevelTierIdxLen() { return gCeilLog2( getVpsNumProfileTierLevelMinus1() + 1 ); }; 887 #else 674 888 Int getProfileLevelTierIdxLen() { return xCeilLog2( getVpsNumProfileTierLevelMinus1() + 1 ); }; 889 #endif 890 675 891 Int getNumLayersInIdList ( Int lsIdx );; 676 892 … … 679 895 Int inferLastDimsionIdLenMinus1(); 680 896 897 #if H_MV5 898 // helpers 899 Bool getInDirectDependencyFlag( Int depLayeridInVps, Int refLayeridInVps, Int depth = 0 ); 900 #endif 901 /// VPS EXTENSION 2 SYNTAX ELEMENTS 681 902 #if H_3D 903 #if H_MV5 904 Int getDepthId ( Int layerIdInNuh) { return getScalabilityId( getLayerIdInVps(layerIdInNuh), DEPTH_ID ); } 905 #else 682 906 Void initViewIndex(); 683 907 Int getViewIndex ( Int layerIdInVps ) { return m_viewIndex[ layerIdInVps ]; } 684 908 Int getDepthId ( Int layerIdInVps ) { return getScalabilityId( layerIdInVps, DEPTH_ID ); } 909 #endif 685 910 Int getLayerIdInNuh( Int viewIndex, Bool depthFlag ); 686 911 … … 716 941 #endif 717 942 718 #if H_3D_TMVP719 943 Bool getIvMvScalingFlag ( ) { return m_ivMvScalingFlag; } 720 944 Void setIvMvScalingFlag ( Bool b ) { m_ivMvScalingFlag = b; } 721 #endif722 945 #if LGE_INTER_SDC_E0156 723 946 Bool getInterSDCFlag ( Int layerIdInVps ) { return m_bInterSDCFlag[layerIdInVps]; } … … 737 960 Int m_winTopOffset; 738 961 Int m_winBottomOffset; 962 #if H_MV5 963 #if H_MV 964 Bool m_scaledFlag; 965 #endif 966 #endif 739 967 public: 740 968 Window() … … 744 972 , m_winTopOffset (0) 745 973 , m_winBottomOffset (0) 974 #if H_MV5 975 #if H_MV 976 , m_scaledFlag(true) 977 #endif 978 #endif 746 979 { } 747 980 … … 757 990 Void setWindowBottomOffset(Int val) { m_winBottomOffset = val; m_enabledFlag = true; } 758 991 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 759 1009 Void setWindow(Int offsetLeft, Int offsetLRight, Int offsetLTop, Int offsetLBottom) 760 1010 { … … 804 1054 TComHRD m_hrdParameters; 805 1055 TimingInfo m_timingInfo; 1056 #if !H_MV5 806 1057 #if H_MV 807 1058 Bool m_tileBoundariesAlignedFlag; 1059 #endif 808 1060 #endif 809 1061 … … 839 1091 ,m_log2MaxMvLengthHorizontal(15) 840 1092 ,m_log2MaxMvLengthVertical(15) 1093 #if !H_MV5 841 1094 #if H_MV 842 1095 ,m_tileBoundariesAlignedFlag(true) 1096 #endif 843 1097 #endif 844 1098 {} … … 937 1191 TComHRD* getHrdParameters () { return &m_hrdParameters; } 938 1192 TimingInfo* getTimingInfo() { return &m_timingInfo; } 1193 #if !H_MV5 939 1194 #if H_MV 940 1195 Bool getTileBoundariesAlignedFlag( ) { return m_tileBoundariesAlignedFlag; } 941 1196 Void setTileBoundariesAlignedFlag( Bool flag ) { m_tileBoundariesAlignedFlag = flag; } 942 1197 #endif 1198 #endif 1199 943 1200 }; 944 1201 … … 1024 1281 TComPTL m_pcPTL; 1025 1282 #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 1026 1291 Bool m_interViewMvVertConstraintFlag; 1292 #if !H_MV5 1027 1293 Int m_numIlpRestrictedRefLayers ; 1028 1294 Int m_minSpatialSegmentOffsetPlus1[MAX_NUM_LAYERS]; 1029 1295 Bool m_ctuBasedOffsetEnabledFlag [MAX_NUM_LAYERS]; 1030 1296 Int m_minHorizontalCtuOffsetPlus1 [MAX_NUM_LAYERS]; 1297 #endif 1031 1298 #endif 1032 1299 #if H_3D … … 1165 1432 TComPTL* getPTL() { return &m_pcPTL; } 1166 1433 #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 1167 1448 Void setInterViewMvVertConstraintFlag(Bool val) { m_interViewMvVertConstraintFlag = val; } 1168 1449 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 1171 1456 Void setNumIlpRestrictedRefLayers ( Int val ) { m_numIlpRestrictedRefLayers = val;} 1172 1457 Int getNumIlpRestrictedRefLayers ( ) { return m_numIlpRestrictedRefLayers ;} … … 1180 1465 Void setMinHorizontalCtuOffsetPlus1 ( Int i, Int val ) { m_minHorizontalCtuOffsetPlus1 [ i ] = val;} 1181 1466 Int getMinHorizontalCtuOffsetPlus1 ( Int i ) { return m_minHorizontalCtuOffsetPlus1 [ i ];} 1467 1468 #endif 1182 1469 #endif 1183 1470 #if H_3D_QTLPC … … 1295 1582 Int m_numExtraSliceHeaderBits; 1296 1583 1584 #if H_MV5 1585 #if H_MV 1586 Int m_layerId; 1587 Bool m_ppsInferScalingListFlag; 1588 Int m_ppsScalingListRefLayerId; 1589 #endif 1590 #endif 1297 1591 public: 1298 1592 TComPPS(); … … 1416 1710 Bool getSliceHeaderExtensionPresentFlag () { return m_sliceHeaderExtensionPresentFlag; } 1417 1711 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 1418 1724 }; 1419 1725 … … 1448 1754 Bool m_PicOutputFlag; ///< pic_output_flag 1449 1755 Int m_iPOC; 1756 #if H_MV5 1757 #if H_MV 1758 Int m_iPOCBeforeReset; 1759 #endif 1760 #endif 1450 1761 Int m_iLastIDR; 1451 1762 static Int m_prevPOC; … … 1542 1853 Bool m_enableTMVPFlag; 1543 1854 #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 1544 1865 std::vector<TComPic*>* m_refPicSetInterLayer; 1545 1866 Int m_layerId; … … 1549 1870 Bool m_isDepth; 1550 1871 #endif 1872 #endif 1551 1873 1552 1874 // Additional slice header syntax elements 1875 #if H_MV5 1876 Bool m_pocResetFlag; 1877 #endif 1553 1878 Bool m_discardableFlag; 1554 1879 Bool m_interLayerPredEnabledFlag; 1555 1880 Int m_numInterLayerRefPicsMinus1; 1556 1881 Int m_interLayerPredLayerIdc [MAX_NUM_LAYERS]; 1882 #if !H_MV5 1557 1883 Bool m_interLayerSamplePredOnlyFlag; 1558 1884 Bool m_altCollocatedIndicationFlag; … … 1562 1888 Int m_activeMotionPredRefLayerId [ MAX_NUM_LAYER_IDS ]; 1563 1889 1890 #endif 1564 1891 Int m_aaiCodedScale [2][MAX_NUM_LAYERS]; 1565 1892 Int m_aaiCodedOffset[2][MAX_NUM_LAYERS]; … … 1640 1967 TComPic* getIvPic ( Bool depthFlag, Int viewIndex){ return m_ivPicsCurrPoc[ depthFlag ? 1 : 0 ][ viewIndex ]; } 1641 1968 #endif 1642 #if H_3D _IV_MERGE1969 #if H_3D 1643 1970 TComPic* getTexturePic () { return m_ivPicsCurrPoc[0][ m_viewIndex ]; } 1644 1971 #endif … … 1695 2022 1696 2023 #if H_MV 2024 #if H_MV5 2025 Void setPocBeforeReset ( Int i ) { m_iPOCBeforeReset = i; } 2026 Int getPocBeforeReset ( ) { return m_iPOCBeforeReset; } 2027 #endif 1697 2028 Int getRefLayerId ( RefPicList e, Int iRefIdx) { return m_aiRefLayerIdList[e][iRefIdx]; } 1698 2029 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 1701 2036 Void setRefPicList ( TComList<TComPic*>& rcListPic, std::vector<TComPic*>& interLayerRefPicSet , Bool checkNumPocTotalCurr = false ); 2037 #endif 1702 2038 #else 1703 2039 #if FIX1071 … … 1748 2084 Void applyReferencePictureSet( TComList<TComPic*>& rcListPic, TComReferencePictureSet *RPSList); 1749 2085 #if H_MV 2086 #if !H_MV5 1750 2087 Void createAndApplyIvReferencePictureSet( TComPicLists* ivPicLists, std::vector<TComPic*>& refPicSetInterLayer ); 1751 2088 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 1752 2093 static Void markCurrPic ( TComPic* currPic );; 1753 2094 static Void markIvRefPicsAsUnused ( TComPicLists* ivPicLists, std::vector<Int> targetDecLayerIdSet, TComVPS* vps, Int curLayerId, Int curPoc ); 2095 #if H_MV5 2096 Void printRefPicList(); 2097 #else 1754 2098 Void xPrintRefPicList(); 2099 #endif 1755 2100 #endif 1756 2101 Bool isTemporalLayerSwitchingPoint( TComList<TComPic*>& rcListPic ); … … 1839 2184 Void setViewId ( Int viewId ) { m_viewId = viewId; } 1840 2185 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 1841 2190 #if H_3D 1842 2191 #if H_3D_TMVP … … 1845 2194 Int getAlterRefIdx ( RefPicList e ) { return m_aiAlterRefIdx[e]; } 1846 2195 #endif 2196 #if !H_MV5 1847 2197 Void setViewIndex ( Int viewIndex ) { m_viewIndex = viewIndex; } 1848 2198 Int getViewIndex () { return m_viewIndex; } 2199 #endif 1849 2200 Void setIsDepth ( Bool isDepth ) { m_isDepth = isDepth; } 1850 2201 Bool getIsDepth () { return m_isDepth; } … … 1867 2218 #if H_MV 1868 2219 // 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 1869 2226 Void setDiscardableFlag( Bool flag ) { m_discardableFlag = flag; } 1870 2227 Bool getDiscardableFlag( ) { return m_discardableFlag; } … … 1879 2236 Int getInterLayerPredLayerIdc( Int i ) { return m_interLayerPredLayerIdc[i]; } 1880 2237 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 1881 2253 Void setInterLayerSamplePredOnlyFlag( Bool flag ) { m_interLayerSamplePredOnlyFlag = flag; } 1882 2254 Bool getInterLayerSamplePredOnlyFlag( ) { return m_interLayerSamplePredOnlyFlag; } … … 1905 2277 TComPic* getPicFromRefPicSetInterLayer( Int layerId ); 1906 2278 2279 #endif 1907 2280 #endif 1908 2281 protected: … … 1911 2284 TComPic* xGetLongTermRefPic(TComList<TComPic*>& rcListPic, Int poc, Bool pocHasMsb); 1912 2285 #if H_MV 2286 #if !H_MV5 1913 2287 Int xCeilLog2( Int val ); 2288 #endif 1914 2289 TComPic* xGetInterLayerRefPic( std::vector<TComPic*>& rcListIlPic, Int layerId ); 1915 2290 #endif … … 1993 2368 //! activate a SPS from a active parameter sets SEI message 1994 2369 //! \returns true, if activation is successful 2370 #if !H_MV5 1995 2371 Bool activateSPSWithSEI(Int SPSId); 1996 2372 … … 2012 2388 Int m_activeSPSId; 2013 2389 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 2413 protected: 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 2014 2429 }; 2015 2430 -
trunk/source/Lib/TLibCommon/TComWedgelet.cpp
r608 r622 175 175 } 176 176 177 #if !SEC_DMM2_E0146_HHIFIX 177 178 Bool TComWedgelet::checkPredDirAbovePossible( UInt uiPredDirBlockSize, UInt uiPredDirBlockOffset ) 178 179 { … … 642 643 } 643 644 } 645 #endif 644 646 645 647 Void TComWedgelet::xGenerateWedgePattern() -
trunk/source/Lib/TLibCommon/TComWedgelet.h
r608 r622 50 50 enum DIM_IDX 51 51 { 52 #if SEC_DMM2_E0146 52 #if SEC_DMM2_E0146_HHIFIX 53 53 DMM1_IDX = 0, 54 54 DMM3_IDX = 1, … … 63 63 #endif 64 64 }; 65 #if SEC_DMM2_E0146 65 #if SEC_DMM2_E0146_HHIFIX 66 66 #define DMM_NUM_TYPE 3 67 67 #else … … 86 86 #define DMM_NO_WEDGEINDEX MAX_UINT 87 87 #define DMM_NUM_WEDGE_REFINES 8 88 #if !SEC_DMM2_E0146 88 #if !SEC_DMM2_E0146_HHIFIX 89 89 #define DMM2_DELTAEND_MAX 4 90 90 #endif … … 151 151 Bool checkInvIdentical( Bool* pbRefPattern ); 152 152 153 #if !SEC_DMM2_E0146_HHIFIX 153 154 // functions for DMM2 prediction 154 155 Bool checkPredDirAbovePossible( UInt uiPredDirBlockSize, UInt uiPredDirBlockOffsett ); … … 156 157 Void getPredDirStartEndAbove( UChar& ruhXs, UChar& ruhYs, UChar& ruhXe, UChar& ruhYe, UInt uiPredDirBlockSize, UInt uiPredDirBlockOffset, Int iDeltaEnd ); 157 158 Void getPredDirStartEndLeft ( UChar& ruhXs, UChar& ruhYs, UChar& ruhXe, UChar& ruhYe, UInt uiPredDirBlockSize, UInt uiPredDirBlockOffset, Int iDeltaEnd ); 159 #endif 158 160 }; // END CLASS DEFINITION TComWedgelet 159 161 -
trunk/source/Lib/TLibCommon/TComYuv.cpp
r608 r622 110 110 { 111 111 ::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 112 124 pDst += iDstStride; 113 125 pSrc += iSrcStride; -
trunk/source/Lib/TLibCommon/TypeDef.h
r608 r622 92 92 // QC_CU_NBDV_D0181 93 93 // 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 94 95 #define H_3D_ARP 1 // Advanced residual prediction (ARP), JCT3V-D0177 95 96 #define H_3D_IC 1 // Illumination Compensation, JCT3V-B0045, JCT3V-C0046, JCT3V-D0060 … … 110 111 // QC_D0191: Clean up 111 112 // LG_D0092: Multiple VSP candidate allowed 112 113 // MTK_VSP_FIX_ALIGN_WD_E0172 113 114 #define H_3D_IV_MERGE 1 // Inter-view motion merge candidate 114 115 // HHI_INTER_VIEW_MOTION_PRED … … 119 120 // QC_AMVP_MRG_UNIFY_IVCAN_C0051 120 121 // TEXTURE MERGING CANDIDATE , JCT3V-C0137 122 // QC_INRIA_MTK_MRG_E0126 121 123 #define H_3D_TMVP 1 // QC_TMVP_C0047 122 124 // Sony_M23639 … … 161 163 #define MTK_DIVMC_FIX_E0172 1 // fix the issue of derivation of disparity inter-view merge candidate, issue 5 in JCT3V-E0172 162 164 #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-E0172164 #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 WD165 166 #if !MTK_VSP_FIX_ALIGN_WD_E0172167 #define MTK_VSP_FIX_E0172 1 // fix the issues related to VSP merge candidate, issue 3, 4 in JCT3V-E0172168 #endif169 165 #endif // MTK_RVS_BUGFIX_E0172 170 166 … … 175 171 #endif // H_3D_NBDV 176 172 177 #if H_3D_IV_MERGE178 #define QC_INRIA_MTK_MRG_E0126 1 // additional merge candidates JCT3V-E0126179 #endif180 181 173 #if H_3D_DIM 182 #define SEC_DMM2_E0146 174 #define SEC_DMM2_E0146_HHIFIX 1 // Removal of DMM2 from DMMs 183 175 #define ZJU_DEPTH_INTRA_MODE_E0204 1 // Simplified Binarization for depth_intra_mode 184 176 #define KWU_SDC_SIMPLE_DC_E0117 1 // Simplified DC calculation for SDC 185 177 #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 Selection178 #define SCU_HS_FAST_DEPTH_INTRA_E0238_HHIFIX 1 // Fast DMM and RBC Mode Selection 187 179 #endif 188 180 … … 215 207 216 208 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 219 214 ///////////////////////////////////////////////////////////////////////////////////////// 220 215 /////////////////////////////////// DERIVED DEFINES /////////////////////////////////// … … 265 260 #endif 266 261 #if H_3D_DIM_DMM 267 #define LGE_PKU_DMM3_OVERLAP_E0159 262 #define LGE_PKU_DMM3_OVERLAP_E0159_HHIFIX 1 // Removal of overlap between DMM3 and DMM1 268 263 #endif 269 264 #endif … … 271 266 ///// ***** VIEW SYNTHESIS PREDICTION ********* 272 267 #if H_3D_VSP 273 #define H_3D_VSP_POSITION 3 // The only supported position274 268 #define H_3D_VSP_BLOCKSIZE 4 // Supported values: 1, 2, and 4 275 269 #if H_3D_VSP_BLOCKSIZE == 1 … … 799 793 enum ScalabilityType 800 794 { 795 #if H_MV5 796 #if H_3D 797 DEPTH_ID = 0, 798 #endif 799 VIEW_ORDER_INDEX = 1, 800 #else 801 801 VIEW_ID = 0, 802 802 #if H_3D 803 803 DEPTH_ID = 1, 804 804 #endif 805 #endif 805 806 }; 806 807 #endif
Note: See TracChangeset for help on using the changeset viewer.