Index: /trunk/source/App/TAppDecoder/TAppDecCfg.h =================================================================== --- /trunk/source/App/TAppDecoder/TAppDecCfg.h (revision 188) +++ /trunk/source/App/TAppDecoder/TAppDecCfg.h (revision 189) @@ -60,20 +60,6 @@ #if SVC_EXTENSION Char* m_pchReconFile [MAX_LAYERS]; ///< output reconstruction file name -#if AVC_BASE - Char* m_pchBLReconFile; ///< input BL reconstruction file name - Int m_iBLSourceWidth; - Int m_iBLSourceHeight; -#if AVC_SYNTAX - Char* m_pchBLSyntaxFile; ///< input BL syntax file name -#endif -#endif #else Char* m_pchReconFile; ///< output reconstruction file name -#endif -#if SYNTAX_OUTPUT - Char* m_pchBLSyntaxFile; ///< input BL syntax file name - Int m_iBLSourceWidth; - Int m_iBLSourceHeight; - Int m_iBLFrames; #endif Int m_iSkipFrame; ///< counter for frames prior to the random access point to skip @@ -86,5 +72,21 @@ #if SVC_EXTENSION Int m_tgtLayerId; ///< target layer ID +#if AVC_BASE + Char* m_pchBLReconFile; ///< input BL reconstruction file name + Int m_iBLSourceWidth; + Int m_iBLSourceHeight; +#if AVC_SYNTAX + Char* m_pchBLSyntaxFile; ///< input BL syntax file name #endif +#endif +#endif + +#if SYNTAX_OUTPUT + Char* m_pchBLSyntaxFile; ///< input BL syntax file name + Int m_iBLSourceWidth; + Int m_iBLSourceHeight; + Int m_iBLFrames; +#endif + std::vector m_targetDecLayerIdSet; ///< set of LayerIds to be included in the sub-bitstream extraction process. Int m_respectDefDispWindow; ///< Only output content inside the default display window @@ -103,6 +105,4 @@ #if SVC_EXTENSION , m_tgtLayerId(0) -#endif - , m_respectDefDispWindow(0) #if AVC_BASE , m_iBLSourceWidth(0) @@ -114,4 +114,6 @@ , m_iBLFrames(0) #endif +#endif + , m_respectDefDispWindow(0) {} virtual ~TAppDecCfg() {} Index: /trunk/source/App/TAppDecoder/TAppDecTop.cpp =================================================================== --- /trunk/source/App/TAppDecoder/TAppDecTop.cpp (revision 188) +++ /trunk/source/App/TAppDecoder/TAppDecTop.cpp (revision 189) @@ -157,14 +157,8 @@ #if AVC_BASE TComPic pcBLPic; - if( !m_pchBLReconFile ) - { - printf( "Wrong base layer YUV input file\n" ); - exit(EXIT_FAILURE); - } - fstream streamYUV( m_pchBLReconFile, fstream::in | fstream::binary ); - if( !streamYUV.good() ) - { - printf( "Base layer YUV input reading error\n" ); - exit(EXIT_FAILURE); + fstream streamYUV; + if( m_pchBLReconFile ) + { + streamYUV.open( m_pchBLReconFile, fstream::in | fstream::binary ); } TComList *cListPic = m_acTDecTop[0].getListPic(); @@ -174,14 +168,8 @@ cListPic->pushBack( &pcBLPic ); #if AVC_SYNTAX - if( !m_pchBLSyntaxFile ) - { - printf( "Wrong base layer syntax file\n" ); - exit(EXIT_FAILURE); - } - fstream streamSyntaxFile( m_pchBLSyntaxFile, fstream::in | fstream::binary ); - if( !streamSyntaxFile.good() ) - { - printf( "Base layer syntax input reading error\n" ); - exit(EXIT_FAILURE); + fstream streamSyntaxFile; + if( m_pchBLSyntaxFile ) + { + streamSyntaxFile.open( m_pchBLSyntaxFile, fstream::in | fstream::binary ); } m_acTDecTop[0].setBLSyntaxFile( &streamSyntaxFile ); @@ -254,9 +242,9 @@ } if ( bNewPicture && bNewPOC && - ( nalu.m_nalUnitType == NAL_UNIT_CODED_SLICE_IDR + ( nalu.m_nalUnitType == NAL_UNIT_CODED_SLICE_IDR_W_RADL || nalu.m_nalUnitType == NAL_UNIT_CODED_SLICE_IDR_N_LP || nalu.m_nalUnitType == NAL_UNIT_CODED_SLICE_BLA_N_LP - || nalu.m_nalUnitType == NAL_UNIT_CODED_SLICE_BLANT - || nalu.m_nalUnitType == NAL_UNIT_CODED_SLICE_BLA ) ) + || nalu.m_nalUnitType == NAL_UNIT_CODED_SLICE_BLA_W_RADL + || nalu.m_nalUnitType == NAL_UNIT_CODED_SLICE_BLA_W_LP ) ) { xFlushOutput( pcListPic, curLayerId ); @@ -414,9 +402,9 @@ } if ( bNewPicture && - ( nalu.m_nalUnitType == NAL_UNIT_CODED_SLICE_IDR + ( nalu.m_nalUnitType == NAL_UNIT_CODED_SLICE_IDR_W_RADL || nalu.m_nalUnitType == NAL_UNIT_CODED_SLICE_IDR_N_LP || nalu.m_nalUnitType == NAL_UNIT_CODED_SLICE_BLA_N_LP - || nalu.m_nalUnitType == NAL_UNIT_CODED_SLICE_BLANT - || nalu.m_nalUnitType == NAL_UNIT_CODED_SLICE_BLA ) ) + || nalu.m_nalUnitType == NAL_UNIT_CODED_SLICE_BLA_W_RADL + || nalu.m_nalUnitType == NAL_UNIT_CODED_SLICE_BLA_W_LP ) ) { xFlushOutput( pcListPic ); @@ -572,4 +560,7 @@ if ( m_pchReconFile ) { +#if SYNTAX_OUTPUT && ILP_DECODED_PICTURE + m_cTVideoIOYuvReconFile.write( pcPic->getPicYuvRec() ); +#else const Window &conf = pcPic->getConformanceWindow(); const Window &defDisp = m_respectDefDispWindow ? pcPic->getDefDisplayWindow() : Window(); @@ -579,4 +570,5 @@ conf.getWindowTopOffset() + defDisp.getWindowTopOffset(), conf.getWindowBottomOffset() + defDisp.getWindowBottomOffset() ); +#endif } Index: /trunk/source/App/TAppEncoder/TAppEncCfg.cpp =================================================================== --- /trunk/source/App/TAppEncoder/TAppEncCfg.cpp (revision 188) +++ /trunk/source/App/TAppEncoder/TAppEncCfg.cpp (revision 189) @@ -66,4 +66,7 @@ TAppEncCfg::TAppEncCfg() : m_pBitstreamFile() +#if AVC_BASE +, m_avcBaseLayerFlag(0) +#endif , m_pColumnWidth() , m_pRowHeight() @@ -89,4 +92,9 @@ { m_aidQP = NULL; +#if J0149_TONE_MAPPING_SEI + m_startOfCodedInterval = NULL; + m_codedPivotValue = NULL; + m_targetPivotValue = NULL; +#endif } #endif @@ -102,4 +110,21 @@ delete[] m_aidQP; } +#if J0149_TONE_MAPPING_SEI + if ( m_startOfCodedInterval ) + { + delete[] m_startOfCodedInterval; + m_startOfCodedInterval = NULL; + } + if ( m_codedPivotValue ) + { + delete[] m_codedPivotValue; + m_codedPivotValue = NULL; + } + if ( m_targetPivotValue ) + { + delete[] m_targetPivotValue; + m_targetPivotValue = NULL; + } +#endif free(m_pchInputFile); #endif @@ -119,4 +144,13 @@ Void TAppEncCfg::destroy() { +#if VPS_EXTN_DIRECT_REF_LAYERS + for(Int layer = 0; layer < MAX_LAYERS; layer++) + { + if( m_acLayerCfg[layer].m_numDirectRefLayers > 0 ) + { + delete [] m_acLayerCfg[layer].m_refLayerIds; + } + } +#endif } @@ -297,4 +331,10 @@ string* cfg_refLayerIdsPtr [MAX_LAYERS]; #endif +#if SCALED_REF_LAYER_OFFSETS + Int* cfg_scaledRefLayerLeftOffset [MAX_LAYERS]; + Int* cfg_scaledRefLayerTopOffset [MAX_LAYERS]; + Int* cfg_scaledRefLayerRightOffset [MAX_LAYERS]; + Int* cfg_scaledRefLayerBottomOffset [MAX_LAYERS]; +#endif for(UInt layer = 0; layer < MAX_LAYERS; layer++) { @@ -311,5 +351,14 @@ cfg_refLayerIdsPtr [layer] = &cfg_refLayerIds[layer]; #endif - } +#if SCALED_REF_LAYER_OFFSETS + cfg_scaledRefLayerLeftOffset [layer] = &m_acLayerCfg[layer].m_scaledRefLayerLeftOffset; + cfg_scaledRefLayerTopOffset [layer] = &m_acLayerCfg[layer].m_scaledRefLayerTopOffset; + cfg_scaledRefLayerRightOffset [layer] = &m_acLayerCfg[layer].m_scaledRefLayerRightOffset; + cfg_scaledRefLayerBottomOffset[layer] = &m_acLayerCfg[layer].m_scaledRefLayerBottomOffset; +#endif + } +#if AVC_BASE + string cfg_BLInputFile; +#endif #if AVC_SYNTAX string cfg_BLSyntaxFile; @@ -324,4 +373,9 @@ string cfg_RowHeight; string cfg_ScalingListFile; +#if J0149_TONE_MAPPING_SEI + string cfg_startOfCodedInterval; + string cfg_codedPivotValue; + string cfg_targetPivotValue; +#endif #if SIGNAL_BITRATE_PICRATE_IN_VPS string cfg_bitRateInfoPresentFlag; @@ -361,7 +415,17 @@ ("OutputBitDepthC", m_outputBitDepthC, 0, "As per OutputBitDepth but for chroma component. (default:InternalBitDepthC)") ("InternalBitDepthC", m_internalBitDepthC, 0, "As per InternalBitDepth but for chroma component. (default:IntrenalBitDepth)") - +#if SCALED_REF_LAYER_OFFSETS + ("ScaledRefLayerLeftOffset%d", cfg_scaledRefLayerLeftOffset, 0, MAX_LAYERS, "Horizontal offset of top-left luma sample of scaled base layer picture with respect to" + " top-left luma sample of the EL picture, in units of two luma samples") + ("ScaledRefLayerTopOffset%d", cfg_scaledRefLayerTopOffset, 0, MAX_LAYERS, "Vertical offset of top-left luma sample of scaled base layer picture with respect to" + " top-left luma sample of the EL picture, in units of two luma samples") + ("ScaledRefLayerRightOffset%d", cfg_scaledRefLayerRightOffset, 0, MAX_LAYERS, "Horizontal offset of bottom-right luma sample of scaled base layer picture with respect to" + " bottom-right luma sample of the EL picture, in units of two luma samples") + ("ScaledRefLayerBottomOffset%d", cfg_scaledRefLayerBottomOffset,0, MAX_LAYERS, "Vertical offset of bottom-right luma sample of scaled base layer picture with respect to" + " bottom-right luma sample of the EL picture, in units of two luma samples") +#endif #if AVC_BASE - ("InputBLFile,-ibl", *cfg_InputFile[0], string(""), "Base layer rec YUV input file name") + ("AvcBase,-avc", m_avcBaseLayerFlag, 0, "avc_base_layer_flag") + ("InputBLFile,-ibl", cfg_BLInputFile, string(""), "Base layer rec YUV input file name") #if AVC_SYNTAX ("InputBLSyntaxFile,-ibs", cfg_BLSyntaxFile, string(""), "Base layer syntax input file name") @@ -369,5 +433,5 @@ #endif #if REF_IDX_FRAMEWORK - ("EnableElRapB,-use-rap-b", m_elRapSliceBEnabled, 0, "Set ILP over base-layer I picture to B picture (default is P picture_") + ("EnableElRapB,-use-rap-b", m_elRapSliceBEnabled, 0, "Set ILP over base-layer I picture to B picture (default is P picture)") #endif #else @@ -430,5 +494,7 @@ ("DecodingRefreshType,-dr", m_iDecodingRefreshType, 0, "Intra refresh type (0:none 1:CRA 2:IDR)") ("GOPSize,g", m_iGOPSize, 1, "GOP size of temporal structure") +#if !L0034_COMBINED_LIST_CLEANUP ("ListCombination,-lc", m_bUseLComb, true, "Combined reference list for uni-prediction estimation in B-slices") +#endif // motion options ("FastSearch", m_iFastSearch, 1, "0:Full search 1:Diamond 2:PMVFAST") @@ -488,4 +554,7 @@ ("LoopFilterTcOffset_div2", m_loopFilterTcOffsetDiv2, 0 ) ("DeblockingFilterControlPresent", m_DeblockingFilterControlPresent, false ) +#if L0386_DB_METRIC + ("DeblockingFilterMetric", m_DeblockingFilterMetric, false ) +#endif // Coding tools @@ -602,4 +671,36 @@ ("SEIBufferingPeriod", m_bufferingPeriodSEIEnabled, 0, "Control generation of buffering period SEI messages") ("SEIPictureTiming", m_pictureTimingSEIEnabled, 0, "Control generation of picture timing SEI messages") +#if J0149_TONE_MAPPING_SEI + ("SEIToneMappingInfo", m_toneMappingInfoSEIEnabled, false, "Control generation of Tone Mapping SEI messages") + ("SEIToneMapId", m_toneMapId, 0, "Specifies Id of Tone Mapping SEI message for a given session") + ("SEIToneMapCancelFlag", m_toneMapCancelFlag, false, "Indicates that Tone Mapping SEI message cancels the persistance or follows") + ("SEIToneMapPersistenceFlag", m_toneMapPersistenceFlag, true, "Specifies the persistence of the Tone Mapping SEI message") + ("SEIToneMapCodedDataBitDepth", m_toneMapCodedDataBitDepth, 8, "Specifies Coded Data BitDepth of Tone Mapping SEI messages") + ("SEIToneMapTargetBitDepth", m_toneMapTargetBitDepth, 8, "Specifies Output BitDepth of Tome mapping function") + ("SEIToneMapModelId", m_toneMapModelId, 0, "Specifies Model utilized for mapping coded data into target_bit_depth range\n" + "\t0: linear mapping with clipping\n" + "\t1: sigmoidal mapping\n" + "\t2: user-defined table mapping\n" + "\t3: piece-wise linear mapping\n" + "\t4: luminance dynamic range information ") + ("SEIToneMapMinValue", m_toneMapMinValue, 0, "Specifies the minimum value in mode 0") + ("SEIToneMapMaxValue", m_toneMapMaxValue, 1023, "Specifies the maxmum value in mode 0") + ("SEIToneMapSigmoidMidpoint", m_sigmoidMidpoint, 512, "Specifies the centre point in mode 1") + ("SEIToneMapSigmoidWidth", m_sigmoidWidth, 960, "Specifies the distance between 5% and 95% values of the target_bit_depth in mode 1") + ("SEIToneMapStartOfCodedInterval", cfg_startOfCodedInterval, string(""), "Array of user-defined mapping table") + ("SEIToneMapNumPivots", m_numPivots, 0, "Specifies the number of pivot points in mode 3") + ("SEIToneMapCodedPivotValue", cfg_codedPivotValue, string(""), "Array of pivot point") + ("SEIToneMapTargetPivotValue", cfg_targetPivotValue, string(""), "Array of pivot point") + ("SEIToneMapCameraIsoSpeedIdc", m_cameraIsoSpeedIdc, 0, "Indicates the camera ISO speed for daylight illumination") + ("SEIToneMapCameraIsoSpeedValue", m_cameraIsoSpeedValue, 400, "Specifies the camera ISO speed for daylight illumination of Extended_ISO") + ("SEIToneMapExposureCompensationValueSignFlag", m_exposureCompensationValueSignFlag, 0, "Specifies the sign of ExposureCompensationValue") + ("SEIToneMapExposureCompensationValueNumerator", m_exposureCompensationValueNumerator, 0, "Specifies the numerator of ExposureCompensationValue") + ("SEIToneMapExposureCompensationValueDenomIdc", m_exposureCompensationValueDenomIdc, 2, "Specifies the denominator of ExposureCompensationValue") + ("SEIToneMapRefScreenLuminanceWhite", m_refScreenLuminanceWhite, 350, "Specifies reference screen brightness setting in units of candela per square metre") + ("SEIToneMapExtendedRangeWhiteLevel", m_extendedRangeWhiteLevel, 800, "Indicates the luminance dynamic range") + ("SEIToneMapNominalBlackLevelLumaCodeValue", m_nominalBlackLevelLumaCodeValue, 16, "Specifies luma sample value of the nominal black level assigned decoded pictures") + ("SEIToneMapNominalWhiteLevelLumaCodeValue", m_nominalWhiteLevelLumaCodeValue, 235, "Specifies luma sample value of the nominal white level assigned decoded pictures") + ("SEIToneMapExtendedWhiteLevelLumaCodeValue", m_extendedWhiteLevelLumaCodeValue, 300, "Specifies luma sample value of the extended dynamic range assigned decoded pictures") +#endif ("SEIFramePacking", m_framePackingSEIEnabled, 0, "Control generation of frame packing SEI messages") ("SEIFramePackingType", m_framePackingSEIType, 0, "Define frame packing arrangement\n" @@ -622,4 +723,10 @@ ("SEIGradualDecodingRefreshInfo", m_gradualDecodingRefreshInfoEnabled, 0, "Control generation of gradual decoding refresh information SEI message") ("SEIDecodingUnitInfo", m_decodingUnitInfoSEIEnabled, 0, "Control generation of decoding unit information SEI message.") +#if L0208_SOP_DESCRIPTION_SEI + ("SEISOPDescription", m_SOPDescriptionSEIEnabled, 0, "Control generation of SOP description SEI messages") +#endif +#if K0180_SCALABLE_NESTING_SEI + ("SEIScalableNesting", m_scalableNestingSEIEnabled, 0, "Control generation of scalable nesting SEI messages") +#endif #if SIGNAL_BITRATE_PICRATE_IN_VPS ("BitRatePicRateMaxTLayers", m_bitRatePicRateMaxTLayers, 0, "Maximum number of sub-layers signalled; can be inferred otherwise; here for easy parsing of config. file") @@ -662,4 +769,10 @@ /* convert std::string to c string for compatability */ #if SVC_EXTENSION +#if AVC_BASE + if( m_avcBaseLayerFlag ) + { + *cfg_InputFile[0] = cfg_BLInputFile; + } +#endif m_pBitstreamFile = cfg_BitstreamFile.empty() ? NULL : strdup(cfg_BitstreamFile.c_str()); #if AVC_SYNTAX @@ -878,4 +991,64 @@ } m_iWaveFrontSubstreams = m_iWaveFrontSynchro ? (m_iSourceHeight + m_uiMaxCUHeight - 1) / m_uiMaxCUHeight : 1; +#endif +#if J0149_TONE_MAPPING_SEI + if( m_toneMappingInfoSEIEnabled && !m_toneMapCancelFlag ) + { + Char* pcStartOfCodedInterval = cfg_startOfCodedInterval.empty() ? NULL: strdup(cfg_startOfCodedInterval.c_str()); + Char* pcCodedPivotValue = cfg_codedPivotValue.empty() ? NULL: strdup(cfg_codedPivotValue.c_str()); + Char* pcTargetPivotValue = cfg_targetPivotValue.empty() ? NULL: strdup(cfg_targetPivotValue.c_str()); + if( m_toneMapModelId == 2 && pcStartOfCodedInterval ) + { + char *startOfCodedInterval; + UInt num = 1u<< m_toneMapTargetBitDepth; + m_startOfCodedInterval = new Int[num]; + ::memset( m_startOfCodedInterval, 0, sizeof(Int)*num ); + startOfCodedInterval = strtok(pcStartOfCodedInterval, " ."); + int i = 0; + while( startOfCodedInterval && ( i < num ) ) + { + m_startOfCodedInterval[i] = atoi( startOfCodedInterval ); + startOfCodedInterval = strtok(NULL, " ."); + i++; + } + } + else + { + m_startOfCodedInterval = NULL; + } + if( ( m_toneMapModelId == 3 ) && ( m_numPivots > 0 ) ) + { + if( pcCodedPivotValue && pcTargetPivotValue ) + { + char *codedPivotValue; + char *targetPivotValue; + m_codedPivotValue = new Int[m_numPivots]; + m_targetPivotValue = new Int[m_numPivots]; + ::memset( m_codedPivotValue, 0, sizeof(Int)*( m_numPivots ) ); + ::memset( m_targetPivotValue, 0, sizeof(Int)*( m_numPivots ) ); + codedPivotValue = strtok(pcCodedPivotValue, " ."); + int i=0; + while(codedPivotValue&&i MAX_LAYERS , "Number of layers in config file is greater than MAX_LAYERS" ); + m_numLayers = m_numLayers > MAX_LAYERS ? MAX_LAYERS : m_numLayers; + // verify layer configuration parameters for(UInt layer=0; layer m_maxDecPicBuffering[m_GOPList[i].m_temporalId]) +#else if(m_GOPList[i].m_numRefPics > m_maxDecPicBuffering[m_GOPList[i].m_temporalId]) - { +#endif + { +#if L0323_DPB + m_maxDecPicBuffering[m_GOPList[i].m_temporalId] = m_GOPList[i].m_numRefPics + 1; +#else m_maxDecPicBuffering[m_GOPList[i].m_temporalId] = m_GOPList[i].m_numRefPics; +#endif } Int highestDecodingNumberWithLowerPOC = 0; @@ -1412,4 +1600,11 @@ m_numReorderPics[i+1] = m_numReorderPics[i]; } +#if L0323_DPB + // the value of num_reorder_pics[ i ] shall be in the range of 0 to max_dec_pic_buffering[ i ] - 1, inclusive + if(m_numReorderPics[i] > m_maxDecPicBuffering[i] - 1) + { + m_maxDecPicBuffering[i] = m_numReorderPics[i] + 1; + } +#else // the value of num_reorder_pics[ i ] shall be in the range of 0 to max_dec_pic_buffering[ i ], inclusive if(m_numReorderPics[i] > m_maxDecPicBuffering[i]) @@ -1417,4 +1612,5 @@ m_maxDecPicBuffering[i] = m_numReorderPics[i]; } +#endif // a lower layer can not have higher value of m_uiMaxDecPicBuffering than a higher layer if(m_maxDecPicBuffering[i+1] < m_maxDecPicBuffering[i]) @@ -1423,4 +1619,13 @@ } } + + +#if L0323_DPB + // the value of num_reorder_pics[ i ] shall be in the range of 0 to max_dec_pic_buffering[ i ] - 1, inclusive + if(m_numReorderPics[MAX_TLAYER-1] > m_maxDecPicBuffering[MAX_TLAYER-1] - 1) + { + m_maxDecPicBuffering[MAX_TLAYER-1] = m_numReorderPics[MAX_TLAYER-1] + 1; + } +#else // the value of num_reorder_pics[ i ] shall be in the range of 0 to max_dec_pic_buffering[ i ], inclusive if(m_numReorderPics[MAX_TLAYER-1] > m_maxDecPicBuffering[MAX_TLAYER-1]) @@ -1428,4 +1633,5 @@ m_maxDecPicBuffering[MAX_TLAYER-1] = m_numReorderPics[MAX_TLAYER-1]; } +#endif #if SVC_EXTENSION // ToDo: it should be checked for the case when parameters are different for the layers @@ -1511,6 +1717,7 @@ } #endif - +#if !L0034_COMBINED_LIST_CLEANUP xConfirmPara( m_bUseLComb==false && m_numReorderPics[MAX_TLAYER-1]!=0, "ListCombination can only be 0 in low delay coding (more precisely when L0 and L1 are identical)" ); // Note however this is not the full necessary condition as ref_pic_list_combination_flag can only be 0 if L0 == L1. +#endif xConfirmPara( m_iWaveFrontSynchro < 0, "WaveFrontSynchro cannot be negative" ); #if !SVC_EXTENSION @@ -1520,4 +1727,17 @@ xConfirmPara( m_decodedPictureHashSEIEnabled<0 || m_decodedPictureHashSEIEnabled>3, "this hash type is not correct!\n"); + +#if J0149_TONE_MAPPING_SEI + if (m_toneMappingInfoSEIEnabled) + { + xConfirmPara( m_toneMapCodedDataBitDepth < 8 || m_toneMapCodedDataBitDepth > 14 , "SEIToneMapCodedDataBitDepth must be in rage 8 to 14"); + xConfirmPara( m_toneMapTargetBitDepth < 1 || (m_toneMapTargetBitDepth > 16 && m_toneMapTargetBitDepth < 255) , "SEIToneMapTargetBitDepth must be in rage 1 to 16 or equal to 255"); + xConfirmPara( m_toneMapModelId < 0 || m_toneMapModelId > 4 , "SEIToneMapModelId must be in rage 0 to 4"); + xConfirmPara( m_cameraIsoSpeedValue == 0, "SEIToneMapCameraIsoSpeedValue shall not be equal to 0"); + xConfirmPara( m_extendedRangeWhiteLevel < 100, "SEIToneMapExtendedRangeWhiteLevel should be greater than or equal to 100"); + xConfirmPara( m_nominalBlackLevelLumaCodeValue >= m_nominalWhiteLevelLumaCodeValue, "SEIToneMapNominalWhiteLevelLumaCodeValue shall be greater than SEIToneMapNominalBlackLevelLumaCodeValue"); + xConfirmPara( m_extendedWhiteLevelLumaCodeValue < m_nominalWhiteLevelLumaCodeValue, "SEIToneMapExtendedWhiteLevelLumaCodeValue shall be greater than or equal to SEIToneMapNominalWhiteLevelLumaCodeValue"); + } +#endif #if RATE_CONTROL_LAMBDA_DOMAIN @@ -1609,5 +1829,9 @@ { printf("=== Layer %d settings === \n", layer); +#if AVC_SYNTAX + m_acLayerCfg[layer].xPrintParameter( layer ); +#else m_acLayerCfg[layer].xPrintParameter(); +#endif printf("\n"); } @@ -1677,5 +1901,7 @@ printf("SQP:%d ", m_uiDeltaQpRD ); printf("ASR:%d ", m_bUseASR ); +#if !L0034_COMBINED_LIST_CLEANUP printf("LComb:%d ", m_bUseLComb ); +#endif printf("FEN:%d ", m_bUseFastEnc ); printf("ECU:%d ", m_bUseEarlyCU ); @@ -1718,9 +1944,15 @@ #if SVC_EXTENSION printf("RecalQP:%d ", m_recalculateQPAccordingToLambda ? 1 : 0 ); - printf("AVC_BASE:%d ", AVC_BASE); +#if AVC_BASE + printf("AvcBase:%d ", m_avcBaseLayerFlag ? 1 : 0); +#else + printf("AvcBase:%d ", 0); +#endif #if REF_IDX_FRAMEWORK printf("REF_IDX_FRAMEWORK:%d ", REF_IDX_FRAMEWORK); printf("EL_RAP_SliceType: %d ", m_elRapSliceBEnabled); - printf("REF_IDX_ME_ZEROMV: %d", REF_IDX_ME_ZEROMV); + printf("REF_IDX_ME_ZEROMV: %d ", REF_IDX_ME_ZEROMV); + printf("ENCODER_FAST_MODE: %d ", ENCODER_FAST_MODE); + printf("REF_IDX_MFM: %d ", REF_IDX_MFM); #elif INTRA_BL printf("INTRA_BL:%d ", INTRA_BL); Index: /trunk/source/App/TAppEncoder/TAppEncCfg.h =================================================================== --- /trunk/source/App/TAppEncoder/TAppEncCfg.h (revision 188) +++ /trunk/source/App/TAppEncoder/TAppEncCfg.h (revision 189) @@ -67,6 +67,9 @@ UInt m_FrameSkip; ///< number of skipped frames from the beginning Int m_framesToBeEncoded; ///< number of encoded frames +#if AVC_BASE + Int m_avcBaseLayerFlag; ///< AVC_BASElayer_flag +#endif #if AVC_SYNTAX - char* m_BLSyntaxFile; ///< input syntax file + Char* m_BLSyntaxFile; ///< input syntax file #endif #else @@ -109,6 +112,12 @@ GOPEntry m_GOPList[MAX_GOP]; ///< the coding structure entries from the config file Int m_numReorderPics[MAX_TLAYER]; ///< total number of reorder pictures +#if L0323_DPB + Int m_maxDecPicBuffering[MAX_TLAYER]; ///< total number of pictures in the decoded picture buffer +#else Int m_maxDecPicBuffering[MAX_TLAYER]; ///< total number of reference pictures needed for decoding +#endif +#if !L0034_COMBINED_LIST_CLEANUP Bool m_bUseLComb; ///< flag for using combined reference list for uni-prediction in B-slices (JCTVC-D421) +#endif Bool m_useTransformSkip; ///< flag for enabling intra transform skipping Bool m_useTransformSkipFast; ///< flag for enabling fast intra transform skipping @@ -172,4 +181,7 @@ Int m_loopFilterTcOffsetDiv2; ///< tc offset for deblocking filter Bool m_DeblockingFilterControlPresent; ///< deblocking filter control present flag in PPS +#if L0386_DB_METRIC + Bool m_DeblockingFilterMetric; ///< blockiness metric in encoder +#endif // coding tools (PCM) @@ -223,4 +235,31 @@ Int m_bufferingPeriodSEIEnabled; Int m_pictureTimingSEIEnabled; +#if J0149_TONE_MAPPING_SEI + Bool m_toneMappingInfoSEIEnabled; + Int m_toneMapId; + Bool m_toneMapCancelFlag; + Bool m_toneMapPersistenceFlag; + Int m_toneMapCodedDataBitDepth; + Int m_toneMapTargetBitDepth; + Int m_toneMapModelId; + Int m_toneMapMinValue; + Int m_toneMapMaxValue; + Int m_sigmoidMidpoint; + Int m_sigmoidWidth; + Int m_numPivots; + Int m_cameraIsoSpeedIdc; + Int m_cameraIsoSpeedValue; + Int m_exposureCompensationValueSignFlag; + Int m_exposureCompensationValueNumerator; + Int m_exposureCompensationValueDenomIdc; + Int m_refScreenLuminanceWhite; + Int m_extendedRangeWhiteLevel; + Int m_nominalBlackLevelLumaCodeValue; + Int m_nominalWhiteLevelLumaCodeValue; + Int m_extendedWhiteLevelLumaCodeValue; + Int* m_startOfCodedInterval; + Int* m_codedPivotValue; + Int* m_targetPivotValue; +#endif Int m_framePackingSEIEnabled; Int m_framePackingSEIType; @@ -232,4 +271,10 @@ Int m_gradualDecodingRefreshInfoEnabled; Int m_decodingUnitInfoSEIEnabled; +#if L0208_SOP_DESCRIPTION_SEI + Int m_SOPDescriptionSEIEnabled; +#endif +#if K0180_SCALABLE_NESTING_SEI + Int m_scalableNestingSEIEnabled; +#endif // weighted prediction Bool m_useWeightedPred; ///< Use of weighted prediction in P slices @@ -316,5 +361,4 @@ Int* m_constantPicRateIdc; ///< Indicates constant picture rate idc for various sub-layers #endif - # public: TAppEncCfg(); Index: /trunk/source/App/TAppEncoder/TAppEncLayerCfg.cpp =================================================================== --- /trunk/source/App/TAppEncoder/TAppEncLayerCfg.cpp (revision 188) +++ /trunk/source/App/TAppEncoder/TAppEncLayerCfg.cpp (revision 189) @@ -116,10 +116,17 @@ } +#if AVC_SYNTAX +Void TAppEncLayerCfg::xPrintParameter( UInt layerId ) +#else Void TAppEncLayerCfg::xPrintParameter() +#endif { printf("Input File : %s\n", m_cInputFile.c_str() ); printf("Reconstruction File : %s\n", m_cReconFile.c_str() ); #if AVC_SYNTAX - printf("Base layer input file : %s\n", m_cAppEncCfg->getBLSyntaxFile() ); + if( layerId == 0 ) + { + printf("Base layer syntax file : %s\n", m_cAppEncCfg->getBLSyntaxFile() ); + } #endif printf("Real Format : %dx%d %dHz\n", m_iSourceWidth - m_confLeft - m_confRight, m_iSourceHeight - m_confTop - m_confBottom, m_iFrameRate ); Index: /trunk/source/App/TAppEncoder/TAppEncLayerCfg.h =================================================================== --- /trunk/source/App/TAppEncoder/TAppEncLayerCfg.h (revision 188) +++ /trunk/source/App/TAppEncoder/TAppEncLayerCfg.h (revision 189) @@ -54,4 +54,10 @@ Int* m_aidQP; ///< array of slice QP values TAppEncCfg* m_cAppEncCfg; ///< pointer to app encoder config +#if SCALED_REF_LAYER_OFFSETS + Int m_scaledRefLayerLeftOffset; + Int m_scaledRefLayerTopOffset; + Int m_scaledRefLayerRightOffset; + Int m_scaledRefLayerBottomOffset; +#endif public: TAppEncLayerCfg(); @@ -63,5 +69,9 @@ bool parseCfg ( const string& cfgFileName ); ///< parse layer configuration file to fill member variables +#if AVC_SYNTAX + Void xPrintParameter( UInt layerId ); +#else Void xPrintParameter(); +#endif Bool xCheckParameter(); Index: /trunk/source/App/TAppEncoder/TAppEncTop.cpp =================================================================== --- /trunk/source/App/TAppEncoder/TAppEncTop.cpp (revision 188) +++ /trunk/source/App/TAppEncoder/TAppEncTop.cpp (revision 189) @@ -1,37 +1,37 @@ /* The copyright in this software is being made available under the BSD -* License, included below. This software may be subject to other third party -* and contributor rights, including patent rights, and no such rights are -* granted under this license. -* -* Copyright (c) 2010-2013, ITU/ISO/IEC -* All rights reserved. -* -* Redistribution and use in source and binary forms, with or without -* modification, are permitted provided that the following conditions are met: -* -* * Redistributions of source code must retain the above copyright notice, -* this list of conditions and the following disclaimer. -* * Redistributions in binary form must reproduce the above copyright notice, -* this list of conditions and the following disclaimer in the documentation -* and/or other materials provided with the distribution. -* * Neither the name of the ITU/ISO/IEC nor the names of its contributors may -* be used to endorse or promote products derived from this software without -* specific prior written permission. -* -* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" -* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE -* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE -* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS -* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR -* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF -* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS -* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN -* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) -* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF -* THE POSSIBILITY OF SUCH DAMAGE. -*/ + * License, included below. This software may be subject to other third party + * and contributor rights, including patent rights, and no such rights are + * granted under this license. + * + * Copyright (c) 2010-2013, ITU/ISO/IEC + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * * Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * * Neither the name of the ITU/ISO/IEC nor the names of its contributors may + * be used to endorse or promote products derived from this software without + * specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS + * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF + * THE POSSIBILITY OF SUCH DAMAGE. + */ /** \file TAppEncTop.cpp -\brief Encoder application class + \brief Encoder application class */ @@ -112,5 +112,9 @@ #if REF_IDX_MFM +#if AVC_BASE + m_acTEncTop[layer].setMFMEnabledFlag(layer == 0 ? false : ( m_avcBaseLayerFlag ? AVC_SYNTAX : true )); +#else m_acTEncTop[layer].setMFMEnabledFlag(layer == 0 ? false : true); +#endif #endif // set layer ID @@ -167,4 +171,7 @@ m_acTEncTop[layer].setLoopFilterTcOffset ( m_loopFilterTcOffsetDiv2 ); m_acTEncTop[layer].setDeblockingFilterControlPresent( m_DeblockingFilterControlPresent); +#if L0386_DB_METRIC + m_acTEncTop[layer].setDeblockingFilterMetric ( m_DeblockingFilterMetric ); +#endif //====== Motion search ======== @@ -200,5 +207,7 @@ m_acTEncTop[layer].setUseHADME ( m_bUseHADME ); m_acTEncTop[layer].setUseLossless ( m_useLossless ); - m_acTEncTop[layer].setUseLComb ( m_bUseLComb ); +#if !L0034_COMBINED_LIST_CLEANUP + m_cTEncTop.setUseLComb ( m_bUseLComb ); +#endif m_acTEncTop[layer].setdQPs ( m_acLayerCfg[layer].getdQPs() ); m_acTEncTop[layer].setUseRDOQ ( m_useRDOQ ); @@ -270,4 +279,31 @@ m_acTEncTop[layer].setBufferingPeriodSEIEnabled( m_bufferingPeriodSEIEnabled ); m_acTEncTop[layer].setPictureTimingSEIEnabled( m_pictureTimingSEIEnabled ); +#if J0149_TONE_MAPPING_SEI + m_acTEncTop[layer].setToneMappingInfoSEIEnabled ( m_toneMappingInfoSEIEnabled ); + m_acTEncTop[layer].setTMISEIToneMapId ( m_toneMapId ); + m_acTEncTop[layer].setTMISEIToneMapCancelFlag ( m_toneMapCancelFlag ); + m_acTEncTop[layer].setTMISEIToneMapPersistenceFlag ( m_toneMapPersistenceFlag ); + m_acTEncTop[layer].setTMISEICodedDataBitDepth ( m_toneMapCodedDataBitDepth ); + m_acTEncTop[layer].setTMISEITargetBitDepth ( m_toneMapTargetBitDepth ); + m_acTEncTop[layer].setTMISEIModelID ( m_toneMapModelId ); + m_acTEncTop[layer].setTMISEIMinValue ( m_toneMapMinValue ); + m_acTEncTop[layer].setTMISEIMaxValue ( m_toneMapMaxValue ); + m_acTEncTop[layer].setTMISEISigmoidMidpoint ( m_sigmoidMidpoint ); + m_acTEncTop[layer].setTMISEISigmoidWidth ( m_sigmoidWidth ); + m_acTEncTop[layer].setTMISEIStartOfCodedInterva ( m_startOfCodedInterval ); + m_acTEncTop[layer].setTMISEINumPivots ( m_numPivots ); + m_acTEncTop[layer].setTMISEICodedPivotValue ( m_codedPivotValue ); + m_acTEncTop[layer].setTMISEITargetPivotValue ( m_targetPivotValue ); + m_acTEncTop[layer].setTMISEICameraIsoSpeedIdc ( m_cameraIsoSpeedIdc ); + m_acTEncTop[layer].setTMISEICameraIsoSpeedValue ( m_cameraIsoSpeedValue ); + m_acTEncTop[layer].setTMISEIExposureCompensationValueSignFlag ( m_exposureCompensationValueSignFlag ); + m_acTEncTop[layer].setTMISEIExposureCompensationValueNumerator ( m_exposureCompensationValueNumerator ); + m_acTEncTop[layer].setTMISEIExposureCompensationValueDenomIdc ( m_exposureCompensationValueDenomIdc ); + m_acTEncTop[layer].setTMISEIRefScreenLuminanceWhite ( m_refScreenLuminanceWhite ); + m_acTEncTop[layer].setTMISEIExtendedRangeWhiteLevel ( m_extendedRangeWhiteLevel ); + m_acTEncTop[layer].setTMISEINominalBlackLevelLumaCodeValue ( m_nominalBlackLevelLumaCodeValue ); + m_acTEncTop[layer].setTMISEINominalWhiteLevelLumaCodeValue ( m_nominalWhiteLevelLumaCodeValue ); + m_acTEncTop[layer].setTMISEIExtendedWhiteLevelLumaCodeValue ( m_extendedWhiteLevelLumaCodeValue ); +#endif m_acTEncTop[layer].setFramePackingArrangementSEIEnabled( m_framePackingSEIEnabled ); m_acTEncTop[layer].setFramePackingArrangementSEIType( m_framePackingSEIType ); @@ -279,4 +315,10 @@ m_acTEncTop[layer].setGradualDecodingRefreshInfoEnabled( m_gradualDecodingRefreshInfoEnabled ); m_acTEncTop[layer].setDecodingUnitInfoSEIEnabled( m_decodingUnitInfoSEIEnabled ); +#if L0208_SOP_DESCRIPTION_SEI + m_acTEncTop[layer].setSOPDescriptionSEIEnabled( m_SOPDescriptionSEIEnabled ); +#endif +#if K0180_SCALABLE_NESTING_SEI + m_acTEncTop[layer].setScalableNestingSEIEnabled( m_scalableNestingSEIEnabled ); +#endif m_acTEncTop[layer].setUniformSpacingIdr ( m_iUniformSpacingIdr ); m_acTEncTop[layer].setNumColumnsMinus1 ( m_iNumColumnsMinus1 ); @@ -376,4 +418,11 @@ m_acTEncTop[layer].setElRapSliceTypeB(layer == 0? 0 : m_elRapSliceBEnabled); #endif +#if SCALED_REF_LAYER_OFFSETS + if( layer > 0 ) + { + m_acTEncTop[layer].getScaledRefLayerWindow().setWindow( 2*m_acLayerCfg[layer].m_scaledRefLayerLeftOffset, 2*m_acLayerCfg[layer].m_scaledRefLayerRightOffset, + 2*m_acLayerCfg[layer].m_scaledRefLayerTopOffset, 2*m_acLayerCfg[layer].m_scaledRefLayerBottomOffset); + } +#endif } } @@ -442,4 +491,7 @@ m_cTEncTop.setLoopFilterTcOffset ( m_loopFilterTcOffsetDiv2 ); m_cTEncTop.setDeblockingFilterControlPresent( m_DeblockingFilterControlPresent); +#if L0386_DB_METRIC + m_cTEncTop.setDeblockingFilterMetric ( m_DeblockingFilterMetric ); +#endif //====== Motion search ======== @@ -475,5 +527,7 @@ m_cTEncTop.setUseHADME ( m_bUseHADME ); m_cTEncTop.setUseLossless ( m_useLossless ); +#if !L0034_COMBINED_LIST_CLEANUP m_cTEncTop.setUseLComb ( m_bUseLComb ); +#endif m_cTEncTop.setdQPs ( m_aidQP ); m_cTEncTop.setUseRDOQ ( m_useRDOQ ); @@ -545,4 +599,31 @@ m_cTEncTop.setBufferingPeriodSEIEnabled( m_bufferingPeriodSEIEnabled ); m_cTEncTop.setPictureTimingSEIEnabled( m_pictureTimingSEIEnabled ); +#if J0149_TONE_MAPPING_SEI + m_cTEncTop.setToneMappingInfoSEIEnabled ( m_toneMappingInfoSEIEnabled ); + m_cTEncTop.setTMISEIToneMapId ( m_toneMapId ); + m_cTEncTop.setTMISEIToneMapCancelFlag ( m_toneMapCancelFlag ); + m_cTEncTop.setTMISEIToneMapPersistenceFlag ( m_toneMapPersistenceFlag ); + m_cTEncTop.setTMISEICodedDataBitDepth ( m_toneMapCodedDataBitDepth ); + m_cTEncTop.setTMISEITargetBitDepth ( m_toneMapTargetBitDepth ); + m_cTEncTop.setTMISEIModelID ( m_toneMapModelId ); + m_cTEncTop.setTMISEIMinValue ( m_toneMapMinValue ); + m_cTEncTop.setTMISEIMaxValue ( m_toneMapMaxValue ); + m_cTEncTop.setTMISEISigmoidMidpoint ( m_sigmoidMidpoint ); + m_cTEncTop.setTMISEISigmoidWidth ( m_sigmoidWidth ); + m_cTEncTop.setTMISEIStartOfCodedInterva ( m_startOfCodedInterval ); + m_cTEncTop.setTMISEINumPivots ( m_numPivots ); + m_cTEncTop.setTMISEICodedPivotValue ( m_codedPivotValue ); + m_cTEncTop.setTMISEITargetPivotValue ( m_targetPivotValue ); + m_cTEncTop.setTMISEICameraIsoSpeedIdc ( m_cameraIsoSpeedIdc ); + m_cTEncTop.setTMISEICameraIsoSpeedValue ( m_cameraIsoSpeedValue ); + m_cTEncTop.setTMISEIExposureCompensationValueSignFlag ( m_exposureCompensationValueSignFlag ); + m_cTEncTop.setTMISEIExposureCompensationValueNumerator ( m_exposureCompensationValueNumerator ); + m_cTEncTop.setTMISEIExposureCompensationValueDenomIdc ( m_exposureCompensationValueDenomIdc ); + m_cTEncTop.setTMISEIRefScreenLuminanceWhite ( m_refScreenLuminanceWhite ); + m_cTEncTop.setTMISEIExtendedRangeWhiteLevel ( m_extendedRangeWhiteLevel ); + m_cTEncTop.setTMISEINominalBlackLevelLumaCodeValue ( m_nominalBlackLevelLumaCodeValue ); + m_cTEncTop.setTMISEINominalWhiteLevelLumaCodeValue ( m_nominalWhiteLevelLumaCodeValue ); + m_cTEncTop.setTMISEIExtendedWhiteLevelLumaCodeValue ( m_extendedWhiteLevelLumaCodeValue ); +#endif m_cTEncTop.setFramePackingArrangementSEIEnabled( m_framePackingSEIEnabled ); m_cTEncTop.setFramePackingArrangementSEIType( m_framePackingSEIType ); @@ -554,4 +635,10 @@ m_cTEncTop.setGradualDecodingRefreshInfoEnabled( m_gradualDecodingRefreshInfoEnabled ); m_cTEncTop.setDecodingUnitInfoSEIEnabled( m_decodingUnitInfoSEIEnabled ); +#if L0208_SOP_DESCRIPTION_SEI + m_cTEncTop.setSOPDescriptionSEIEnabled( m_SOPDescriptionSEIEnabled ); +#endif +#if K0180_SCALABLE_NESTING_SEI + m_cTEncTop.setScalableNestingSEIEnabled( m_scalableNestingSEIEnabled ); +#endif m_cTEncTop.setUniformSpacingIdr ( m_iUniformSpacingIdr ); m_cTEncTop.setNumColumnsMinus1 ( m_iNumColumnsMinus1 ); @@ -729,5 +816,9 @@ #if VPS_EXTN_MASK_AND_DIM_INFO UInt i = 0, dimIdLen = 0; +#if AVC_BASE + vps->setAvcBaseLayerFlag(m_avcBaseLayerFlag); +#else vps->setAvcBaseLayerFlag(false); +#endif vps->setSplittingFlag(false); for(i = 0; i < MAX_VPS_NUM_SCALABILITY_TYPES; i++) @@ -769,7 +860,16 @@ #endif // Target output layer +#if VPS_PROFILE_OUTPUT_LAYERS + vps->setNumOutputLayerSets(2); // 2 including the default base-layer set. + vps->setNumProfileTierLevel(2); // 1 for the enhancement layer + vps->setProfileLevelTierIdx(1, 1); + vps->setDefaultOneTargetOutputLayerFlag(true); + Int lsIdx = 1; + vps->setOutputLayerSetIdx(1, lsIdx); // Because only one layer set +#else vps->setNumOutputLayerSets(1); Int lsIdx = 1; vps->setOutputLayerSetIdx(0, lsIdx); // Because only one layer set +#endif // Include the highest layer as output layer for(UInt layer=0; layer <= vps->getMaxLayerId() ; layer++) @@ -802,4 +902,7 @@ } #endif +#if JCTVC_M0458_INTERLAYER_RPS_SIG + vps->setMaxOneActiveRefLayerFlag(true); +#endif #else m_cTEncTop.init(); @@ -812,11 +915,11 @@ /** -- create internal class -- initialize internal variable -- until the end of input YUV file, call encoding function in TEncTop class -- delete allocated buffers -- destroy internal class -. -*/ + - create internal class + - initialize internal variable + - until the end of input YUV file, call encoding function in TEncTop class + - delete allocated buffers + - destroy internal class + . + */ #if SVC_EXTENSION Void TAppEncTop::encode() @@ -855,16 +958,20 @@ #if AVC_SYNTAX - if( !m_BLSyntaxFile ) - { - printf( "Wrong base layer syntax input file\n" ); - exit(EXIT_FAILURE); - } - fstream streamSyntaxFile( m_BLSyntaxFile, fstream::in | fstream::binary ); - if( !streamSyntaxFile.good() ) - { - printf( "Base layer syntax input reading error\n" ); - exit(EXIT_FAILURE); - } - m_acTEncTop[0].setBLSyntaxFile( &streamSyntaxFile ); + fstream streamSyntaxFile; + if( m_acTEncTop[0].getVPS()->getAvcBaseLayerFlag() ) + { + if( !m_BLSyntaxFile ) + { + printf( "Wrong base layer syntax input file\n" ); + exit(EXIT_FAILURE); + } + streamSyntaxFile.open( m_BLSyntaxFile, fstream::in | fstream::binary ); + if( !streamSyntaxFile.good() ) + { + printf( "Base layer syntax input reading error\n" ); + exit(EXIT_FAILURE); + } + m_acTEncTop[0].setBLSyntaxFile( &streamSyntaxFile ); + } #endif @@ -1102,9 +1209,9 @@ /** -- application has picture buffer list with size of GOP -- picture buffer list acts as ring buffer -- end of the list has the latest picture -. -*/ + - application has picture buffer list with size of GOP + - picture buffer list acts as ring buffer + - end of the list has the latest picture + . + */ #if SVC_EXTENSION Void TAppEncTop::xGetBuffer( TComPicYuv*& rpcPicYuvRec, UInt layer) @@ -1222,5 +1329,5 @@ /** \param iNumEncoded number of encoded frames -*/ + */ Void TAppEncTop::xWriteOutput(std::ostream& bitstreamFile, Int iNumEncoded, const std::list& accessUnits) { @@ -1240,5 +1347,9 @@ if (m_pchReconFile) { +#if SYNTAX_OUTPUT && ILP_DECODED_PICTURE + m_cTVideoIOYuvReconFile.write( pcPicYuvRec ); +#else m_cTVideoIOYuvReconFile.write( pcPicYuvRec, m_confLeft, m_confRight, m_confTop, m_confBottom ); +#endif } @@ -1251,6 +1362,6 @@ /** -* -*/ + * + */ void TAppEncTop::rateStatsAccum(const AccessUnit& au, const std::vector& annexBsizes) { @@ -1264,18 +1375,18 @@ case NAL_UNIT_CODED_SLICE_TRAIL_R: case NAL_UNIT_CODED_SLICE_TRAIL_N: - case NAL_UNIT_CODED_SLICE_TLA: + case NAL_UNIT_CODED_SLICE_TLA_R: case NAL_UNIT_CODED_SLICE_TSA_N: case NAL_UNIT_CODED_SLICE_STSA_R: case NAL_UNIT_CODED_SLICE_STSA_N: - case NAL_UNIT_CODED_SLICE_BLA: - case NAL_UNIT_CODED_SLICE_BLANT: + case NAL_UNIT_CODED_SLICE_BLA_W_LP: + case NAL_UNIT_CODED_SLICE_BLA_W_RADL: case NAL_UNIT_CODED_SLICE_BLA_N_LP: - case NAL_UNIT_CODED_SLICE_IDR: + case NAL_UNIT_CODED_SLICE_IDR_W_RADL: case NAL_UNIT_CODED_SLICE_IDR_N_LP: case NAL_UNIT_CODED_SLICE_CRA: case NAL_UNIT_CODED_SLICE_RADL_N: - case NAL_UNIT_CODED_SLICE_DLP: + case NAL_UNIT_CODED_SLICE_RADL_R: case NAL_UNIT_CODED_SLICE_RASL_N: - case NAL_UNIT_CODED_SLICE_TFD: + case NAL_UNIT_CODED_SLICE_RASL_R: case NAL_UNIT_VPS: case NAL_UNIT_SPS: Index: /trunk/source/Lib/TLibCommon/CommonDef.h =================================================================== --- /trunk/source/Lib/TLibCommon/CommonDef.h (revision 188) +++ /trunk/source/Lib/TLibCommon/CommonDef.h (revision 189) @@ -56,5 +56,5 @@ // ==================================================================================================================== -#define NV_VERSION "1.2" ///< Current software version +#define NV_VERSION "2.0rc1" ///< Current software version // ==================================================================================================================== @@ -110,5 +110,7 @@ #define MAX_NUM_REF_PICS 16 ///< max. number of pictures used for reference #define MAX_NUM_REF 16 ///< max. number of entries in picture reference list +#if !L0034_COMBINED_LIST_CLEANUP #define MAX_NUM_REF_LC MAX_NUM_REF_PICS // TODO: remove this macro definition (leftover from combined list concept) +#endif #define MAX_UINT 0xFFFFFFFFU ///< max. value of unsigned 32-bit integer @@ -197,5 +199,5 @@ NAL_UNIT_CODED_SLICE_TSA_N, // 2 - NAL_UNIT_CODED_SLICE_TLA, // 3 // Current name in the spec: TSA_R + NAL_UNIT_CODED_SLICE_TLA_R, // 3 NAL_UNIT_CODED_SLICE_STSA_N, // 4 @@ -203,33 +205,33 @@ NAL_UNIT_CODED_SLICE_RADL_N, // 6 - NAL_UNIT_CODED_SLICE_DLP, // 7 // Current name in the spec: RADL_R + NAL_UNIT_CODED_SLICE_RADL_R, // 7 NAL_UNIT_CODED_SLICE_RASL_N, // 8 - NAL_UNIT_CODED_SLICE_TFD, // 9 // Current name in the spec: RASL_R - - NAL_UNIT_RESERVED_10, - NAL_UNIT_RESERVED_11, - NAL_UNIT_RESERVED_12, - NAL_UNIT_RESERVED_13, - NAL_UNIT_RESERVED_14, - NAL_UNIT_RESERVED_15, - - NAL_UNIT_CODED_SLICE_BLA, // 16 // Current name in the spec: BLA_W_LP - NAL_UNIT_CODED_SLICE_BLANT, // 17 // Current name in the spec: BLA_W_DLP + NAL_UNIT_CODED_SLICE_RASL_R, // 9 + + NAL_UNIT_RESERVED_VCL_N10, + NAL_UNIT_RESERVED_VCL_R11, + NAL_UNIT_RESERVED_VCL_N12, + NAL_UNIT_RESERVED_VCL_R13, + NAL_UNIT_RESERVED_VCL_N14, + NAL_UNIT_RESERVED_VCL_R15, + + NAL_UNIT_CODED_SLICE_BLA_W_LP, // 16 + NAL_UNIT_CODED_SLICE_BLA_W_RADL, // 17 NAL_UNIT_CODED_SLICE_BLA_N_LP, // 18 - NAL_UNIT_CODED_SLICE_IDR, // 19 // Current name in the spec: IDR_W_DLP + NAL_UNIT_CODED_SLICE_IDR_W_RADL, // 19 NAL_UNIT_CODED_SLICE_IDR_N_LP, // 20 NAL_UNIT_CODED_SLICE_CRA, // 21 - NAL_UNIT_RESERVED_22, - NAL_UNIT_RESERVED_23, - - NAL_UNIT_RESERVED_24, - NAL_UNIT_RESERVED_25, - NAL_UNIT_RESERVED_26, - NAL_UNIT_RESERVED_27, - NAL_UNIT_RESERVED_28, - NAL_UNIT_RESERVED_29, - NAL_UNIT_RESERVED_30, - NAL_UNIT_RESERVED_31, + NAL_UNIT_RESERVED_IRAP_VCL22, + NAL_UNIT_RESERVED_IRAP_VCL23, + + NAL_UNIT_RESERVED_VCL24, + NAL_UNIT_RESERVED_VCL25, + NAL_UNIT_RESERVED_VCL26, + NAL_UNIT_RESERVED_VCL27, + NAL_UNIT_RESERVED_VCL28, + NAL_UNIT_RESERVED_VCL29, + NAL_UNIT_RESERVED_VCL30, + NAL_UNIT_RESERVED_VCL31, NAL_UNIT_VPS, // 32 @@ -240,13 +242,13 @@ NAL_UNIT_EOB, // 37 NAL_UNIT_FILLER_DATA, // 38 - NAL_UNIT_SEI, // 39 Prefix SEI - NAL_UNIT_SEI_SUFFIX, // 40 Suffix SEI - NAL_UNIT_RESERVED_41, - NAL_UNIT_RESERVED_42, - NAL_UNIT_RESERVED_43, - NAL_UNIT_RESERVED_44, - NAL_UNIT_RESERVED_45, - NAL_UNIT_RESERVED_46, - NAL_UNIT_RESERVED_47, + NAL_UNIT_PREFIX_SEI, // 39 + NAL_UNIT_SUFFIX_SEI, // 40 + NAL_UNIT_RESERVED_NVCL41, + NAL_UNIT_RESERVED_NVCL42, + NAL_UNIT_RESERVED_NVCL43, + NAL_UNIT_RESERVED_NVCL44, + NAL_UNIT_RESERVED_NVCL45, + NAL_UNIT_RESERVED_NVCL46, + NAL_UNIT_RESERVED_NVCL47, NAL_UNIT_UNSPECIFIED_48, NAL_UNIT_UNSPECIFIED_49, Index: /trunk/source/Lib/TLibCommon/NAL.h =================================================================== --- /trunk/source/Lib/TLibCommon/NAL.h (revision 188) +++ /trunk/source/Lib/TLibCommon/NAL.h (revision 189) @@ -76,24 +76,24 @@ return m_nalUnitType == NAL_UNIT_CODED_SLICE_TRAIL_R || m_nalUnitType == NAL_UNIT_CODED_SLICE_TRAIL_N - || m_nalUnitType == NAL_UNIT_CODED_SLICE_TLA + || m_nalUnitType == NAL_UNIT_CODED_SLICE_TLA_R || m_nalUnitType == NAL_UNIT_CODED_SLICE_TSA_N || m_nalUnitType == NAL_UNIT_CODED_SLICE_STSA_R || m_nalUnitType == NAL_UNIT_CODED_SLICE_STSA_N - || m_nalUnitType == NAL_UNIT_CODED_SLICE_BLA - || m_nalUnitType == NAL_UNIT_CODED_SLICE_BLANT + || m_nalUnitType == NAL_UNIT_CODED_SLICE_BLA_W_LP + || m_nalUnitType == NAL_UNIT_CODED_SLICE_BLA_W_RADL || m_nalUnitType == NAL_UNIT_CODED_SLICE_BLA_N_LP - || m_nalUnitType == NAL_UNIT_CODED_SLICE_IDR + || m_nalUnitType == NAL_UNIT_CODED_SLICE_IDR_W_RADL || m_nalUnitType == NAL_UNIT_CODED_SLICE_IDR_N_LP || m_nalUnitType == NAL_UNIT_CODED_SLICE_CRA || m_nalUnitType == NAL_UNIT_CODED_SLICE_RADL_N - || m_nalUnitType == NAL_UNIT_CODED_SLICE_DLP + || m_nalUnitType == NAL_UNIT_CODED_SLICE_RADL_R || m_nalUnitType == NAL_UNIT_CODED_SLICE_RASL_N - || m_nalUnitType == NAL_UNIT_CODED_SLICE_TFD; + || m_nalUnitType == NAL_UNIT_CODED_SLICE_RASL_R; } #if L0045_NON_NESTED_SEI_RESTRICTIONS Bool isSei() { - return m_nalUnitType == NAL_UNIT_SEI - || m_nalUnitType == NAL_UNIT_SEI_SUFFIX; + return m_nalUnitType == NAL_UNIT_PREFIX_SEI + || m_nalUnitType == NAL_UNIT_SUFFIX_SEI; } Index: /trunk/source/Lib/TLibCommon/SEI.cpp =================================================================== --- /trunk/source/Lib/TLibCommon/SEI.cpp (revision 188) +++ /trunk/source/Lib/TLibCommon/SEI.cpp (revision 189) @@ -38,4 +38,9 @@ #include "CommonDef.h" #include "SEI.h" + +#if J0149_TONE_MAPPING_SEI +//Table D-7 Meaning of camera iso sensitivity indicator and exposure index rating indicator +Int Table_exp_indicator[32] = {0, 10, 12, 16, 20, 25, 32, 40, 50, 64, 80, 100, 125, 160, 200, 250, 320, 400, 500, 640, 800, 1000, 1250, 1600, 2000, 2500, 3200, 4000, 5000, 6400, 8000, -1}; +#endif SEIMessages getSeisByType(SEIMessages &seiList, SEI::PayloadType seiType) Index: /trunk/source/Lib/TLibCommon/SEI.h =================================================================== --- /trunk/source/Lib/TLibCommon/SEI.h (revision 188) +++ /trunk/source/Lib/TLibCommon/SEI.h (revision 189) @@ -355,4 +355,58 @@ }; +#if L0208_SOP_DESCRIPTION_SEI +class SEISOPDescription : public SEI +{ +public: + PayloadType payloadType() const { return SOP_DESCRIPTION; } + + SEISOPDescription() {} + virtual ~SEISOPDescription() {} + + UInt m_sopSeqParameterSetId; + UInt m_numPicsInSopMinus1; + + UInt m_sopDescVclNaluType[MAX_NUM_PICS_IN_SOP]; + UInt m_sopDescTemporalId[MAX_NUM_PICS_IN_SOP]; + UInt m_sopDescStRpsIdx[MAX_NUM_PICS_IN_SOP]; + Int m_sopDescPocDelta[MAX_NUM_PICS_IN_SOP]; +}; +#endif + +#if J0149_TONE_MAPPING_SEI +class SEIToneMappingInfo : public SEI +{ +public: + PayloadType payloadType() const { return TONE_MAPPING_INFO; } + SEIToneMappingInfo() {} + virtual ~SEIToneMappingInfo() {} + + Int m_toneMapId; + Bool m_toneMapCancelFlag; + Bool m_toneMapPersistenceFlag; + Int m_codedDataBitDepth; + Int m_targetBitDepth; + Int m_modelId; + Int m_minValue; + Int m_maxValue; + Int m_sigmoidMidpoint; + Int m_sigmoidWidth; + std::vector m_startOfCodedInterval; + Int m_numPivots; + std::vector m_codedPivotValue; + std::vector m_targetPivotValue; + Int m_cameraIsoSpeedIdc; + Int m_cameraIsoSpeedValue; + Int m_exposureCompensationValueSignFlag; + Int m_exposureCompensationValueNumerator; + Int m_exposureCompensationValueDenomIdc; + Int m_refScreenLuminanceWhite; + Int m_extendedRangeWhiteLevel; + Int m_nominalBlackLevelLumaCodeValue; + Int m_nominalWhiteLevelLumaCodeValue; + Int m_extendedWhiteLevelLumaCodeValue; +}; +#endif + typedef std::list SEIMessages; @@ -366,3 +420,35 @@ Void deleteSEIs (SEIMessages &seiList); +#if K0180_SCALABLE_NESTING_SEI +class SEIScalableNesting : public SEI +{ +public: + PayloadType payloadType() const { return SCALABLE_NESTING; } + + SEIScalableNesting() {} + virtual ~SEIScalableNesting() + { + if (!m_callerOwnsSEIs) + { + deleteSEIs(m_nestedSEIs); + } + } + + Bool m_bitStreamSubsetFlag; + Bool m_nestingOpFlag; + Bool m_defaultOpFlag; //value valid if m_nestingOpFlag != 0 + UInt m_nestingNumOpsMinus1; // -"- + UInt m_nestingMaxTemporalIdPlus1[MAX_TLAYER]; // -"- + UInt m_nestingOpIdx[MAX_NESTING_NUM_OPS]; // -"- + + Bool m_allLayersFlag; //value valid if m_nestingOpFlag == 0 + UInt m_nestingNoOpMaxTemporalIdPlus1; //value valid if m_nestingOpFlag == 0 and m_allLayersFlag == 0 + UInt m_nestingNumLayersMinus1; //value valid if m_nestingOpFlag == 0 and m_allLayersFlag == 0 + UChar m_nestingLayerId[MAX_NESTING_NUM_LAYER]; //value valid if m_nestingOpFlag == 0 and m_allLayersFlag == 0. This can e.g. be a static array of 64 unsigned char values + + Bool m_callerOwnsSEIs; + SEIMessages m_nestedSEIs; +}; +#endif + //! \} Index: /trunk/source/Lib/TLibCommon/TComBitStream.cpp =================================================================== --- /trunk/source/Lib/TLibCommon/TComBitStream.cpp (revision 188) +++ /trunk/source/Lib/TLibCommon/TComBitStream.cpp (revision 189) @@ -177,4 +177,5 @@ } } + Void TComOutputBitstream::writeByteAlignment() { @@ -182,4 +183,37 @@ writeAlignZero(); } + +Int TComOutputBitstream::countStartCodeEmulations() +{ + UInt cnt = 0; + vector& rbsp = getFIFO(); + for (vector::iterator it = rbsp.begin(); it != rbsp.end();) + { + vector::iterator found = it; + do + { + // find the next emulated 00 00 {00,01,02,03} + // NB, end()-1, prevents finding a trailing two byte sequence + found = search_n(found, rbsp.end()-1, 2, 0); + found++; + // if not found, found == end, otherwise found = second zero byte + if (found == rbsp.end()) + { + break; + } + if (*(++found) <= 3) + { + break; + } + } while (true); + it = found; + if (found != rbsp.end()) + { + cnt++; + } + } + return cnt; +} + /** * read #uiNumberOfBits# from bitstream without updating the bitstream Index: /trunk/source/Lib/TLibCommon/TComBitStream.h =================================================================== --- /trunk/source/Lib/TLibCommon/TComBitStream.h (revision 188) +++ /trunk/source/Lib/TLibCommon/TComBitStream.h (revision 189) @@ -154,4 +154,7 @@ Void addSubstream ( TComOutputBitstream* pcSubstream ); Void writeByteAlignment(); + + //! returns the number of start code emulations contained in the current buffer + Int countStartCodeEmulations(); }; @@ -163,4 +166,5 @@ { std::vector *m_fifo; /// FIFO for storage of complete bytes + std::vector m_emulationPreventionByteLocation; protected: @@ -206,4 +210,11 @@ UInt getNumBitsRead() { return m_numBitsRead; } Void readByteAlignment(); + + Void pushEmulationPreventionByteLocation ( UInt pos ) { m_emulationPreventionByteLocation.push_back( pos ); } + UInt numEmulationPreventionBytesRead () { return (UInt) m_emulationPreventionByteLocation.size(); } + std::vector getEmulationPreventionByteLocation () { return m_emulationPreventionByteLocation; } + UInt getEmulationPreventionByteLocation ( UInt idx ) { return m_emulationPreventionByteLocation[ idx ]; } + Void clearEmulationPreventionByteLocation() { m_emulationPreventionByteLocation.clear(); } + Void setEmulationPreventionByteLocation ( std::vector vec ) { m_emulationPreventionByteLocation = vec; } }; Index: /trunk/source/Lib/TLibCommon/TComDataCU.cpp =================================================================== --- /trunk/source/Lib/TLibCommon/TComDataCU.cpp (revision 188) +++ /trunk/source/Lib/TLibCommon/TComDataCU.cpp (revision 189) @@ -1802,4 +1802,10 @@ UInt TComDataCU::getCtxIntraBLFlag( UInt uiAbsPartIdx ) { +#if INTRA_BL_CTX_CHANGE + Int cuDepth = getDepth(uiAbsPartIdx); + Int maxCuDepth = g_uiMaxCUDepth - g_uiAddCUDepth; + UInt uiCtx = (maxCuDepth==3 && cuDepth > 0) ? (cuDepth - 1) : cuDepth; + return uiCtx; +#else TComDataCU* pcTempCU; UInt uiTempPartIdx; @@ -1824,4 +1830,5 @@ return uiCtx; +#endif } #endif @@ -1835,5 +1842,5 @@ { Int refIdxL0 = cMvFieldL0.getRefIdx(); - if(getSlice()->getRefPic(REF_PIC_LIST_0, refIdxL0)->isILR()) + if(getSlice()->getRefPic(REF_PIC_LIST_0, refIdxL0)->isILR(m_layerId)) { checkZeroMVILR &= (cMvFieldL0.getHor() == 0 && cMvFieldL0.getVer() == 0); @@ -1843,5 +1850,5 @@ { Int refIdxL1 = cMvFieldL1.getRefIdx(); - if(getSlice()->getRefPic(REF_PIC_LIST_1, refIdxL1)->isILR()) + if(getSlice()->getRefPic(REF_PIC_LIST_1, refIdxL1)->isILR(m_layerId)) { checkZeroMVILR &= (cMvFieldL1.getHor() == 0 && cMvFieldL1.getVer() == 0); @@ -1859,5 +1866,5 @@ Bool checkZeroMVILR = true; - if(getSlice()->getRefPic(eRefPicList, iRefIdx)->isILR()) + if(getSlice()->getRefPic(eRefPicList, iRefIdx)->isILR(m_layerId)) { AMVPInfo* pcAMVPInfo = getCUMvField(eRefPicList)->getAMVPInfo(); @@ -2530,12 +2537,5 @@ if(m_layerId) { -#if MV_SCALING_POS_FIX pcColCU = getBaseColCU( xP + nPSW/2, yP + nPSH/2, uiCUAddrBase, uiAbsPartAddrBase ); -#else - UInt uiPartIdxCenter; - xDeriveCenterIdx( cCurPS, uiPUIdx, uiPartIdxCenter ); - uiPartIdxCenter -= m_uiAbsIdxInLCU; - pcColCU = getBaseColCU( uiPartIdxCenter, uiCUAddrBase, uiAbsPartAddrBase ); -#endif #if INTRA_BL @@ -2671,5 +2671,5 @@ #endif Bool isAvailableB0 = pcCUAboveRight && -#if SVC_MVP +#if SVC_MVP && !IL_MRG_SIMPLIFIED_PRUNING ( !pcColCU || pcColCU->isIntra( uiAbsPartAddrBase ) || !pcCUAboveRight->hasEqualMotion( uiAboveRightPartIdx, puhInterDirNeighbours[0], &pcMvFieldNeighbours[0] )) && #endif @@ -2715,5 +2715,5 @@ Bool isAvailableA0 = pcCULeftBottom && pcCULeftBottom->isDiffMER(xP-1, yP+nPSH, xP, yP) && -#if SVC_MVP +#if SVC_MVP && !IL_MRG_SIMPLIFIED_PRUNING ( !pcColCU || pcColCU->isIntra( uiAbsPartAddrBase ) || !pcCULeftBottom->hasEqualMotion( uiLeftBottomPartIdx, puhInterDirNeighbours[0], &pcMvFieldNeighbours[0])) && #endif @@ -2759,5 +2759,5 @@ Bool isAvailableB2 = pcCUAboveLeft && pcCUAboveLeft->isDiffMER(xP-1, yP-1, xP, yP) && -#if SVC_MVP +#if SVC_MVP && !IL_MRG_SIMPLIFIED_PRUNING ( !pcColCU || pcColCU->isIntra( uiAbsPartAddrBase ) || !pcCUAboveLeft->hasEqualMotion( uiAboveLeftPartIdx, puhInterDirNeighbours[0], &pcMvFieldNeighbours[0] )) && #endif @@ -4175,5 +4175,6 @@ TComPic* cBaseColPic = m_pcSlice->getBaseColPic(); -#if SVC_UPSAMPLING +#if !SIMPLIFIED_MV_POS_SCALING +#if SVC_UPSAMPLING && !ILP_DECODED_PICTURE const Window &confBL = cBaseColPic->getPicYuvRec()->getConformanceWindow(); const Window &confEL = m_pcPic->getPicYuvRec()->getConformanceWindow(); @@ -4191,4 +4192,5 @@ Int heightEL = m_pcPic->getPicYuvRec()->getHeight(); #endif +#endif uiPelX = (UInt)Clip3(0, m_pcPic->getPicYuvRec()->getWidth() - 1, uiPelX); @@ -4197,13 +4199,37 @@ UInt uiMinUnitSize = m_pcPic->getMinCUWidth(); +#if SIMPLIFIED_MV_POS_SCALING +#if SCALED_REF_LAYER_OFFSETS + Int leftStartL = this->getSlice()->getSPS()->getScaledRefLayerWindow().getWindowLeftOffset(); + Int topStartL = this->getSlice()->getSPS()->getScaledRefLayerWindow().getWindowTopOffset(); + Int iBX = ((uiPelX - leftStartL)*g_posScalingFactor[m_layerId][0] + (1<<15)) >> 16; + Int iBY = ((uiPelY - topStartL )*g_posScalingFactor[m_layerId][1] + (1<<15)) >> 16; +#else + Int iBX = (uiPelX*g_posScalingFactor[m_layerId][0] + (1<<15)) >> 16; + Int iBY = (uiPelY*g_posScalingFactor[m_layerId][1] + (1<<15)) >> 16; +#endif +#else Int iBX = (uiPelX*widthBL + widthEL/2)/widthEL; Int iBY = (uiPelY*heightBL+ heightEL/2)/heightEL; - +#endif + +#if SCALED_REF_LAYER_OFFSETS + if ( iBX >= cBaseColPic->getPicYuvRec()->getWidth() || iBY >= cBaseColPic->getPicYuvRec()->getHeight() || + iBX < 0 || iBY < 0 ) +#else if ( iBX >= cBaseColPic->getPicYuvRec()->getWidth() || iBY >= cBaseColPic->getPicYuvRec()->getHeight()) +#endif { return NULL; } -#if AVC_SYNTAX +#if AVC_SYNTAX && !ILP_DECODED_PICTURE +#if !ILP_DECODED_PICTURE + const Window &confBL = cBaseColPic->getPicYuvRec()->getConformanceWindow(); + const Window &confEL = m_pcPic->getPicYuvRec()->getConformanceWindow(); + + Int widthBL = m_pcSlice->getBaseColPic()->getPicYuvRec()->getWidth () - confBL.getWindowLeftOffset() - confBL.getWindowRightOffset(); + Int heightBL = m_pcSlice->getBaseColPic()->getPicYuvRec()->getHeight() - confBL.getWindowTopOffset() - confBL.getWindowBottomOffset(); +#endif if( iBX >= widthBL || iBY >= heightBL ) //outside of the reference layer cropped picture { @@ -4228,6 +4254,7 @@ TComMvField cMvFieldBase; TComMv cMv; - -#if MV_SCALING_FIX +#if SIMPLIFIED_MV_POS_SCALING + cMv = rcMvFieldBase.getMv().scaleMv( g_mvScalingFactor[m_layerId][0], g_mvScalingFactor[m_layerId][1] ); +#else const Window &confBL = m_pcSlice->getBaseColPic()->getPicYuvRec()->getConformanceWindow(); const Window &confEL = m_pcPic->getPicYuvRec()->getConformanceWindow(); @@ -4238,11 +4265,4 @@ Int widthEL = m_pcPic->getPicYuvRec()->getWidth() - confEL.getWindowLeftOffset() - confEL.getWindowRightOffset(); Int heightEL = m_pcPic->getPicYuvRec()->getHeight() - confEL.getWindowTopOffset() - confEL.getWindowBottomOffset(); -#else - Int widthBL = m_pcSlice->getBaseColPic()->getPicYuvRec()->getWidth(); - Int heightBL = m_pcSlice->getBaseColPic()->getPicYuvRec()->getHeight(); - - Int widthEL = m_pcPic->getPicYuvRec()->getWidth(); - Int heightEL = m_pcPic->getPicYuvRec()->getHeight(); -#endif Int iMvX = (rcMvFieldBase.getHor()*widthEL + (widthBL/2 -1) * (rcMvFieldBase.getHor() > 0 ? 1: -1) )/widthBL; @@ -4250,4 +4270,5 @@ cMv.set(iMvX, iMvY); +#endif rcMvFieldEnhance.setMvField( cMv, rcMvFieldBase.getRefIdx() ); Index: /trunk/source/Lib/TLibCommon/TComLoopFilter.cpp =================================================================== --- /trunk/source/Lib/TLibCommon/TComLoopFilter.cpp (revision 188) +++ /trunk/source/Lib/TLibCommon/TComLoopFilter.cpp (revision 189) @@ -57,10 +57,10 @@ // ==================================================================================================================== -const UChar tctable_8x8[54] = +const UChar TComLoopFilter::sm_tcTable[54] = { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,2,2,2,2,3,3,3,3,4,4,4,5,5,6,6,7,8,9,10,11,13,14,16,18,20,22,24 }; -const UChar betatable_8x8[52] = +const UChar TComLoopFilter::sm_betaTable[52] = { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,6,7,8,9,10,11,12,13,14,15,16,17,18,20,22,24,26,28,30,32,34,36,38,40,42,44,46,48,50,52,54,56,58,60,62,64 @@ -585,6 +585,6 @@ Int iIndexB = Clip3(0, MAX_QP, iQP + (betaOffsetDiv2 << 1)); - Int iTc = tctable_8x8[iIndexTC]*iBitdepthScale; - Int iBeta = betatable_8x8[iIndexB]*iBitdepthScale; + Int iTc = sm_tcTable[iIndexTC]*iBitdepthScale; + Int iBeta = sm_betaTable[iIndexB]*iBitdepthScale; Int iSideThreshold = (iBeta+(iBeta>>1))>>3; Int iThrCut = iTc*10; @@ -735,5 +735,5 @@ Int iIndexTC = Clip3(0, MAX_QP+DEFAULT_INTRA_TC_OFFSET, iQP + DEFAULT_INTRA_TC_OFFSET*(ucBs - 1) + (tcOffsetDiv2 << 1)); - Int iTc = tctable_8x8[iIndexTC]*iBitdepthScale; + Int iTc = sm_tcTable[iIndexTC]*iBitdepthScale; for ( UInt uiStep = 0; uiStep < uiPelsInPartChroma; uiStep++ ) Index: /trunk/source/Lib/TLibCommon/TComLoopFilter.h =================================================================== --- /trunk/source/Lib/TLibCommon/TComLoopFilter.h (revision 188) +++ /trunk/source/Lib/TLibCommon/TComLoopFilter.h (revision 189) @@ -99,4 +99,7 @@ __inline Int xCalcDQ( Pel* piSrc, Int iOffset); + static const UChar sm_tcTable[54]; + static const UChar sm_betaTable[52]; + public: TComLoopFilter(); @@ -111,4 +114,10 @@ /// picture-level deblocking filter Void loopFilterPic( TComPic* pcPic ); + + static Int getBeta( Int qp ) + { + Int indexB = Clip3( 0, MAX_QP, qp ); + return sm_betaTable[ indexB ]; + } }; Index: /trunk/source/Lib/TLibCommon/TComMv.h =================================================================== --- /trunk/source/Lib/TLibCommon/TComMv.h (revision 188) +++ /trunk/source/Lib/TLibCommon/TComMv.h (revision 189) @@ -149,4 +149,12 @@ return TComMv( mvx, mvy ); } +#if SIMPLIFIED_MV_POS_SCALING + const TComMv scaleMv( Int iScaleX, Int iScaleY ) const + { + Int mvx = Clip3( -32768, 32767, (iScaleX * getHor() + 127 + (iScaleX * getHor() < 0)) >> 8 ); + Int mvy = Clip3( -32768, 32767, (iScaleY * getVer() + 127 + (iScaleY * getVer() < 0)) >> 8 ); + return TComMv( mvx, mvy ); + } +#endif };// END CLASS DEFINITION TComMV Index: /trunk/source/Lib/TLibCommon/TComPic.cpp =================================================================== --- /trunk/source/Lib/TLibCommon/TComPic.cpp (revision 188) +++ /trunk/source/Lib/TLibCommon/TComPic.cpp (revision 189) @@ -116,27 +116,4 @@ return; } -#if REF_IDX_FRAMEWORK -Void TComPic::createWithOutYuv( Int iWidth, Int iHeight, UInt uiMaxWidth, UInt uiMaxHeight, UInt uiMaxDepth, TComSPS* pcSps, Bool bIsVirtual) -{ - m_apcPicSym = new TComPicSym; m_apcPicSym ->create( iWidth, iHeight, uiMaxWidth, uiMaxHeight, uiMaxDepth ); - if (!bIsVirtual) - { - m_apcPicYuv[0] = new TComPicYuv; m_apcPicYuv[0]->create( iWidth, iHeight, uiMaxWidth, uiMaxHeight, uiMaxDepth, pcSps ); - } - m_apcPicYuv[1] = NULL; - -#if SVC_UPSAMPLING - if (m_bSpatialEnhLayer) - { - m_pcFullPelBaseRec = new TComPicYuv; m_pcFullPelBaseRec->create( iWidth, iHeight, uiMaxWidth, uiMaxHeight, uiMaxDepth, pcSps ); - } -#endif - - /* there are no SEI messages associated with this picture initially */ - m_SEIs.clear(); - m_bUsedByCurr = false; - return; -} -#endif #else Void TComPic::create( Int iWidth, Int iHeight, UInt uiMaxWidth, UInt uiMaxHeight, UInt uiMaxDepth, Window &conformanceWindow, Window &defaultDisplayWindow, @@ -559,5 +536,5 @@ } -Void TComPic:: copyUpsampledPictureYuv(TComPicYuv* pcPicYuvIn, TComPicYuv* pcPicYuvOut) +Void TComPic::copyUpsampledPictureYuv(TComPicYuv* pcPicYuvIn, TComPicYuv* pcPicYuvOut) { Int upsampledRowWidthLuma = pcPicYuvOut->getStride(); // 2 * pcPicYuvOut->getLumaMargin() + pcPicYuvOut->getWidth(); @@ -585,44 +562,7 @@ #if REF_IDX_MFM -#if !REUSE_BLKMAPPING -Void TComPic::deriveUnitIdxBase( UInt upsamplePelX, UInt upsamplePelY, UInt ratio, UInt& baseCUAddr, UInt& baseAbsPartIdx ) -{ - //pixel in the base layer - - UInt pelX = (upsamplePelX<<1)/ratio; - UInt pelY = (upsamplePelY<<1)/ratio; - UInt baseWidth = getPicYuvRec()->getWidth(); - UInt baseHeight = getPicYuvRec()->getHeight(); - - UInt widthInCU = ( baseWidth % g_uiMaxCUWidth ) ? baseWidth /g_uiMaxCUWidth + 1 : baseWidth /g_uiMaxCUWidth; - -#if MFM_CLIPPING_FIX - pelX = (UInt)Clip3(0, getPicYuvRec()->getWidth() - 1, pelX); - pelY = (UInt)Clip3(0, getPicYuvRec()->getHeight() - 1, pelY); -#else - UInt heightInCU = ( baseHeight% g_uiMaxCUHeight ) ? baseHeight/ g_uiMaxCUHeight + 1 : baseHeight/ g_uiMaxCUHeight; - - pelX = (UInt)Clip3(0, widthInCU * g_uiMaxCUWidth - 1, pelX); - pelY = (UInt)Clip3(0, heightInCU * g_uiMaxCUHeight - 1, pelY); -#endif - - baseCUAddr = pelY / g_uiMaxCUHeight * widthInCU + pelX / g_uiMaxCUWidth; - - UInt widthMinPU = g_uiMaxCUWidth / (1<getConformanceWindow(); const Window &confEL = getPicYuvRec()->getConformanceWindow(); @@ -633,24 +573,4 @@ Int widthEL = getPicYuvRec()->getWidth() - confEL.getWindowLeftOffset() - confEL.getWindowRightOffset(); Int heightEL = getPicYuvRec()->getHeight() - confEL.getWindowTopOffset() - confEL.getWindowBottomOffset(); -#endif - -#if !REUSE_MVSCALE || !REUSE_BLKMAPPING - UInt upSampleRatio = 0; - if(widthEL == widthBL && heightEL == heightBL) - { - upSampleRatio = 2; - } - else if(2*widthEL == 3*widthBL && 2*heightEL == 3*heightBL) - { - upSampleRatio = 3; - } - else if(widthEL == 2*widthBL && heightEL == 2*heightBL) - { - upSampleRatio = 4; - } - else - { - assert(0); - } #endif @@ -671,49 +591,21 @@ UInt baseCUAddr, baseAbsPartIdx; -#if REUSE_BLKMAPPING TComDataCU *pcColCU = 0; pcColCU = pcCUDes->getBaseColCU(pelX + 8, pelY + 8, baseCUAddr, baseAbsPartIdx); -#else - pcPicBase->deriveUnitIdxBase(pelX + 8, pelY + 8, upSampleRatio, baseCUAddr, baseAbsPartIdx); -#endif - -#if AVC_SYNTAX + +#if AVC_SYNTAX && !ILP_DECODED_PICTURE Int xBL = ( (pelX + 8) * widthBL + widthEL/2 ) / widthEL; Int yBL = ( (pelY + 8) * heightBL+ heightEL/2 ) / heightEL; -#if REUSE_BLKMAPPING if( ( xBL < widthBL && yBL < heightBL ) && pcColCU && (pcColCU->getPredictionMode(baseAbsPartIdx) != MODE_NONE) && (pcColCU->getPredictionMode(baseAbsPartIdx) != MODE_INTRA) ) //base layer unit not skip and invalid mode #else - if( ( xBL < widthBL && yBL < heightBL ) && (pcPicBase->getCU(baseCUAddr)->getPredictionMode(baseAbsPartIdx) != MODE_NONE) && (pcPicBase->getCU(baseCUAddr)->getPredictionMode(baseAbsPartIdx) != MODE_INTRA) ) //base layer unit not skip and invalid mode -#endif -#else -#if REUSE_BLKMAPPING if( pcColCU && (pcColCU->getPredictionMode(baseAbsPartIdx) != MODE_NONE) && (pcColCU->getPredictionMode(baseAbsPartIdx) != MODE_INTRA) ) //base layer unit not skip and invalid mode -#else - if( (pcPicBase->getCU(baseCUAddr)->getPredictionMode(baseAbsPartIdx) != MODE_NONE) && (pcPicBase->getCU(baseCUAddr)->getPredictionMode(baseAbsPartIdx) != MODE_INTRA) ) //base layer unit not skip and invalid mode -#endif #endif { for(UInt refPicList = 0; refPicList < 2; refPicList++) //for each reference list { -#if REUSE_MVSCALE TComMvField sMvFieldBase, sMvField; -#if REUSE_BLKMAPPING pcColCU->getMvField( pcColCU, baseAbsPartIdx, (RefPicList)refPicList, sMvFieldBase); -#else - pcPicBase->getCU(baseCUAddr)->getMvField( pcPicBase->getCU(baseCUAddr), baseAbsPartIdx, (RefPicList)refPicList, sMvFieldBase); -#endif pcCUDes->scaleBaseMV( sMvField, sMvFieldBase ); -#else - TComMv cMv = pcPicBase->getCU(baseCUAddr)->getCUMvField((RefPicList)refPicList)->getMv(baseAbsPartIdx); - Int refIdx = pcPicBase->getCU(baseCUAddr)->getCUMvField((RefPicList)refPicList)->getRefIdx(baseAbsPartIdx); - - Int hor = ((Int)upSampleRatio * cMv.getHor())/2 ; - Int ver = ((Int)upSampleRatio * cMv.getVer())/2 ; - - TComMv cScaledMv(hor, ver); - TComMvField sMvField; - sMvField.setMvField(cScaledMv, refIdx); -#endif pcCUDes->getCUMvField((RefPicList)refPicList)->setMvField(sMvField, absPartIdx); @@ -739,7 +631,5 @@ } } -#endif - -#if RAP_MFM_INIT + Void TComPic::initUpsampledMvField() { @@ -774,7 +664,12 @@ } +#if ILP_DECODED_PICTURE + UInt width = this->getPicYuvRec()->getWidth(); + UInt height = this->getPicYuvRec()->getHeight(); +#else const Window &conf = this->getPicYuvRec()->getConformanceWindow(); UInt width = this->getPicYuvRec()->getWidth() - conf.getWindowLeftOffset() - conf.getWindowRightOffset(); UInt height = this->getPicYuvRec()->getHeight() - conf.getWindowTopOffset() - conf.getWindowBottomOffset(); +#endif UInt64 poc = (UInt64)this->getPOC(); UInt partWidth = width / 4; @@ -853,7 +748,12 @@ } +#if ILP_DECODED_PICTURE + UInt width = this->getPicYuvRec()->getWidth(); + UInt height = this->getPicYuvRec()->getHeight(); +#else const Window &conf = this->getConformanceWindow(); UInt width = this->getPicYuvRec()->getWidth() - conf.getWindowLeftOffset() - conf.getWindowRightOffset(); UInt height = this->getPicYuvRec()->getHeight() - conf.getWindowTopOffset() - conf.getWindowBottomOffset(); +#endif UInt64 poc = (UInt64)this->getPOC(); Index: /trunk/source/Lib/TLibCommon/TComPic.h =================================================================== --- /trunk/source/Lib/TLibCommon/TComPic.h (revision 188) +++ /trunk/source/Lib/TLibCommon/TComPic.h (revision 189) @@ -103,8 +103,4 @@ Void create( Int iWidth, Int iHeight, UInt uiMaxWidth, UInt uiMaxHeight, UInt uiMaxDepth, Window &conformanceWindow, Window &defaultDisplayWindow, Int *numReorderPics, TComSPS* pcSps = NULL, Bool bIsVirtual = false ); -#if REF_IDX_FRAMEWORK - Void createWithOutYuv( Int iWidth, Int iHeight, UInt uiMaxWidth, UInt uiMaxHeight, UInt uiMaxDepth, TComSPS* pcSps = NULL, Bool bIsVirtual = false ); - Void setPicYuvRec(TComPicYuv *pPicYuv) { m_apcPicYuv[1]=pPicYuv; } -#endif #else Void create( Int iWidth, Int iHeight, UInt uiMaxWidth, UInt uiMaxHeight, UInt uiMaxDepth, Window &conformanceWindow, Window &defaultDisplayWindow, @@ -124,15 +120,10 @@ #endif #if REF_IDX_ME_ZEROMV || ENCODER_FAST_MODE || REF_IDX_MFM - Bool isILR( UInt refLayer = 0 ) {return (getIsLongTerm() && m_layerId == refLayer);} + Bool isILR( UInt currLayerId ) { return ( getIsLongTerm() && m_layerId < currLayerId ); } #endif #if REF_IDX_MFM Void copyUpsampledMvField ( TComPic* pcPicBase ); -#if !REUSE_BLKMAPPING - Void deriveUnitIdxBase ( UInt upsamplePelX, UInt upsamplePelY, UInt ratio, UInt& baseCUAddr, UInt& baseAbsPartIdx ); -#endif -#if RAP_MFM_INIT Void initUpsampledMvField (); -#endif #endif Index: /trunk/source/Lib/TLibCommon/TComPicYuv.cpp =================================================================== --- /trunk/source/Lib/TLibCommon/TComPicYuv.cpp (revision 188) +++ /trunk/source/Lib/TLibCommon/TComPicYuv.cpp (revision 189) @@ -60,4 +60,5 @@ m_piPicOrgU = NULL; m_piPicOrgV = NULL; + m_bIsBorderExtended = false; } Index: /trunk/source/Lib/TLibCommon/TComPrediction.cpp =================================================================== --- /trunk/source/Lib/TLibCommon/TComPrediction.cpp (revision 188) +++ /trunk/source/Lib/TLibCommon/TComPrediction.cpp (revision 189) @@ -83,6 +83,6 @@ if( m_piYuvExt == NULL ) { - Int extWidth = g_uiMaxCUWidth + 16; - Int extHeight = g_uiMaxCUHeight + 1; + Int extWidth = MAX_CU_SIZE + 16; + Int extHeight = MAX_CU_SIZE + 1; Int i, j; for (i = 0; i < 4; i++) @@ -94,18 +94,18 @@ } } - m_iYuvExtHeight = ((g_uiMaxCUHeight + 2) << 4); - m_iYuvExtStride = ((g_uiMaxCUWidth + 8) << 4); + m_iYuvExtHeight = ((MAX_CU_SIZE + 2) << 4); + m_iYuvExtStride = ((MAX_CU_SIZE + 8) << 4); m_piYuvExt = new Int[ m_iYuvExtStride * m_iYuvExtHeight ]; // new structure - m_acYuvPred[0] .create( g_uiMaxCUWidth, g_uiMaxCUHeight ); - m_acYuvPred[1] .create( g_uiMaxCUWidth, g_uiMaxCUHeight ); - - m_cYuvPredTemp.create( g_uiMaxCUWidth, g_uiMaxCUHeight ); - } - - if (m_iLumaRecStride != (g_uiMaxCUWidth>>1) + 1) - { - m_iLumaRecStride = (g_uiMaxCUWidth>>1) + 1; + m_acYuvPred[0] .create( MAX_CU_SIZE, MAX_CU_SIZE ); + m_acYuvPred[1] .create( MAX_CU_SIZE, MAX_CU_SIZE ); + + m_cYuvPredTemp.create( MAX_CU_SIZE, MAX_CU_SIZE ); + } + + if (m_iLumaRecStride != (MAX_CU_SIZE>>1) + 1) + { + m_iLumaRecStride = (MAX_CU_SIZE>>1) + 1; if (!m_pLumaRecBuffer) { @@ -495,5 +495,5 @@ #if REF_IDX_ME_ZEROMV - assert( ( pcCU->getSlice()->getRefPic(eRefPicList, iRefIdx)->isILR() && cMv.getHor() == 0 && cMv.getVer() == 0 ) || pcCU->getSlice()->getRefPic(eRefPicList, iRefIdx)->isILR() == false ); + assert( ( pcCU->getSlice()->getRefPic(eRefPicList, iRefIdx)->isILR(pcCU->getLayerId()) && cMv.getHor() == 0 && cMv.getVer() == 0 ) || pcCU->getSlice()->getRefPic(eRefPicList, iRefIdx)->isILR(pcCU->getLayerId()) == false ); #endif @@ -773,8 +773,15 @@ #if SVC_UPSAMPLING +#if SCALED_REF_LAYER_OFFSETS +Void TComPrediction::upsampleBasePic( TComPicYuv* pcUsPic, TComPicYuv* pcBasePic, TComPicYuv* pcTempPic, const Window window) +{ + m_cUsf.upsampleBasePic( pcUsPic, pcBasePic, pcTempPic, window); +} +#else Void TComPrediction::upsampleBasePic( TComPicYuv* pcUsPic, TComPicYuv* pcBasePic, TComPicYuv* pcTempPic) { m_cUsf.upsampleBasePic( pcUsPic, pcBasePic, pcTempPic); } +#endif #endif //! \} Index: /trunk/source/Lib/TLibCommon/TComPrediction.h =================================================================== --- /trunk/source/Lib/TLibCommon/TComPrediction.h (revision 188) +++ /trunk/source/Lib/TLibCommon/TComPrediction.h (revision 189) @@ -122,5 +122,9 @@ #if SVC_UPSAMPLING +#if SCALED_REF_LAYER_OFFSETS + Void upsampleBasePic( TComPicYuv* pcUsPic, TComPicYuv* pcBasePic, TComPicYuv* pcTempPic, const Window window ); +#else Void upsampleBasePic( TComPicYuv* pcUsPic, TComPicYuv* pcBasePic, TComPicYuv* pcTempPic ); +#endif #endif }; Index: /trunk/source/Lib/TLibCommon/TComRom.cpp =================================================================== --- /trunk/source/Lib/TLibCommon/TComRom.cpp (revision 188) +++ /trunk/source/Lib/TLibCommon/TComRom.cpp (revision 189) @@ -62,5 +62,4 @@ g_aucConvertToBit[ i ] = c; - // g_auiFrameScanXY[ g_aucConvertToBit[ transformSize ] ]: zigzag scan array for transformSize c=2; for ( i=0; i& rcListPic) +Void TComSlice::sortPicList(TComList& rcListPic) { TComPic* pcPicExtract; @@ -268,16 +293,30 @@ -TComPic* TComSlice::xGetLongTermRefPic (TComList& rcListPic, - Int poc) +TComPic* TComSlice::xGetLongTermRefPic(TComList& rcListPic, Int poc, Bool pocHasMsb) { TComList::iterator iterPic = rcListPic.begin(); TComPic* pcPic = *(iterPic); TComPic* pcStPic = pcPic; + + Int pocCycle = 1 << getSPS()->getBitsForPOC(); + if (!pocHasMsb) + { + poc = poc % pocCycle; + } + while ( iterPic != rcListPic.end() ) { pcPic = *(iterPic); - if(pcPic && (pcPic->getPOC()%(1<getBitsForPOC())) == (poc%(1<getBitsForPOC()))) - { - if(pcPic->getIsLongTerm()) + if (pcPic && pcPic->getPOC()!=this->getPOC() && pcPic->getSlice( 0 )->isReferenced()) + { + Int picPoc = pcPic->getPOC(); + if (!pocHasMsb) + { + picPoc = picPoc % pocCycle; + } + + if (poc == picPoc) + { + if (pcPic->getIsLongTerm()) { return pcPic; @@ -289,11 +328,13 @@ break; } + } iterPic++; } + return pcStPic; } -Void TComSlice::setRefPOCList () +Void TComSlice::setRefPOCList() { for (Int iDir = 0; iDir < 2; iDir++) @@ -307,4 +348,22 @@ } +#if L0034_COMBINED_LIST_CLEANUP +Void TComSlice::setList1IdxToList0Idx() +{ + Int idxL0, idxL1; + for ( idxL1 = 0; idxL1 < getNumRefIdx( REF_PIC_LIST_1 ); idxL1++ ) + { + m_list1IdxToList0Idx[idxL1] = -1; + for ( idxL0 = 0; idxL0 < getNumRefIdx( REF_PIC_LIST_0 ); idxL0++ ) + { + if ( m_apcRefPicList[REF_PIC_LIST_0][idxL0]->getPOC() == m_apcRefPicList[REF_PIC_LIST_1][idxL1]->getPOC() ) + { + m_list1IdxToList0Idx[idxL1] = idxL0; + break; + } + } + } +} +#else Void TComSlice::generateCombinedList() { @@ -369,23 +428,26 @@ } } - -Void TComSlice::setRefPicList( TComList& rcListPic) -{ -#if REF_IDX_FRAMEWORK - if( m_eSliceType == I_SLICE || ( getSPS()->getLayerId() && - (getNalUnitType() >= NAL_UNIT_CODED_SLICE_BLA) && - (getNalUnitType() <= NAL_UNIT_CODED_SLICE_CRA) ) ) -#else - if (m_eSliceType == I_SLICE) -#endif - { - ::memset( m_apcRefPicList, 0, sizeof (m_apcRefPicList)); - ::memset( m_aiNumRefIdx, 0, sizeof ( m_aiNumRefIdx )); - - return; - } +#endif + +#if FIX1071 +Void TComSlice::setRefPicList( TComList& rcListPic, Bool checkNumPocTotalCurr, TComPic** ilpPic) +#else +Void TComSlice::setRefPicList( TComList& rcListPic ) +#endif +{ +#if FIX1071 + if (!checkNumPocTotalCurr) +#endif + { + if( m_eSliceType == I_SLICE ) + { + ::memset( m_apcRefPicList, 0, sizeof (m_apcRefPicList)); + ::memset( m_aiNumRefIdx, 0, sizeof ( m_aiNumRefIdx )); + return; + } - m_aiNumRefIdx[0] = getNumRefIdx(REF_PIC_LIST_0); - m_aiNumRefIdx[1] = getNumRefIdx(REF_PIC_LIST_1); + m_aiNumRefIdx[0] = getNumRefIdx(REF_PIC_LIST_0); + m_aiNumRefIdx[1] = getNumRefIdx(REF_PIC_LIST_1); + } TComPic* pcRefPic= NULL; @@ -398,4 +460,15 @@ Int i; +#if REF_IDX_FRAMEWORK +#if ZERO_NUM_DIRECT_LAYERS + if( m_layerId == 0 || ( m_layerId > 0 && ( m_activeNumILRRefIdx == 0 || !((getNalUnitType() >= NAL_UNIT_CODED_SLICE_BLA_W_LP) && (getNalUnitType() <= NAL_UNIT_CODED_SLICE_CRA)) ) ) ) +#else + if ((getLayerId() == 0) || + ((getSPS()->getLayerId()) && !((getNalUnitType() >= NAL_UNIT_CODED_SLICE_BLA_W_LP) && + (getNalUnitType() <= NAL_UNIT_CODED_SLICE_CRA)) ) + ) +#endif + { +#endif for(i=0; i < m_pcRPS->getNumberOfNegativePictures(); i++) { @@ -410,4 +483,5 @@ } } + for(; i < m_pcRPS->getNumberOfNegativePictures()+m_pcRPS->getNumberOfPositivePictures(); i++) { @@ -422,9 +496,10 @@ } } + for(i = m_pcRPS->getNumberOfNegativePictures()+m_pcRPS->getNumberOfPositivePictures()+m_pcRPS->getNumberOfLongtermPictures()-1; i > m_pcRPS->getNumberOfNegativePictures()+m_pcRPS->getNumberOfPositivePictures()-1 ; i--) { if(m_pcRPS->getUsed(i)) { - pcRefPic = xGetLongTermRefPic(rcListPic, m_pcRPS->getPOC(i)); + pcRefPic = xGetLongTermRefPic(rcListPic, m_pcRPS->getPOC(i), m_pcRPS->getCheckLTMSBPresent(i)); pcRefPic->setIsLongTerm(1); pcRefPic->getPicYuvRec()->extendPicBorder(); @@ -434,15 +509,71 @@ if(pcRefPic==NULL) { - pcRefPic = xGetLongTermRefPic(rcListPic, m_pcRPS->getPOC(i)); + pcRefPic = xGetLongTermRefPic(rcListPic, m_pcRPS->getPOC(i), m_pcRPS->getCheckLTMSBPresent(i)); } pcRefPic->setCheckLTMSBPresent(m_pcRPS->getCheckLTMSBPresent(i)); } - +#if REF_IDX_FRAMEWORK + } +#endif + +#if REF_IDX_FRAMEWORK + //inter-layer reference picture +#if REF_IDX_MFM +#if ZERO_NUM_DIRECT_LAYERS + if( m_layerId > 0 && m_activeNumILRRefIdx > 0 ) +#else + if (getLayerId()) +#endif + { + if(!(getNalUnitType() >= NAL_UNIT_CODED_SLICE_BLA_W_LP && getNalUnitType() <= NAL_UNIT_CODED_SLICE_CRA) && getSPS()->getMFMEnabledFlag()) + { + ilpPic[0]->copyUpsampledMvField(getBaseColPic()); + } + else + { + ilpPic[0]->initUpsampledMvField(); + } + #endif + ilpPic[0]->setIsLongTerm(1); + } +#endif // ref_pic_list_init TComPic* rpsCurrList0[MAX_NUM_REF+1]; TComPic* rpsCurrList1[MAX_NUM_REF+1]; +#if REF_IDX_FRAMEWORK +#if JCTVC_M0458_INTERLAYER_RPS_SIG + Int numPocTotalCurr = NumPocStCurr0 + NumPocStCurr1 + NumPocLtCurr + m_activeNumILRRefIdx; +#else + Int numPocTotalCurr = NumPocStCurr0 + NumPocStCurr1 + NumPocLtCurr + m_numILRRefIdx; +#endif +#else Int numPocTotalCurr = NumPocStCurr0 + NumPocStCurr1 + NumPocLtCurr; - - { +#endif +#if FIX1071 + if (checkNumPocTotalCurr) + { + // 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: + // – If the current picture is a BLA or CRA picture, the value of NumPocTotalCurr shall be equal to 0. + // – Otherwise, when the current picture contains a P or B slice, the value of NumPocTotalCurr shall not be equal to 0. + if (getRapPicFlag()) + { + assert(numPocTotalCurr == 0); + } + + if (m_eSliceType == I_SLICE) + { + ::memset( m_apcRefPicList, 0, sizeof (m_apcRefPicList)); + ::memset( m_aiNumRefIdx, 0, sizeof ( m_aiNumRefIdx )); + + return; + } + + assert(numPocTotalCurr != 0); + + m_aiNumRefIdx[0] = getNumRefIdx(REF_PIC_LIST_0); + m_aiNumRefIdx[1] = getNumRefIdx(REF_PIC_LIST_1); + } +#endif + Int cIdx = 0; for ( i=0; igetNalUnitType() >= NAL_UNIT_CODED_SLICE_BLA && this->getNalUnitType() <= NAL_UNIT_CODED_SLICE_CRA) + if(this->getNalUnitType() >= NAL_UNIT_CODED_SLICE_BLA_W_LP && this->getNalUnitType() <= NAL_UNIT_CODED_SLICE_CRA) + { return; + } TComRefPicListModification* refPicListModification = this->getRefPicListModification(); @@ -537,5 +694,9 @@ else { - for(Int i = m_aiNumILRRefIdx; i > 0; i-- ) +#if JCTVC_M0458_INTERLAYER_RPS_SIG + for(Int i = m_activeNumILRRefIdx; i > 0; i-- ) +#else + for(Int i = m_numILRRefIdx; i > 0; i-- ) +#endif { refPicListModification->setRefPicSetIdxL0(m_aiNumRefIdx[REF_PIC_LIST_0] - i, numberOfRpsCurrTempList - i); @@ -563,5 +724,9 @@ else { - for(Int i = m_aiNumILRRefIdx; i > 0; i-- ) +#if JCTVC_M0458_INTERLAYER_RPS_SIG + for(Int i = m_activeNumILRRefIdx; i > 0; i-- ) +#else + for(Int i = m_numILRRefIdx; i > 0; i-- ) +#endif { refPicListModification->setRefPicSetIdxL1(m_aiNumRefIdx[REF_PIC_LIST_1] - i, numberOfRpsCurrTempList - i); @@ -569,149 +734,4 @@ } } - return; -} - -Void TComSlice::setRefPicListSvc( TComList& rcListPic, TComPic** ilpPic ) -{ - assert(getLayerId() > 0); - - m_aiNumRefIdx[0] = getNumRefIdx(REF_PIC_LIST_0); - m_aiNumRefIdx[1] = getNumRefIdx(REF_PIC_LIST_1); - - TComPic* pcRefPic= NULL; - TComPic* RefPicSetStCurr0[16]; - TComPic* RefPicSetStCurr1[16]; - TComPic* RefPicSetLtCurr[16]; - UInt NumPocStCurr0 = 0; - UInt NumPocStCurr1 = 0; - UInt NumPocLtCurr = 0; - Int i; - - //temporal reference pictures - if( !(getNalUnitType() >= NAL_UNIT_CODED_SLICE_BLA && getNalUnitType() <= NAL_UNIT_CODED_SLICE_CRA) ) - { - for(i=0; i < m_pcRPS->getNumberOfNegativePictures(); i++) - { - if(m_pcRPS->getUsed(i)) - { - pcRefPic = xGetRefPic(rcListPic, getPOC()+m_pcRPS->getDeltaPOC(i)); - pcRefPic->setIsLongTerm(0); - pcRefPic->getPicYuvRec()->extendPicBorder(); - RefPicSetStCurr0[NumPocStCurr0] = pcRefPic; - NumPocStCurr0++; - pcRefPic->setCheckLTMSBPresent(false); - } - } - for(; i < m_pcRPS->getNumberOfNegativePictures()+m_pcRPS->getNumberOfPositivePictures(); i++) - { - if(m_pcRPS->getUsed(i)) - { - pcRefPic = xGetRefPic(rcListPic, getPOC()+m_pcRPS->getDeltaPOC(i)); - pcRefPic->setIsLongTerm(0); - pcRefPic->getPicYuvRec()->extendPicBorder(); - RefPicSetStCurr1[NumPocStCurr1] = pcRefPic; - NumPocStCurr1++; - pcRefPic->setCheckLTMSBPresent(false); - } - } - for(i = m_pcRPS->getNumberOfNegativePictures()+m_pcRPS->getNumberOfPositivePictures()+m_pcRPS->getNumberOfLongtermPictures()-1; i > m_pcRPS->getNumberOfNegativePictures()+m_pcRPS->getNumberOfPositivePictures()-1 ; i--) - { - if(m_pcRPS->getUsed(i)) - { - pcRefPic = xGetLongTermRefPic(rcListPic, m_pcRPS->getPOC(i)); - pcRefPic->setIsLongTerm(1); - pcRefPic->getPicYuvRec()->extendPicBorder(); - RefPicSetLtCurr[NumPocLtCurr] = pcRefPic; - NumPocLtCurr++; - } - if(pcRefPic==NULL) - { - pcRefPic = xGetLongTermRefPic(rcListPic, m_pcRPS->getPOC(i)); - } - pcRefPic->setCheckLTMSBPresent(m_pcRPS->getCheckLTMSBPresent(i)); - } - } - - //inter-layer reference picture -#if REF_IDX_MFM - assert(m_aiNumILRRefIdx == 1); - if(!(getNalUnitType() >= NAL_UNIT_CODED_SLICE_BLA && getNalUnitType() <= NAL_UNIT_CODED_SLICE_CRA) && getSPS()->getMFMEnabledFlag()) - { - ilpPic[0]->copyUpsampledMvField(getBaseColPic()); - } - else - { - ilpPic[0]->initUpsampledMvField(); - } -#endif - ilpPic[0]->setIsLongTerm(1); - - // ref_pic_list_init - UInt cIdx = 0; - UInt num_ref_idx_l0_active_minus1 = m_aiNumRefIdx[0] - 1; - UInt num_ref_idx_l1_active_minus1 = m_aiNumRefIdx[1] - 1; - TComPic* refPicListTemp0[MAX_NUM_REF+1]; - TComPic* refPicListTemp1[MAX_NUM_REF+1]; - Int numRpsCurrTempList0, numRpsCurrTempList1; - - numRpsCurrTempList0 = numRpsCurrTempList1 = NumPocStCurr0 + NumPocStCurr1 + NumPocLtCurr + m_aiNumILRRefIdx; - if (numRpsCurrTempList0 <= num_ref_idx_l0_active_minus1) - { - numRpsCurrTempList0 = num_ref_idx_l0_active_minus1 + 1; - } - if (numRpsCurrTempList1 <= num_ref_idx_l1_active_minus1) - { - numRpsCurrTempList1 = num_ref_idx_l1_active_minus1 + 1; - } - - assert(numRpsCurrTempList0 <= MAX_NUM_REF); - assert(numRpsCurrTempList1 <= MAX_NUM_REF); - - cIdx = 0; - while (cIdx < numRpsCurrTempList0) - { - for ( i=0; i= (NumPocStCurr0 + NumPocStCurr1)) - : ((rIdx % numRpsCurrTempList0) >= (NumPocStCurr0 + NumPocStCurr1)); - } - if ( m_eSliceType == P_SLICE ) - { - m_aiNumRefIdx[1] = 0; - ::memset( m_apcRefPicList[1], 0, sizeof(m_apcRefPicList[1])); - } - else - { - for (Int rIdx = 0; rIdx <= (m_aiNumRefIdx[1]-1); rIdx ++) - { - m_apcRefPicList[1][rIdx] = m_RefPicListModification.getRefPicListModificationFlagL1() ? refPicListTemp1[ m_RefPicListModification.getRefPicSetIdxL1(rIdx) ] : refPicListTemp1[rIdx % numRpsCurrTempList1]; - m_bIsUsedAsLongTerm[1][rIdx] = m_RefPicListModification.getRefPicListModificationFlagL1() ? - (m_RefPicListModification.getRefPicSetIdxL1(rIdx) >= (NumPocStCurr0 + NumPocStCurr1)): ((rIdx % numRpsCurrTempList1) >= (NumPocStCurr0 + NumPocStCurr1)); - } - } - return; } @@ -724,5 +744,5 @@ #if REF_IDX_FRAMEWORK if( m_eSliceType == I_SLICE || ( getSPS()->getLayerId() && - (getNalUnitType() >= NAL_UNIT_CODED_SLICE_BLA) && + (getNalUnitType() >= NAL_UNIT_CODED_SLICE_BLA_W_LP) && (getNalUnitType() <= NAL_UNIT_CODED_SLICE_CRA) ) ) #else @@ -730,6 +750,10 @@ #endif { -#if REF_LIST_BUGFIX - return m_aiNumILRRefIdx; +#if REF_IDX_FRAMEWORK +#if JCTVC_M0458_INTERLAYER_RPS_SIG + return m_activeNumILRRefIdx; +#else + return getNumILRRefIdx(); +#endif #else return 0; @@ -743,8 +767,12 @@ } } -#if REF_LIST_BUGFIX +#if REF_IDX_FRAMEWORK if(getLayerId()) { +#if JCTVC_M0458_INTERLAYER_RPS_SIG + numRpsCurrTempList += m_activeNumILRRefIdx; +#else numRpsCurrTempList += getNumILRRefIdx(); +#endif } #endif @@ -793,5 +821,5 @@ } -Void TComSlice::checkCRA(TComReferencePictureSet *pReferencePictureSet, Int& pocCRA, Bool& prevRAPisBLA) +Void TComSlice::checkCRA(TComReferencePictureSet *pReferencePictureSet, Int& pocCRA, Bool& prevRAPisBLA, TComList& rcListPic) { for(Int i = 0; i < pReferencePictureSet->getNumberOfNegativePictures()+pReferencePictureSet->getNumberOfPositivePictures(); i++) @@ -806,8 +834,15 @@ if(pocCRA < MAX_UINT && getPOC() > pocCRA) { + if (!pReferencePictureSet->getCheckLTMSBPresent(i)) + { + assert(xGetLongTermRefPic(rcListPic, pReferencePictureSet->getPOC(i), false)->getPOC() >= pocCRA); + } + else + { assert(pReferencePictureSet->getPOC(i) >= pocCRA); } } - if ( getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR || getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR_N_LP ) // IDR picture found + } + if ( getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR_W_RADL || getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR_N_LP ) // IDR picture found { pocCRA = getPOC(); @@ -819,6 +854,6 @@ prevRAPisBLA = false; } - else if ( getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA - || getNalUnitType() == NAL_UNIT_CODED_SLICE_BLANT + else if ( getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_W_LP + || getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_W_RADL || getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_N_LP ) // BLA picture found { @@ -851,8 +886,8 @@ Int pocCurr = getPOC(); - if ( getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA - || getNalUnitType() == NAL_UNIT_CODED_SLICE_BLANT + if ( getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_W_LP + || getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_W_RADL || getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_N_LP - || getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR + || getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR_W_RADL || getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR_N_LP ) // IDR or BLA picture { @@ -866,6 +901,6 @@ iterPic++; } - if ( getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA - || getNalUnitType() == NAL_UNIT_CODED_SLICE_BLANT + if ( getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_W_LP + || getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_W_RADL || getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_N_LP ) { @@ -881,5 +916,8 @@ { rpcPic = *(iterPic); - if (rpcPic->getPOC() != pocCurr && rpcPic->getPOC() != pocCRA) rpcPic->getSlice(0)->setReferenced(false); + if (rpcPic->getPOC() != pocCurr && rpcPic->getPOC() != pocCRA) + { + rpcPic->getSlice(0)->setReferenced(false); + } iterPic++; } @@ -912,9 +950,19 @@ m_deblockingFilterTcOffsetDiv2 = pSrc->m_deblockingFilterTcOffsetDiv2; +#if L0034_COMBINED_LIST_CLEANUP + for (i = 0; i < 2; i++) +#else for (i = 0; i < 3; i++) +#endif { m_aiNumRefIdx[i] = pSrc->m_aiNumRefIdx[i]; } +#if L0034_COMBINED_LIST_CLEANUP + for (i = 0; i < MAX_NUM_REF; i++) + { + m_list1IdxToList0Idx[i] = pSrc->m_list1IdxToList0Idx[i]; + } +#else for (i = 0; i < 2; i++) { @@ -933,4 +981,5 @@ m_bRefPicListModificationFlagLC = pSrc->m_bRefPicListModificationFlagLC; m_bRefPicListCombinationFlag = pSrc->m_bRefPicListCombinationFlag; +#endif m_bCheckLDC = pSrc->m_bCheckLDC; m_iSliceQpDelta = pSrc->m_iSliceQpDelta; @@ -958,4 +1007,15 @@ // access channel +#if SVC_EXTENSION + m_pcVPS = pSrc->m_pcVPS; +#if JCTVC_M0458_INTERLAYER_RPS_SIG + m_activeNumILRRefIdx = pSrc->m_activeNumILRRefIdx; + m_interLayerPredEnabledFlag = pSrc->m_interLayerPredEnabledFlag; + m_numInterLayerRefPics = pSrc->m_numInterLayerRefPics; + memcpy( m_interLayerPredLayerIdc, pSrc->m_interLayerPredLayerIdc, sizeof( m_interLayerPredLayerIdc ) ); +#elif REF_IDX_FRAMEWORK + m_numILRRefIdx = pSrc->m_numILRRefIdx; +#endif +#endif m_pcSPS = pSrc->m_pcSPS; m_pcPPS = pSrc->m_pcPPS; @@ -984,5 +1044,7 @@ } +#if !L0034_COMBINED_LIST_CLEANUP m_bNoBackPredFlag = pSrc->m_bNoBackPredFlag; +#endif m_uiTLayer = pSrc->m_uiTLayer; m_bTLayerSwitchingFlag = pSrc->m_bTLayerSwitchingFlag; @@ -1018,4 +1080,5 @@ Int TComSlice::m_prevPOC = 0; + /** Function for setting the slice's temporal layer ID and corresponding temporal_layer_switching_point_flag. * \param uiTLayer Temporal layer ID of the current slice @@ -1078,11 +1141,14 @@ Int i, isReference; - Int j = 0; // loop through all pictures in the reference picture buffer TComList::iterator iterPic = rcListPic.begin(); while ( iterPic != rcListPic.end()) { - j++; rpcPic = *(iterPic++); + + if(!rpcPic->getSlice( 0 )->isReferenced()) + { + continue; + } isReference = 0; @@ -1123,4 +1189,5 @@ { rpcPic->getSlice( 0 )->setReferenced( false ); + rpcPic->setUsedByCurr(0); rpcPic->setIsLongTerm(0); } @@ -1128,5 +1195,5 @@ assert(rpcPic->getSlice( 0 )->isReferenced()==0||rpcPic->getUsedByCurr()==0||rpcPic->getTLayer()<=this->getTLayer()); //check that pictures of higher or equal temporal layer are not in the RPS if the current picture is a TSA picture - if(this->getNalUnitType() == NAL_UNIT_CODED_SLICE_TLA || this->getNalUnitType() == NAL_UNIT_CODED_SLICE_TSA_N) + if(this->getNalUnitType() == NAL_UNIT_CODED_SLICE_TLA_R || this->getNalUnitType() == NAL_UNIT_CODED_SLICE_TSA_N) { assert(rpcPic->getSlice( 0 )->isReferenced()==0||rpcPic->getTLayer()getTLayer()); @@ -1145,5 +1212,5 @@ { TComPic* rpcPic; - Int i, isAvailable, j; + Int i, isAvailable; Int atLeastOneLost = 0; Int atLeastOneRemoved = 0; @@ -1154,5 +1221,4 @@ for(i=pReferencePictureSet->getNumberOfNegativePictures()+pReferencePictureSet->getNumberOfPositivePictures();igetNumberOfPictures();i++) { - j = 0; isAvailable = 0; // loop through all pictures in the reference picture buffer @@ -1160,5 +1226,4 @@ while ( iterPic != rcListPic.end()) { - j++; rpcPic = *(iterPic++); if(pReferencePictureSet->getCheckLTMSBPresent(i)==true) @@ -1183,8 +1248,16 @@ while ( iterPic != rcListPic.end()) { - j++; rpcPic = *(iterPic++); - if((rpcPic->getPicSym()->getSlice(0)->getPOC()%(1<getPicSym()->getSlice(0)->getSPS()->getBitsForPOC())) == (this->getPOC() + pReferencePictureSet->getDeltaPOC(i))%(1<getPicSym()->getSlice(0)->getSPS()->getBitsForPOC()) && rpcPic->getSlice(0)->isReferenced()) + Int pocCycle = 1 << rpcPic->getPicSym()->getSlice(0)->getSPS()->getBitsForPOC(); + Int curPoc = rpcPic->getPicSym()->getSlice(0)->getPOC(); + Int refPoc = pReferencePictureSet->getPOC(i); + if (!pReferencePictureSet->getCheckLTMSBPresent(i)) + { + curPoc = curPoc % pocCycle; + refPoc = refPoc % pocCycle; + } + + if (rpcPic->getSlice(0)->isReferenced() && curPoc == refPoc) { isAvailable = 1; @@ -1224,5 +1297,4 @@ for(i=0;igetNumberOfNegativePictures()+pReferencePictureSet->getNumberOfPositivePictures();i++) { - j = 0; isAvailable = 0; // loop through all pictures in the reference picture buffer @@ -1230,5 +1302,4 @@ while ( iterPic != rcListPic.end()) { - j++; rpcPic = *(iterPic++); @@ -1247,5 +1318,7 @@ { if(printErrors) + { printf("\nShort-term reference picture with POC = %3d seems to have been removed or not correctly decoded.", this->getPOC() + pReferencePictureSet->getDeltaPOC(i)); + } atLeastOneRemoved = 1; } @@ -1253,5 +1326,7 @@ { if(printErrors) + { printf("\nShort-term reference picture with POC = %3d is lost or not correctly decoded!", this->getPOC() + pReferencePictureSet->getDeltaPOC(i)); + } atLeastOneLost = 1; iPocLost=this->getPOC() + pReferencePictureSet->getDeltaPOC(i); @@ -1399,5 +1474,5 @@ * \returns Void */ -Void TComSlice::resetWpScaling(wpScalingParam wp[2][MAX_NUM_REF][3]) +Void TComSlice::resetWpScaling() { for ( Int e=0 ; e<2 ; e++ ) @@ -1407,5 +1482,5 @@ for ( Int yuv=0 ; yuv<3 ; yuv++ ) { - wpScalingParam *pwp = &(wp[e][i][yuv]); + wpScalingParam *pwp = &(m_weightPredTable[e][i][yuv]); pwp->bPresentFlag = false; pwp->uiLog2WeightDenom = 0; @@ -1423,13 +1498,4 @@ Void TComSlice::initWpScaling() { - initWpScaling(m_weightPredTable); -} - -/** set WP tables - * \param wpScalingParam - * \returns Void - */ -Void TComSlice::initWpScaling(wpScalingParam wp[2][MAX_NUM_REF][3]) -{ for ( Int e=0 ; e<2 ; e++ ) { @@ -1438,6 +1504,7 @@ for ( Int yuv=0 ; yuv<3 ; yuv++ ) { - wpScalingParam *pwp = &(wp[e][i][yuv]); - if ( !pwp->bPresentFlag ) { + wpScalingParam *pwp = &(m_weightPredTable[e][i][yuv]); + if ( !pwp->bPresentFlag ) + { // Inferring values not present : pwp->iWeight = (1 << pwp->uiLog2WeightDenom); @@ -1477,10 +1544,19 @@ , m_numOutputLayerSets (0) #endif -{ - +#if VPS_PROFILE_OUTPUT_LAYERS +, m_numProfileTierLevel (0) +, m_moreOutputLayerSetsThanDefaultFlag (false) +, m_numAddOutputLayerSets (0) +, m_defaultOneTargetOutputLayerFlag (false) +#endif +{ for( Int i = 0; i < MAX_TLAYER; i++) { m_numReorderPics[i] = 0; +#if L0323_DPB + m_uiMaxDecPicBuffering[i] = 1; +#else m_uiMaxDecPicBuffering[i] = 0; +#endif m_uiMaxLatencyIncrease[i] = 0; } @@ -1512,13 +1588,46 @@ ::memset(m_refLayerId, 0, sizeof(m_refLayerId )); #endif +#if DERIVE_LAYER_ID_LIST_VARIABLES + ::memset(m_layerSetLayerIdList, 0, sizeof(m_layerSetLayerIdList)); + ::memset(m_numLayerInIdList, 0, sizeof(m_numLayerInIdList )); +#endif +#if VPS_PROFILE_OUTPUT_LAYERS + ::memset(m_profileLevelTierIdx, 0, sizeof(m_profileLevelTierIdx)); +#endif +#if JCTVC_M0458_INTERLAYER_RPS_SIG + m_maxOneActiveRefLayerFlag = true; +#endif } TComVPS::~TComVPS() { - if( m_hrdParameters != NULL ) delete m_hrdParameters; - if( m_hrdOpSetIdx != NULL ) delete m_hrdOpSetIdx; - if( m_cprmsPresentFlag != NULL ) delete m_cprmsPresentFlag; -} - + if( m_hrdParameters != NULL ) delete[] m_hrdParameters; + if( m_hrdOpSetIdx != NULL ) delete[] m_hrdOpSetIdx; + if( m_cprmsPresentFlag != NULL ) delete[] m_cprmsPresentFlag; +} +#if DERIVE_LAYER_ID_LIST_VARIABLES +Void TComVPS::deriveLayerIdListVariables() +{ + // For layer 0 + setNumLayersInIdList(0, 1); + setLayerSetLayerIdList(0, 0, 0); + + // For other layers + Int i, m, n; + for( i = 1; i <= getNumLayerSets() - 1; i++ ) + { + n = 0; + for( m = 0; m <= this->getMaxLayerId(); m++) + { + if(this->getLayerIdIncludedFlag(i, m)) + { + setLayerSetLayerIdList(i, n, m); + n++; + } + } + setNumLayersInIdList(i, n); + } +} +#endif // ------------------------------------------------------------------------------------------------ // Sequence parameter set (SPS) @@ -1533,9 +1642,9 @@ , m_picWidthInLumaSamples (352) , m_picHeightInLumaSamples (288) +, m_log2MinCodingBlockSize ( 0) +, m_log2DiffMaxMinCodingBlockSize (0) , m_uiMaxCUWidth ( 32) , m_uiMaxCUHeight ( 32) , m_uiMaxCUDepth ( 3) -, m_uiMinTrDepth ( 0) -, m_uiMaxTrDepth ( 1) , m_bLongTermRefsPresent (false) , m_uiQuadtreeTULog2MaxSize ( 0) @@ -1547,5 +1656,7 @@ , m_pcmLog2MaxSize ( 5) , m_uiPCMLog2MinSize ( 7) +#if !L0034_COMBINED_LIST_CLEANUP , m_bUseLComb (false) +#endif , m_bitDepthY ( 8) , m_bitDepthC ( 8) @@ -1572,5 +1683,9 @@ { m_uiMaxLatencyIncrease[i] = 0; +#if L0323_DPB + m_uiMaxDecPicBuffering[i] = 1; +#else m_uiMaxDecPicBuffering[i] = 0; +#endif m_numReorderPics[i] = 0; } @@ -1591,4 +1706,5 @@ m_RPSList.create(numRPS); } + Void TComSPS::setHrdParameters( UInt frameRate, UInt numDU, UInt bitRate, Bool randomAccess ) { @@ -1835,12 +1951,15 @@ return m_POC[bufferNum]; } + Void TComReferencePictureSet::setPOC(Int bufferNum, Int POC) { m_POC[bufferNum] = POC; } + Bool TComReferencePictureSet::getCheckLTMSBPresent(Int bufferNum) { return m_bCheckLTMSB[bufferNum]; } + Void TComReferencePictureSet::setCheckLTMSBPresent(Int bufferNum, Bool b) { @@ -2022,4 +2141,5 @@ return (defaultCounter == (SCALING_LIST_NUM * SCALING_LIST_SIZE_NUM - 4)) ? false : true; // -4 for 32x32 } + /** get scaling matrix from RefMatrixID * \param sizeId size index @@ -2031,4 +2151,5 @@ ::memcpy(getScalingListAddress(sizeId, listId),((listId == refListId)? getScalingListDefaultAddress(sizeId, refListId): getScalingListAddress(sizeId, refListId)),sizeof(Int)*min(MAX_MATRIX_COEF_NUM,(Int)g_scalingListSize[sizeId])); } + /** parse syntax infomation * \param pchFile syntax infomation @@ -2123,4 +2244,5 @@ m_scalingListCoef[SCALING_LIST_32x32][3] = m_scalingListCoef[SCALING_LIST_32x32][1]; // copy address for 32x32 } + /** destroy quantization matrix array */ @@ -2135,4 +2257,5 @@ } } + /** get default address of quantization matrix * \param sizeId size index @@ -2164,4 +2287,5 @@ return src; } + /** process of default matrix * \param sizeId size index @@ -2173,4 +2297,5 @@ setScalingListDC(sizeId,listId,SCALING_LIST_DC); } + /** check DC value of matrix for default matrix signaling */ @@ -2240,5 +2365,5 @@ //! activate a PPS and depending on isIDR parameter also SPS and VPS //! \returns true, if activation is successful -Bool ParameterSetManager::activatePPS(Int ppsId, Bool isIDR) +Bool ParameterSetManager::activatePPS(Int ppsId, Bool isIRAP) { TComPPS *pps = m_ppsMap.getPS(ppsId); @@ -2246,7 +2371,7 @@ { Int spsId = pps->getSPSId(); - if (!isIDR && (spsId != m_activeSPSId)) - { - printf("Warning: tried to activate PPS referring to a inactive SPS at non-IDR."); + if (!isIRAP && (spsId != m_activeSPSId)) + { + printf("Warning: tried to activate PPS referring to a inactive SPS at non-IRAP."); return false; } @@ -2255,7 +2380,7 @@ { Int vpsId = sps->getVPSId(); - if (!isIDR && (vpsId != m_activeVPSId)) - { - printf("Warning: tried to activate PPS referring to a inactive VPS at non-IDR."); + if (!isIRAP && (vpsId != m_activeVPSId)) + { + printf("Warning: tried to activate PPS referring to a inactive VPS at non-IRAP."); return false; } @@ -2345,5 +2470,5 @@ // Assumed that RPL of the base layer is same to the EL, otherwise this information should be also dumped and read from the metadata file setPOC( pcSlice->getPOC() ); - if( pcSlice->getNalUnitType() >= NAL_UNIT_CODED_SLICE_BLA && pcSlice->getNalUnitType() <= NAL_UNIT_CODED_SLICE_CRA ) + if( pcSlice->getNalUnitType() >= NAL_UNIT_CODED_SLICE_BLA_W_LP && pcSlice->getNalUnitType() <= NAL_UNIT_CODED_SLICE_CRA ) { setSliceType( I_SLICE ); @@ -2395,54 +2520,4 @@ #endif -#if REF_IDX_FRAMEWORK -Void TComSlice::addRefPicList( TComPic **pIlpPicList, Int iRefPicNum, Int iInsertOffset ) -{ - if(getSPS()->getLayerId() && m_eSliceType != I_SLICE) - { -#if REF_IDX_MFM - assert(iRefPicNum == 1); -#if RAP_MFM_INIT - if(!(getNalUnitType() >= NAL_UNIT_CODED_SLICE_BLA && getNalUnitType() <= NAL_UNIT_CODED_SLICE_CRA) && getSPS()->getMFMEnabledFlag()) -#else - if( getPOC() != 0 ) -#endif - { - pIlpPicList[0]->copyUpsampledMvField(getBaseColPic()); - } -#if RAP_MFM_INIT - else - { - pIlpPicList[0]->initUpsampledMvField(); - } -#endif -#endif - //add to list 0; - Int iOffset; - m_aiNumRefIdx[REF_PIC_LIST_0] += iInsertOffset; - iOffset = m_aiNumRefIdx[REF_PIC_LIST_0]; - for (Int i=0; isetIsLongTerm(1); //mark ilp as long-term reference - m_bIsUsedAsLongTerm[REF_PIC_LIST_0][iOffset + i] = 1; //mark ilp as long-term reference - m_apcRefPicList[REF_PIC_LIST_0][iOffset + i] = pIlpPicList[i]; - m_aiNumRefIdx[REF_PIC_LIST_0]++; - //m_aiNumRefIdx[REF_PIC_LIST_C]++; - } - if(m_eSliceType == B_SLICE) - { - m_aiNumRefIdx[REF_PIC_LIST_1] += iInsertOffset; - iOffset = m_aiNumRefIdx[REF_PIC_LIST_1]; - for (Int i=0; isetIsLongTerm(1); //mark ilp as long-term reference - m_bIsUsedAsLongTerm[REF_PIC_LIST_1][iOffset + i] = 1; //mark ilp as long-term reference - m_apcRefPicList[REF_PIC_LIST_1][iOffset + i] = pIlpPicList[i]; - m_aiNumRefIdx[REF_PIC_LIST_1]++; - //m_aiNumRefIdx[REF_PIC_LIST_C]++; - } - } - } -} - #if REF_IDX_MFM Void TComSlice::setRefPOCListILP( TComPic** ilpPic, TComPic *pcRefPicBL ) @@ -2453,7 +2528,5 @@ assert(thePoc == pcRefPicBL->getPOC()); -#if REUSE_MVSCALE || REUSE_BLKMAPPING ilpPic[0]->getSlice(0)->setBaseColPic( pcRefPicBL ); -#endif //copy reference pictures marking from the reference layer @@ -2486,5 +2559,3 @@ #endif - -#endif //! \} Index: /trunk/source/Lib/TLibCommon/TComSlice.h =================================================================== --- /trunk/source/Lib/TLibCommon/TComSlice.h (revision 188) +++ /trunk/source/Lib/TLibCommon/TComSlice.h (revision 189) @@ -504,5 +504,8 @@ Bool m_layerIdIncludedFlag[MAX_VPS_OP_SETS_PLUS1][MAX_VPS_NUH_RESERVED_ZERO_LAYER_ID_PLUS1]; #endif - +#if DERIVE_LAYER_ID_LIST_VARIABLES + Int m_layerSetLayerIdList[MAX_VPS_LAYER_SETS_PLUS1][MAX_VPS_LAYER_ID_PLUS1]; + Int m_numLayerInIdList[MAX_VPS_LAYER_SETS_PLUS1]; +#endif TComPTL m_pcPTL; #if SIGNAL_BITRATE_PICRATE_IN_VPS @@ -547,5 +550,14 @@ UInt m_refLayerId[MAX_VPS_LAYER_ID_PLUS1][MAX_VPS_LAYER_ID_PLUS1]; #endif - +#if VPS_PROFILE_OUTPUT_LAYERS + UInt m_numProfileTierLevel; + Bool m_moreOutputLayerSetsThanDefaultFlag; + Int m_numAddOutputLayerSets; + Bool m_defaultOneTargetOutputLayerFlag; + Int m_profileLevelTierIdx[64]; +#endif +#if JCTVC_M0458_INTERLAYER_RPS_SIG + Bool m_maxOneActiveRefLayerFlag; +#endif public: TComVPS(); @@ -604,5 +616,13 @@ Bool getLayerIdIncludedFlag(UInt opsIdx, UInt id) { return m_layerIdIncludedFlag[opsIdx][id]; } Void setLayerIdIncludedFlag(Bool v, UInt opsIdx, UInt id) { m_layerIdIncludedFlag[opsIdx][id] = v; } - +#if DERIVE_LAYER_ID_LIST_VARIABLES + Int getLayerSetLayerIdList(Int set, Int layerId) { return m_layerSetLayerIdList[set][layerId]; } + Void setLayerSetLayerIdList(Int set, Int layerId, Int x) { m_layerSetLayerIdList[set][layerId] = x ; } + + Int getNumLayersInIdList(Int set) { return m_numLayerInIdList[set]; } + Void setNumLayersInIdList(Int set, Int x) { m_numLayerInIdList[set] = x ; } + + Void deriveLayerIdListVariables(); +#endif TComPTL* getPTL() { return &m_pcPTL; } #if SIGNAL_BITRATE_PICRATE_IN_VPS @@ -663,13 +683,33 @@ #if VPS_EXTN_DIRECT_REF_LAYERS // Direct dependency of layers - Bool getDirectDependencyFlag(Int i, Int j) { return m_directDependencyFlag[i][j]; } - Void setDirectDependencyFlag(Int i, Int j, Bool x) { m_directDependencyFlag[i][j] = x; } - - UInt getNumDirectRefLayers(Int i) { return m_numDirectRefLayers[i]; } - Void setNumDirectRefLayers(Int i, UInt x) { m_numDirectRefLayers[i] = x; } - - UInt getRefLayerId(Int i, Int j) { return m_refLayerId[i][j]; } - Void setRefLayerId(Int i, Int j, UInt x) { m_refLayerId[i][j] = x; } -#endif + Bool getDirectDependencyFlag(Int currLayerId, Int refLayerId) { return m_directDependencyFlag[currLayerId][refLayerId]; } + Void setDirectDependencyFlag(Int currLayerId, Int refLayerId, Bool x) { m_directDependencyFlag[currLayerId][refLayerId] = x; } + + UInt getNumDirectRefLayers(Int layerId) { return m_numDirectRefLayers[layerId]; } + Void setNumDirectRefLayers(Int layerId, UInt refLayerNum) { m_numDirectRefLayers[layerId] = refLayerNum; } + + UInt getRefLayerId(Int layerId, Int refLayerIdx) { return m_refLayerId[layerId][refLayerIdx]; } + Void setRefLayerId(Int layerId, Int refLayerIdx, UInt refLayerId) { m_refLayerId[layerId][refLayerIdx] = refLayerId; } +#endif +#if VPS_PROFILE_OUTPUT_LAYERS + UInt getNumProfileTierLevel() { return m_numProfileTierLevel; } + Void setNumProfileTierLevel(Int x) { m_numProfileTierLevel = x; } + + Bool getMoreOutputLayerSetsThanDefaultFlag() { return m_moreOutputLayerSetsThanDefaultFlag;} + Void setMoreOutputLayerSetsThanDefaultFlag(Bool x) { m_moreOutputLayerSetsThanDefaultFlag = x ;} + + Int getNumAddOutputLayerSets() { return m_numAddOutputLayerSets; } + Void setNumAddOutputLayerSets(Int x) { m_numAddOutputLayerSets = x ; } + + Bool getDefaultOneTargetOutputLayerFlag() { return m_defaultOneTargetOutputLayerFlag;} + Void setDefaultOneTargetOutputLayerFlag(Bool x) { m_defaultOneTargetOutputLayerFlag= x ;} + + Int getProfileLevelTierIdx(Int i) { return m_profileLevelTierIdx[i]; } + Void setProfileLevelTierIdx(Int i, Int x) { m_profileLevelTierIdx[i] = x ; } +#endif +#if JCTVC_M0458_INTERLAYER_RPS_SIG + Bool getMaxOneActiveRefLayerFlag() { return m_maxOneActiveRefLayerFlag; } + Void setMaxOneActiveRefLayerFlag(Bool x) { m_maxOneActiveRefLayerFlag = x; } +#endif }; @@ -908,11 +948,12 @@ UInt m_picHeightInLumaSamples; - Window m_conformanceWindow; - + Int m_log2MinCodingBlockSize; + Int m_log2DiffMaxMinCodingBlockSize; UInt m_uiMaxCUWidth; UInt m_uiMaxCUHeight; UInt m_uiMaxCUDepth; - UInt m_uiMinTrDepth; - UInt m_uiMaxTrDepth; + + Window m_conformanceWindow; + TComRPSList m_RPSList; Bool m_bLongTermRefsPresent; @@ -930,5 +971,7 @@ Bool m_useAMP; +#if !L0034_COMBINED_LIST_CLEANUP Bool m_bUseLComb; +#endif // Parameter @@ -978,4 +1021,7 @@ Bool m_bMFMEnabledFlag; #endif +#if SCALED_REF_LAYER_OFFSETS + Window m_scaledRefLayerWindow; +#endif public: TComSPS(); @@ -1009,4 +1055,10 @@ Bool getUsedByCurrPicLtSPSFlag(Int i) {return m_usedByCurrPicLtSPSFlag[i];} Void setUsedByCurrPicLtSPSFlag(Int i, Bool x) { m_usedByCurrPicLtSPSFlag[i] = x;} + + Int getLog2MinCodingBlockSize() const { return m_log2MinCodingBlockSize; } + Void setLog2MinCodingBlockSize(Int val) { m_log2MinCodingBlockSize = val; } + Int getLog2DiffMaxMinCodingBlockSize() const { return m_log2DiffMaxMinCodingBlockSize; } + Void setLog2DiffMaxMinCodingBlockSize(Int val) { m_log2DiffMaxMinCodingBlockSize = val; } + Void setMaxCUWidth ( UInt u ) { m_uiMaxCUWidth = u; } UInt getMaxCUWidth () { return m_uiMaxCUWidth; } @@ -1025,8 +1077,4 @@ Bool getUseAMP() { return m_useAMP; } Void setUseAMP( Bool b ) { m_useAMP = b; } - Void setMinTrDepth ( UInt u ) { m_uiMinTrDepth = u; } - UInt getMinTrDepth () { return m_uiMinTrDepth; } - Void setMaxTrDepth ( UInt u ) { m_uiMaxTrDepth = u; } - UInt getMaxTrDepth () { return m_uiMaxTrDepth; } Void setQuadtreeTULog2MaxSize( UInt u ) { m_uiQuadtreeTULog2MaxSize = u; } UInt getQuadtreeTULog2MaxSize() { return m_uiQuadtreeTULog2MaxSize; } @@ -1050,6 +1098,8 @@ // Tool list +#if !L0034_COMBINED_LIST_CLEANUP Void setUseLComb (Bool b) { m_bUseLComb = b; } Bool getUseLComb () { return m_bUseLComb; } +#endif Bool getUseLossless () { return m_useLossless; } @@ -1112,4 +1162,7 @@ Void setMFMEnabledFlag(Bool flag) {m_bMFMEnabledFlag = flag;} Bool getMFMEnabledFlag() {return m_bMFMEnabledFlag;} +#endif +#if SCALED_REF_LAYER_OFFSETS + Window& getScaledRefLayerWindow( ) { return m_scaledRefLayerWindow; } #endif }; @@ -1370,11 +1423,17 @@ Int m_deblockingFilterBetaOffsetDiv2; //< beta offset for deblocking filter Int m_deblockingFilterTcOffsetDiv2; //< tc offset for deblocking filter - +#if JCTVC_M0458_INTERLAYER_RPS_SIG + Int m_activeNumILRRefIdx; //< Active inter-layer reference pictures + Int m_interLayerPredLayerIdc [MAX_VPS_LAYER_ID_PLUS1]; +#else +#if REF_IDX_FRAMEWORK + Int m_numILRRefIdx; //< for inter-layer reference picture ser +#endif +#endif +#if L0034_COMBINED_LIST_CLEANUP + Int m_list1IdxToList0Idx[MAX_NUM_REF]; + Int m_aiNumRefIdx [2]; // for multiple reference of current slice +#else Int m_aiNumRefIdx [3]; // for multiple reference of current slice - -#if REF_LIST_BUGFIX - Int m_aiNumILRRefIdx; //< for inter-layer reference picture ser -#endif - Int m_iRefIdxOfLC[2][MAX_NUM_REF_LC]; Int m_eListIdFromIdxOfLC[MAX_NUM_REF_LC]; @@ -1384,4 +1443,5 @@ Bool m_bRefPicListModificationFlagLC; Bool m_bRefPicListCombinationFlag; +#endif Bool m_bCheckLDC; @@ -1421,6 +1481,7 @@ Bool m_abEqualRef [2][MAX_NUM_REF][MAX_NUM_REF]; - +#if !L0034_COMBINED_LIST_CLEANUP Bool m_bNoBackPredFlag; +#endif UInt m_uiTLayer; #if SVC_EXTENSION @@ -1462,4 +1523,8 @@ Bool m_enableTMVPFlag; +#if JCTVC_M0458_INTERLAYER_RPS_SIG + Bool m_interLayerPredEnabledFlag; + Int m_numInterLayerRefPics; +#endif public: TComSlice(); @@ -1517,8 +1582,5 @@ Int getDeblockingFilterBetaOffsetDiv2() { return m_deblockingFilterBetaOffsetDiv2; } Int getDeblockingFilterTcOffsetDiv2() { return m_deblockingFilterTcOffsetDiv2; } -#if REF_LIST_BUGFIX - Int getNumILRRefIdx ( ) { return m_aiNumILRRefIdx; } - Void setNumILRRefIdx ( Int i ) { m_aiNumILRRefIdx = i; } -#endif + Int getNumRefIdx ( RefPicList e ) { return m_aiNumRefIdx[e]; } TComPic* getPic () { return m_pcPic; } @@ -1533,4 +1595,7 @@ Bool getMvdL1ZeroFlag () { return m_bLMvdL1Zero; } Int getNumRpsCurrTempList(); +#if L0034_COMBINED_LIST_CLEANUP + Int getList1IdxToList0Idx ( Int list1Idx ) { return m_list1IdxToList0Idx[list1Idx]; } +#else Int getRefIdxOfLC (RefPicList e, Int iRefIdx) { return m_iRefIdxOfLC[e][iRefIdx]; } Int getListIdFromIdxOfLC(Int iRefIdx) { return m_eListIdFromIdxOfLC[iRefIdx]; } @@ -1542,12 +1607,14 @@ Bool getRefPicListCombinationFlag() {return m_bRefPicListCombinationFlag;} Void setRefPicListCombinationFlag(Bool bflag) {m_bRefPicListCombinationFlag=bflag;} +#endif Void setReferenced(Bool b) { m_bRefenced = b; } Bool isReferenced() { return m_bRefenced; } Void setPOC ( Int i ) { m_iPOC = i; if(getTLayer()==0) m_prevPOC=i; } Void setNalUnitType ( NalUnitType e ) { m_eNalUnitType = e; } - NalUnitType getNalUnitType () { return m_eNalUnitType; } + NalUnitType getNalUnitType () const { return m_eNalUnitType; } Bool getRapPicFlag (); - Bool getIdrPicFlag () { return getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR || getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR_N_LP; } - Void checkCRA(TComReferencePictureSet *pReferencePictureSet, Int& pocCRA, Bool& prevRAPisBLA); + Bool getIdrPicFlag () { return getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR_W_RADL || getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR_N_LP; } + Bool isIRAP () const { return (getNalUnitType() >= 16) && (getNalUnitType() <= 23); } + Void checkCRA(TComReferencePictureSet *pReferencePictureSet, Int& pocCRA, Bool& prevRAPisBLA, TComList& rcListPic); Void decodingRefreshMarking(Int& pocCRA, Bool& bRefreshPending, TComList& rcListPic); Void setSliceType ( SliceType e ) { m_eSliceType = e; } @@ -1569,26 +1636,10 @@ Void setPic ( TComPic* p ) { m_pcPic = p; } Void setDepth ( Int iDepth ) { m_iDepth = iDepth; } - -#if SVC_EXTENSION - Void setBaseColPic ( TComPic* p) { m_pcBaseColPic = p; } - Void setBaseColPic ( TComList& rcListPic , UInt layerID ); - TComPic* getBaseColPic () { return m_pcBaseColPic; } - - Void setLayerId (UInt layerId) { m_layerId = layerId; } - UInt getLayerId () { return m_layerId; } - - Void setFullPelBaseRec ( TComPicYuv* p) { m_pcFullPelBaseRec = p; } - TComPicYuv* getFullPelBaseRec () { return m_pcFullPelBaseRec; } - -#if AVC_SYNTAX - Void initBaseLayerRPL( TComSlice *pcSlice ); -#endif -#endif - -#if REF_IDX_MFM - Void setRefPOCListILP(TComPic** ilpPic, TComPic *pcRefPicBL); -#endif - + +#if FIX1071 + Void setRefPicList ( TComList& rcListPic, Bool checkNumPocTotalCurr = false, TComPic** ilpPic = NULL ); +#else Void setRefPicList ( TComList& rcListPic ); +#endif Void setRefPOCList (); Void setColFromL0Flag ( UInt colFromL0 ) { m_colFromL0Flag = colFromL0; } @@ -1596,9 +1647,4 @@ Void setCheckLDC ( Bool b ) { m_bCheckLDC = b; } Void setMvdL1ZeroFlag ( Bool b) { m_bLMvdL1Zero = b; } - -#if REF_LIST_BUGFIX - Void setRefPicListModificationSvc(); - Void setRefPicListSvc ( TComList& rcListPic, TComPic** ilpPic ); -#endif Bool isIntra () { return m_eSliceType == I_SLICE; } @@ -1628,8 +1674,11 @@ static Void sortPicList ( TComList& rcListPic ); - +#if L0034_COMBINED_LIST_CLEANUP + Void setList1IdxToList0Idx(); +#else Bool getNoBackPredFlag() { return m_bNoBackPredFlag; } Void setNoBackPredFlag( Bool b ) { m_bNoBackPredFlag = b; } Void generateCombinedList (); +#endif UInt getTLayer () { return m_uiTLayer; } @@ -1679,6 +1728,5 @@ Void getWpScaling ( RefPicList e, Int iRefIdx, wpScalingParam *&wp); - Void resetWpScaling (wpScalingParam wp[2][MAX_NUM_REF][3]); - Void initWpScaling (wpScalingParam wp[2][MAX_NUM_REF][3]); + Void resetWpScaling (); Void initWpScaling (); inline Bool applyWP () { return( (m_eSliceType==P_SLICE && m_pcPPS->getUseWP()) || (m_eSliceType==B_SLICE && m_pcPPS->getWPBiPred()) ); } @@ -1714,12 +1762,51 @@ Void setEnableTMVPFlag ( Bool b ) { m_enableTMVPFlag = b; } Bool getEnableTMVPFlag () { return m_enableTMVPFlag;} + +#if SVC_EXTENSION + Void setBaseColPic ( TComList& rcListPic , UInt layerID ); + Void setBaseColPic ( TComPic* p) { m_pcBaseColPic = p; } + TComPic* getBaseColPic () { return m_pcBaseColPic; } + + Void setLayerId (UInt layerId) { m_layerId = layerId; } + UInt getLayerId () { return m_layerId; } + + Void setFullPelBaseRec ( TComPicYuv* p) { m_pcFullPelBaseRec = p; } + TComPicYuv* getFullPelBaseRec () { return m_pcFullPelBaseRec; } + +#if AVC_SYNTAX + Void initBaseLayerRPL( TComSlice *pcSlice ); +#endif + #if REF_IDX_FRAMEWORK - Void addRefPicList( TComPic **pIlpPicList, Int iRefPicNum, Int iInsertOffset=0 ); -#endif + Void setRefPicListModificationSvc(); + Int getNumILRRefIdx ( ) { return m_pcVPS->getNumDirectRefLayers( m_layerId ); } + +#if REF_IDX_MFM + Void setRefPOCListILP(TComPic** ilpPic, TComPic *pcRefPicBL); +#endif + +#if JCTVC_M0458_INTERLAYER_RPS_SIG + Int getActiveNumILRRefIdx ( ) { return m_activeNumILRRefIdx; } + Void setActiveNumILRRefIdx ( Int i ) { m_activeNumILRRefIdx = i; } + + Int getInterLayerPredLayerIdc (UInt Idx ) { return m_interLayerPredLayerIdc[Idx];} + Void setInterLayerPredLayerIdc (UInt val, UInt Idx) { m_interLayerPredLayerIdc[Idx] = val; } + + Void setInterLayerPredEnabledFlag ( Bool val ) { m_interLayerPredEnabledFlag = val; } + Bool getInterLayerPredEnabledFlag () { return m_interLayerPredEnabledFlag;} + + Void setNumInterLayerRefPics ( UInt val ) { m_numInterLayerRefPics = val; } + UInt getNumInterLayerRefPics () { return m_numInterLayerRefPics;} +#else + Void setNumILRRefIdx ( Int i ) { m_numILRRefIdx = i; } +#endif +#endif + +#endif //SVC_EXTENSION + protected: TComPic* xGetRefPic (TComList& rcListPic, Int poc); - TComPic* xGetLongTermRefPic (TComList& rcListPic, - Int poc); + TComPic* xGetLongTermRefPic(TComList& rcListPic, Int poc, Bool pocHasMsb); };// END CLASS DEFINITION TComSlice @@ -1805,5 +1892,5 @@ //! activate a PPS and depending on isIDR parameter also SPS and VPS //! \returns true, if activation is successful - Bool activatePPS(Int ppsId, Bool isIDR); + Bool activatePPS(Int ppsId, Bool isIRAP); TComVPS* getActiveVPS(){ return m_vpsMap.getPS(m_activeVPSId); }; Index: /trunk/source/Lib/TLibCommon/TComTrQuant.cpp =================================================================== --- /trunk/source/Lib/TLibCommon/TComTrQuant.cpp (revision 188) +++ /trunk/source/Lib/TLibCommon/TComTrQuant.cpp (revision 189) @@ -2007,5 +2007,5 @@ } - if(piQCoef[minPos] == 32767 || piQCoef[minPos] == -32768) + if(piDstCoeff[minPos] == 32767 || piDstCoeff[minPos] == -32768) { finalChange = -1; Index: /trunk/source/Lib/TLibCommon/TComUpsampleFilter.cpp =================================================================== --- /trunk/source/Lib/TLibCommon/TComUpsampleFilter.cpp (revision 188) +++ /trunk/source/Lib/TLibCommon/TComUpsampleFilter.cpp (revision 189) @@ -128,5 +128,9 @@ } +#if SCALED_REF_LAYER_OFFSETS +Void TComUpsampleFilter::upsampleBasePic( TComPicYuv* pcUsPic, TComPicYuv* pcBasePic, TComPicYuv* pcTempPic, const Window window ) +#else Void TComUpsampleFilter::upsampleBasePic( TComPicYuv* pcUsPic, TComPicYuv* pcBasePic, TComPicYuv* pcTempPic ) +#endif { assert ( NTAPS_US_LUMA == 8 ); @@ -136,4 +140,15 @@ //========== Y component upsampling =========== +#if SCALED_REF_LAYER_OFFSETS + const Window &scalEL = window; + + Int widthBL = pcBasePic->getWidth (); + Int heightBL = pcBasePic->getHeight(); + Int strideBL = pcBasePic->getStride(); + + Int widthEL = pcUsPic->getWidth () - scalEL.getWindowLeftOffset() - scalEL.getWindowRightOffset(); + Int heightEL = pcUsPic->getHeight() - scalEL.getWindowTopOffset() - scalEL.getWindowBottomOffset(); + Int strideEL = pcUsPic->getStride(); +#else const Window &confBL = pcBasePic->getConformanceWindow(); const Window &confEL = pcUsPic->getConformanceWindow(); @@ -146,5 +161,5 @@ Int heightEL = pcUsPic->getHeight() - confEL.getWindowTopOffset() - confEL.getWindowBottomOffset(); Int strideEL = pcUsPic->getStride(); - +#endif Pel* piTempBufY = pcTempPic->getLumaAddr(); Pel* piSrcBufY = pcBasePic->getLumaAddr(); @@ -329,10 +344,30 @@ const Double sFactor12 = sFactor * 12; #endif +#if ILP_DECODED_PICTURE + widthBL = pcBasePic->getWidth (); + heightBL = pcBasePic->getHeight(); + + widthEL = pcUsPic->getWidth (); + heightEL = pcUsPic->getHeight(); +#endif +#if SCALED_REF_LAYER_OFFSETS + Int leftStartL = scalEL.getWindowLeftOffset(); + Int rightEndL = pcUsPic->getWidth() - scalEL.getWindowRightOffset(); + Int topStartL = scalEL.getWindowTopOffset(); + Int bottomEndL = pcUsPic->getHeight() - scalEL.getWindowBottomOffset(); +#endif //========== horizontal upsampling =========== for( i = 0; i < widthEL; i++ ) { +#if SCALED_REF_LAYER_OFFSETS + Int x = Clip3( leftStartL, rightEndL - 1, i ); +#endif #if PHASE_DERIVATION_IN_INTEGER +#if SCALED_REF_LAYER_OFFSETS + refPos16 = (((x - leftStartL)*scaleX + addX) >> shiftXM4) - deltaX; +#else refPos16 = ((i*scaleX + addX) >> shiftXM4) - deltaX; +#endif phase = refPos16 & 15; refPos = refPos16 >> 4; @@ -366,8 +401,19 @@ Int iOffset = 1 << (nShift - 1); +#if SCALED_REF_LAYER_OFFSETS + for( j = 0; j < pcTempPic->getHeight(); j++ ) +#else for( j = 0; j < heightEL; j++ ) - { +#endif + { +#if SCALED_REF_LAYER_OFFSETS + Int y = Clip3(topStartL, bottomEndL - 1, j); +#endif #if PHASE_DERIVATION_IN_INTEGER +#if SCALED_REF_LAYER_OFFSETS + refPos16 = ((( y - topStartL )*scaleY + addY) >> shiftYM4) - deltaY; +#else refPos16 = ((j*scaleY + addY) >> shiftYM4) - deltaY; +#endif phase = refPos16 & 15; refPos = refPos16 >> 4; @@ -382,12 +428,40 @@ piSrcY = piTempBufY + (refPos -((NTAPS_US_LUMA>>1) - 1))*strideEL; piDstY = piDstBufY + j * strideEL; - +#if SCALED_REF_LAYER_OFFSETS + for( i = 0; i < pcTempPic->getWidth(); i++ ) +#else for( i = 0; i < widthEL; i++ ) +#endif { *piDstY = ClipY( (sumLumaVer(piSrcY, coeff, strideEL) + iOffset) >> (nShift)); +#if SCALED_REF_LAYER_OFFSETS + // Only increase the x position of reference upsample picture when within the window + // "-2" to ensure that pointer doesn't go beyond the boundary rightEndL-1 + if( (i >= leftStartL) && (i <= rightEndL-2) ) + { + piSrcY++; + } +#else piSrcY++; +#endif piDstY++; } } + +#if ILP_DECODED_PICTURE +#if SCALED_REF_LAYER_OFFSETS + widthBL = pcBasePic->getWidth (); + heightBL = pcBasePic->getHeight(); + + widthEL = pcUsPic->getWidth () - scalEL.getWindowLeftOffset() - scalEL.getWindowRightOffset(); + heightEL = pcUsPic->getHeight() - scalEL.getWindowTopOffset() - scalEL.getWindowBottomOffset(); +#else + widthBL = pcBasePic->getWidth () - confBL.getWindowLeftOffset() - confBL.getWindowRightOffset(); + heightBL = pcBasePic->getHeight() - confBL.getWindowTopOffset() - confBL.getWindowBottomOffset(); + + widthEL = pcUsPic->getWidth () - confEL.getWindowLeftOffset() - confEL.getWindowRightOffset(); + heightEL = pcUsPic->getHeight() - confEL.getWindowTopOffset() - confEL.getWindowBottomOffset(); +#endif +#endif //========== UV component upsampling =========== @@ -401,4 +475,10 @@ strideBL = pcBasePic->getCStride(); strideEL = pcUsPic->getCStride(); +#if SCALED_REF_LAYER_OFFSETS + Int leftStartC = scalEL.getWindowLeftOffset() >> 1; + Int rightEndC = (pcUsPic->getWidth() >> 1) - (scalEL.getWindowRightOffset() >> 1); + Int topStartC = scalEL.getWindowTopOffset() >> 1; + Int bottomEndC = (pcUsPic->getHeight() >> 1) - (scalEL.getWindowBottomOffset() >> 1); +#endif #if PHASE_DERIVATION_IN_INTEGER @@ -422,9 +502,24 @@ #endif +#if ILP_DECODED_PICTURE + widthBL = pcBasePic->getWidth () >> 1; + heightBL = pcBasePic->getHeight() >> 1; + + widthEL = pcUsPic->getWidth () >> 1; + heightEL = pcUsPic->getHeight() >> 1; +#endif + //========== horizontal upsampling =========== for( i = 0; i < widthEL; i++ ) { +#if SCALED_REF_LAYER_OFFSETS + Int x = Clip3(leftStartC, rightEndC - 1, i); +#endif #if PHASE_DERIVATION_IN_INTEGER +#if SCALED_REF_LAYER_OFFSETS + refPos16 = (((x - leftStartC)*scaleX + addX) >> shiftXM4) - deltaX; +#else refPos16 = ((i*scaleX + addX) >> shiftXM4) - deltaX; +#endif phase = refPos16 & 15; refPos = refPos16 >> 4; @@ -460,8 +555,19 @@ pcTempPic->setHeight(heightEL << 1); - for( j = 0; j < heightEL; j++ ) - { +#if SCALED_REF_LAYER_OFFSETS + for( j = 0; j < pcTempPic->getHeight() >> 1; j++ ) +#else + for( j = 0; j < heightEL; j++ ) +#endif + { +#if SCALED_REF_LAYER_OFFSETS + Int y = Clip3(topStartC, bottomEndC - 1, j); +#endif #if PHASE_DERIVATION_IN_INTEGER +#if SCALED_REF_LAYER_OFFSETS + refPos16 = (((y - topStartC)*scaleY + addY) >> shiftYM4) - deltaY; +#else refPos16 = ((j*scaleY + addY) >> shiftYM4) - deltaY; +#endif phase = refPos16 & 15; refPos = refPos16 >> 4; @@ -488,11 +594,25 @@ piDstV = piDstBufV + j*strideEL; +#if SCALED_REF_LAYER_OFFSETS + for( i = 0; i < pcTempPic->getWidth() >> 1; i++ ) +#else for( i = 0; i < widthEL; i++ ) +#endif { *piDstU = ClipC( (sumChromaVer(piSrcU, coeff, strideEL) + iOffset) >> (nShift)); *piDstV = ClipC( (sumChromaVer(piSrcV, coeff, strideEL) + iOffset) >> (nShift)); +#if SCALED_REF_LAYER_OFFSETS + // Only increase the x position of reference upsample picture when within the window + // "-2" to ensure that pointer doesn't go beyond the boundary rightEndC-1 + if( (i >= leftStartC) && (i <= rightEndC-2) ) + { + piSrcU++; + piSrcV++; + } +#else piSrcU++; piSrcV++; +#endif piDstU++; piDstV++; Index: /trunk/source/Lib/TLibCommon/TComUpsampleFilter.h =================================================================== --- /trunk/source/Lib/TLibCommon/TComUpsampleFilter.h (revision 188) +++ /trunk/source/Lib/TLibCommon/TComUpsampleFilter.h (revision 189) @@ -52,5 +52,9 @@ ~TComUpsampleFilter(void); +#if SCALED_REF_LAYER_OFFSETS + Void upsampleBasePic( TComPicYuv* pcUsPic, TComPicYuv* pcBasePic, TComPicYuv* pcTempPic, const Window window ); +#else Void upsampleBasePic( TComPicYuv* pcUsPic, TComPicYuv* pcBasePic, TComPicYuv* pcTempPic ); +#endif }; Index: /trunk/source/Lib/TLibCommon/TypeDef.h =================================================================== --- /trunk/source/Lib/TLibCommon/TypeDef.h (revision 188) +++ /trunk/source/Lib/TLibCommon/TypeDef.h (revision 189) @@ -44,4 +44,7 @@ #if SVC_EXTENSION +#define SCALED_REF_LAYER_OFFSETS 1 ///< M0309: Signal scaled reference layer offsets in SPS +#define MAX_LAYERS 2 ///< max number of layers the codec is supposed to handle + #define VPS_RENAME 1 ///< Rename variables max_layer_id and num_layer_sets_minus1 in VPS #define VPS_EXTNS 1 ///< Include function structure for VPS extensions @@ -51,6 +54,11 @@ #define VPS_EXTN_PROFILE_INFO 1 ///< Include profile information for layer sets in VPS extension #define VPS_EXTN_DIRECT_REF_LAYERS 1 ///< Include indication of direct dependency of layers in VPS extension -#endif -#define MAX_LAYERS 2 ///< max number of layers the codec is supposed to handle +#define VPS_EXTN_DIRECT_REF_LAYERS_CONTINUE 1 +#define VPS_OUTPUT_LAYER_SET_IDX 1 ///< M0268: Signal output_layer_set_idx[i] as output_layer_set_idx_minus1[i] +#define VPS_MOVE_DIR_DEPENDENCY_FLAG 1 ///< M0268: Move the syntax element direct_dependency_flag to follow the syntax element dimension_id +#define VPS_PROFILE_OUTPUT_LAYERS 1 ///< M0268: Signal profile information and output layer information as in Sec. 3 of M0268v2 +#endif + +#define DERIVE_LAYER_ID_LIST_VARIABLES 1 ///< Derived variables based on the variables in VPS - for use in syntax table parsing #define SVC_COL_BLK 1 ///< get co-located block @@ -60,12 +68,11 @@ #define CHROMA_UPSAMPLING 1 ///< L0335: Chroma upsampling with 5 bits coefficients -#define MV_SCALING_FIX 1 ///< fixing the base layer MV scaling -#define MV_SCALING_POS_FIX 1 ///< use center pixels to get co-located base layer block -#define MFM_CLIPPING_FIX 1 ///< set the right picture size for the clipping - -#define AVC_BASE 0 ///< YUV BL reading for AVC base SVC -#define REF_IDX_FRAMEWORK 0 ///< inter-layer reference framework - -#if SVC_UPSAMPLING +#define SIMPLIFIED_MV_POS_SCALING 1 ///< M0133/M0449: inter-layer MV scaling and pixel mapping position calculation +#define ILP_DECODED_PICTURE 1 ///< M0274: use decoded picture for inter-layer prediction +#define JCTVC_M0259_LAMBDAREFINEMENT 1 ///< JCTVC-M0259: lambda refinement (encoder only optimization) + +#define REF_IDX_FRAMEWORK 1 ///< inter-layer reference framework + +#if SVC_UPSAMPLING && !ILP_DECODED_PICTURE #define JCTVC_L0178 1 ///< implementation of JCTVC-L0178 (code only supports right and bottom croppping offsets) #endif @@ -73,6 +80,7 @@ #define IDR_ALIGNMENT 1 ///< align IDR picures across layers +#define AVC_BASE 1 ///< YUV BL reading for AVC base SVC #if AVC_BASE -#define AVC_SYNTAX 1 ///< Syntax reading for AVC base +#define AVC_SYNTAX 0 ///< Syntax reading for AVC base #endif @@ -80,15 +88,9 @@ #define REF_IDX_ME_ZEROMV 1 ///< L0051: use zero motion for inter-layer reference picture (without fractional ME) #define ENCODER_FAST_MODE 1 ///< L0174: enable encoder fast mode. TestMethod 1 is enabled by setting to 1 and TestMethod 2 is enable by setting to 2. By default it is set to 1. -#if !AVC_BASE || AVC_SYNTAX #define REF_IDX_MFM 1 ///< L0336: motion vector mapping of inter-layer reference picture -#endif - -#if REF_IDX_MFM -#define REUSE_MVSCALE 1 ///< using the base layer MV scaling function -#define REUSE_BLKMAPPING 1 ///< using the base layer get co-located block function -#define RAP_MFM_INIT 1 ///< initilizing MFM when base layer is RAP picture -#define REF_LIST_BUGFIX 1 -#endif - +#define JCTVC_M0458_INTERLAYER_RPS_SIG 1 ///< implementation of JCTVC-L0178 (currently only one reference layer is supported ) +#if JCTVC_M0458_INTERLAYER_RPS_SIG +#define ZERO_NUM_DIRECT_LAYERS 1 ///< support of zero direct reference layers +#endif #else #define INTRA_BL 1 ///< inter-layer texture prediction @@ -97,4 +99,6 @@ #define INTRA_BL_DST4x4 1 ///< L0067/L0204: DST4x4 for Intra BL #define NO_RESIDUAL_FLAG_FOR_BLPRED 1 ///< L0437: Root cbf for Intra_BL +#define IL_MRG_SIMPLIFIED_PRUNING 1 ///< M0124: simplified pruning, Only the left and above candidates are checked with BL-C candidate for redundancy removal +#define INTRA_BL_CTX_CHANGE 1 ///< M0075: spatial dependency removal for IntraBL flag context derivation // Hooks @@ -109,4 +113,5 @@ #endif #else +#define ILP_DECODED_PICTURE 0 #define SYNTAX_OUTPUT 0 #endif @@ -114,4 +119,15 @@ //! \ingroup TLibCommon //! \{ + +#define FIX1071 1 ///< Temporary fix for issue #1071 + +#define L0208_SOP_DESCRIPTION_SEI 1 ///< L0208: add SOP descrioption SEI +#define MAX_NUM_PICS_IN_SOP 1024 + +#define K0180_SCALABLE_NESTING_SEI 1 ///JCTVC-K0180 scalable nesting sei message +#define MAX_NESTING_NUM_OPS 1024 +#define MAX_NESTING_NUM_LAYER 64 + +#define J0149_TONE_MAPPING_SEI 1 ///< J0149: Tone mapping information SEI #define L0363_DU_BIT_RATE 1 ///< L0363: add bit_rate_du_value_minus1 to HRD parameters #define L0328_SPLICING 1 ///< L0328: splicing support in HRD @@ -138,4 +154,8 @@ #define SIGNAL_BITRATE_PICRATE_IN_VPS 0 ///< K0125: Signal bit_rate and pic_rate in VPS #define L0232_RD_PENALTY 1 ///< L0232: RD-penalty for 32x32 TU for intra in non-intra slices +#define L0386_DB_METRIC 1 ///< L0386: non-normative blockiness metric (automatically configures deblocking parameters in bitstream) +#define L0323_DPB 1 ///< L0323: Specification of active reference indices and decoded picture buffer + +#define L0034_COMBINED_LIST_CLEANUP 1 #if VPS_EXTN_MASK_AND_DIM_INFO @@ -144,5 +164,5 @@ #if VPS_RENAME #define MAX_VPS_LAYER_SETS_PLUS1 1024 -#define MAX_VPS_LAYER_ID_PLUS1 2 +#define MAX_VPS_LAYER_ID_PLUS1 MAX_LAYERS #else #define MAX_VPS_NUM_HRD_PARAMETERS 1 @@ -477,5 +497,7 @@ REF_PIC_LIST_0 = 0, ///< reference list 0 REF_PIC_LIST_1 = 1, ///< reference list 1 +#if !L0034_COMBINED_LIST_CLEANUP REF_PIC_LIST_C = 2, ///< combined reference list for uni-prediction in B-Slices +#endif REF_PIC_LIST_X = 100 ///< special mark }; Index: /trunk/source/Lib/TLibDecoder/NALread.cpp =================================================================== --- /trunk/source/Lib/TLibDecoder/NALread.cpp (revision 188) +++ /trunk/source/Lib/TLibDecoder/NALread.cpp (revision 189) @@ -50,14 +50,18 @@ //! \ingroup TLibDecoder //! \{ -static void convertPayloadToRBSP(vector& nalUnitBuf, Bool isVclNalUnit) +static void convertPayloadToRBSP(vector& nalUnitBuf, TComInputBitstream *bitstream, Bool isVclNalUnit) { UInt zeroCount = 0; vector::iterator it_read, it_write; - for (it_read = it_write = nalUnitBuf.begin(); it_read != nalUnitBuf.end(); it_read++, it_write++) + UInt pos = 0; + bitstream->clearEmulationPreventionByteLocation(); + for (it_read = it_write = nalUnitBuf.begin(); it_read != nalUnitBuf.end(); it_read++, it_write++, pos++) { assert(zeroCount < 2 || *it_read >= 0x03); if (zeroCount == 2 && *it_read == 0x03) { + bitstream->pushEmulationPreventionByteLocation( pos ); + pos++; it_read++; zeroCount = 0; @@ -109,8 +113,8 @@ if ( nalu.m_temporalId ) { - assert( nalu.m_nalUnitType != NAL_UNIT_CODED_SLICE_BLA - && nalu.m_nalUnitType != NAL_UNIT_CODED_SLICE_BLANT + assert( nalu.m_nalUnitType != NAL_UNIT_CODED_SLICE_BLA_W_LP + && nalu.m_nalUnitType != NAL_UNIT_CODED_SLICE_BLA_W_RADL && nalu.m_nalUnitType != NAL_UNIT_CODED_SLICE_BLA_N_LP - && nalu.m_nalUnitType != NAL_UNIT_CODED_SLICE_IDR + && nalu.m_nalUnitType != NAL_UNIT_CODED_SLICE_IDR_W_RADL && nalu.m_nalUnitType != NAL_UNIT_CODED_SLICE_IDR_N_LP && nalu.m_nalUnitType != NAL_UNIT_CODED_SLICE_CRA @@ -122,5 +126,5 @@ else { - assert( nalu.m_nalUnitType != NAL_UNIT_CODED_SLICE_TLA + assert( nalu.m_nalUnitType != NAL_UNIT_CODED_SLICE_TLA_R && nalu.m_nalUnitType != NAL_UNIT_CODED_SLICE_TSA_N && nalu.m_nalUnitType != NAL_UNIT_CODED_SLICE_STSA_R @@ -136,7 +140,8 @@ /* perform anti-emulation prevention */ TComInputBitstream *pcBitstream = new TComInputBitstream(NULL); - convertPayloadToRBSP(nalUnitBuf, (nalUnitBuf[0] & 64) == 0); + convertPayloadToRBSP(nalUnitBuf, pcBitstream, (nalUnitBuf[0] & 64) == 0); nalu.m_Bitstream = new TComInputBitstream(&nalUnitBuf); + nalu.m_Bitstream->setEmulationPreventionByteLocation(pcBitstream->getEmulationPreventionByteLocation()); delete pcBitstream; readNalUnitHeader(nalu); Index: /trunk/source/Lib/TLibDecoder/SEIread.cpp =================================================================== --- /trunk/source/Lib/TLibDecoder/SEIread.cpp (revision 188) +++ /trunk/source/Lib/TLibDecoder/SEIread.cpp (revision 189) @@ -90,4 +90,19 @@ fprintf( g_hTrace, "=========== Decoding Unit Information SEI message ===========\n"); break; +#if J0149_TONE_MAPPING_SEI + case SEI::TONE_MAPPING_INFO: + fprintf( g_hTrace, "===========Tone Mapping Info SEI message ===========\n"); + break; +#endif +#if L0208_SOP_DESCRIPTION_SEI + case SEI::SOP_DESCRIPTION: + fprintf( g_hTrace, "=========== SOP Description SEI message ===========\n"); + break; +#endif +#if K0180_SCALABLE_NESTING_SEI + case SEI::SCALABLE_NESTING: + fprintf( g_hTrace, "=========== Scalable Nesting SEI message ===========\n"); + break; +#endif default: fprintf( g_hTrace, "=========== Unknown SEI message ===========\n"); @@ -154,5 +169,5 @@ SEI *sei = NULL; - if(nalUnitType == NAL_UNIT_SEI) + if(nalUnitType == NAL_UNIT_PREFIX_SEI) { switch (payloadType) @@ -219,4 +234,22 @@ xParseSEIGradualDecodingRefreshInfo((SEIGradualDecodingRefreshInfo&) *sei, payloadSize); break; +#if J0149_TONE_MAPPING_SEI + case SEI::TONE_MAPPING_INFO: + sei = new SEIToneMappingInfo; + xParseSEIToneMappingInfo((SEIToneMappingInfo&) *sei, payloadSize); + break; +#endif +#if L0208_SOP_DESCRIPTION_SEI + case SEI::SOP_DESCRIPTION: + sei = new SEISOPDescription; + xParseSEISOPDescription((SEISOPDescription&) *sei, payloadSize); + break; +#endif +#if K0180_SCALABLE_NESTING_SEI + case SEI::SCALABLE_NESTING: + sei = new SEIScalableNesting; + xParseSEIScalableNesting((SEIScalableNesting&) *sei, nalUnitType, payloadSize, sps); + break; +#endif default: for (UInt i = 0; i < payloadSize; i++) @@ -284,10 +317,13 @@ { UInt reservedPayloadExtensionData; - READ_CODE (1, reservedPayloadExtensionData, "reserved_payload_extension_data"); + READ_FLAG (reservedPayloadExtensionData, "reserved_payload_extension_data"); } UInt dummy; - READ_CODE (1, dummy, "payload_bit_equal_to_one"); - READ_CODE (payloadBitsRemaining-1, dummy, "payload_bit_equal_to_zero"); + READ_FLAG (dummy, "payload_bit_equal_to_one"); payloadBitsRemaining--; + while (payloadBitsRemaining) + { + READ_FLAG (dummy, "payload_bit_equal_to_zero"); payloadBitsRemaining--; + } } @@ -632,4 +668,162 @@ } +#if J0149_TONE_MAPPING_SEI +Void SEIReader::xParseSEIToneMappingInfo(SEIToneMappingInfo& sei, UInt /*payloadSize*/) +{ + Int i; + UInt val; + READ_UVLC( val, "tone_map_id" ); sei.m_toneMapId = val; + READ_FLAG( val, "tone_map_cancel_flag" ); sei.m_toneMapCancelFlag = val; + + if ( !sei.m_toneMapCancelFlag ) + { + READ_FLAG( val, "tone_map_persistence_flag" ); sei.m_toneMapPersistenceFlag = val; + READ_CODE( 8, val, "coded_data_bit_depth" ); sei.m_codedDataBitDepth = val; + READ_CODE( 8, val, "target_bit_depth" ); sei.m_targetBitDepth = val; + READ_UVLC( val, "model_id" ); sei.m_modelId = val; + switch(sei.m_modelId) + { + case 0: + { + READ_CODE( 32, val, "min_value" ); sei.m_minValue = val; + READ_CODE( 32, val, "max_value" ); sei.m_maxValue = val; + break; + } + case 1: + { + READ_CODE( 32, val, "sigmoid_midpoint" ); sei.m_sigmoidMidpoint = val; + READ_CODE( 32, val, "sigmoid_width" ); sei.m_sigmoidWidth = val; + break; + } + case 2: + { + UInt num = 1u << sei.m_targetBitDepth; + sei.m_startOfCodedInterval.resize(num+1); + for(i = 0; i < num; i++) + { + READ_CODE( ((( sei.m_codedDataBitDepth + 7 ) >> 3 ) << 3), val, "start_of_coded_interval" ); + sei.m_startOfCodedInterval[i] = val; + } + sei.m_startOfCodedInterval[num] = 1u << sei.m_codedDataBitDepth; + break; + } + case 3: + { + READ_CODE( 16, val, "num_pivots" ); sei.m_numPivots = val; + sei.m_codedPivotValue.resize(sei.m_numPivots); + sei.m_targetPivotValue.resize(sei.m_numPivots); + for(i = 0; i < sei.m_numPivots; i++ ) + { + READ_CODE( ((( sei.m_codedDataBitDepth + 7 ) >> 3 ) << 3), val, "coded_pivot_value" ); + sei.m_codedPivotValue[i] = val; + READ_CODE( ((( sei.m_targetBitDepth + 7 ) >> 3 ) << 3), val, "target_pivot_value" ); + sei.m_targetPivotValue[i] = val; + } + break; + } + case 4: + { + READ_CODE( 8, val, "camera_iso_speed_idc" ); sei.m_cameraIsoSpeedValue = val; + if( sei.m_cameraIsoSpeedValue == 255) //Extended_ISO + { + READ_CODE( 32, val, "camera_iso_speed_value" ); sei.m_cameraIsoSpeedValue = val; + } + READ_FLAG( val, "exposure_compensation_value_sign_flag" ); sei.m_exposureCompensationValueSignFlag = val; + READ_CODE( 16, val, "exposure_compensation_value_numerator" ); sei.m_exposureCompensationValueNumerator = val; + READ_CODE( 16, val, "exposure_compensation_value_denom_idc" ); sei.m_exposureCompensationValueDenomIdc = val; + READ_CODE( 32, val, "ref_screen_luminance_white" ); sei.m_refScreenLuminanceWhite = val; + READ_CODE( 32, val, "extended_range_white_level" ); sei.m_extendedRangeWhiteLevel = val; + READ_CODE( 16, val, "nominal_black_level_luma_code_value" ); sei.m_nominalBlackLevelLumaCodeValue = val; + READ_CODE( 16, val, "nominal_white_level_luma_code_value" ); sei.m_nominalWhiteLevelLumaCodeValue= val; + READ_CODE( 16, val, "extended_white_level_luma_code_value" ); sei.m_extendedWhiteLevelLumaCodeValue = val; + break; + } + default: + { + assert(!"Undefined SEIToneMapModelId"); + break; + } + }//switch model id + }// if(!sei.m_toneMapCancelFlag) + + xParseByteAlign(); +} +#endif + +#if L0208_SOP_DESCRIPTION_SEI +Void SEIReader::xParseSEISOPDescription(SEISOPDescription &sei, UInt payloadSize) +{ + Int iCode; + UInt uiCode; + + READ_UVLC( uiCode, "sop_seq_parameter_set_id" ); sei.m_sopSeqParameterSetId = uiCode; + READ_UVLC( uiCode, "num_pics_in_sop_minus1" ); sei.m_numPicsInSopMinus1 = uiCode; + for (UInt i = 0; i <= sei.m_numPicsInSopMinus1; i++) + { + READ_CODE( 6, uiCode, "sop_desc_vcl_nalu_type" ); sei.m_sopDescVclNaluType[i] = uiCode; + READ_CODE( 3, sei.m_sopDescTemporalId[i], "sop_desc_temporal_id" ); sei.m_sopDescTemporalId[i] = uiCode; + if (sei.m_sopDescVclNaluType[i] != NAL_UNIT_CODED_SLICE_IDR_W_RADL && sei.m_sopDescVclNaluType[i] != NAL_UNIT_CODED_SLICE_IDR_N_LP) + { + READ_UVLC( sei.m_sopDescStRpsIdx[i], "sop_desc_st_rps_idx" ); sei.m_sopDescStRpsIdx[i] = uiCode; + } + if (i > 0) + { + READ_SVLC( iCode, "sop_desc_poc_delta" ); sei.m_sopDescPocDelta[i] = iCode; + } + } + + xParseByteAlign(); +} +#endif + +#if K0180_SCALABLE_NESTING_SEI +Void SEIReader::xParseSEIScalableNesting(SEIScalableNesting& sei, const NalUnitType nalUnitType, UInt payloadSize, TComSPS *sps) +{ + UInt uiCode; + SEIMessages seis; + + READ_FLAG( uiCode, "bitstream_subset_flag" ); sei.m_bitStreamSubsetFlag = uiCode; + READ_FLAG( uiCode, "nesting_op_flag" ); sei.m_nestingOpFlag = uiCode; + if (sei.m_nestingOpFlag) + { + READ_FLAG( uiCode, "default_op_flag" ); sei.m_defaultOpFlag = uiCode; + READ_UVLC( uiCode, "nesting_num_ops_minus1" ); sei.m_nestingNumOpsMinus1 = uiCode; + for (UInt i = sei.m_defaultOpFlag; i <= sei.m_nestingNumOpsMinus1; i++) + { + READ_CODE( 3, uiCode, "nesting_max_temporal_id_plus1" ); sei.m_nestingMaxTemporalIdPlus1[i] = uiCode; + READ_UVLC( uiCode, "nesting_op_idx" ); sei.m_nestingOpIdx[i] = uiCode; + } + } + else + { + READ_FLAG( uiCode, "all_layers_flag" ); sei.m_allLayersFlag = uiCode; + if (!sei.m_allLayersFlag) + { + READ_CODE( 3, uiCode, "nesting_no_op_max_temporal_id_plus1" ); sei.m_nestingNoOpMaxTemporalIdPlus1 = uiCode; + READ_UVLC( uiCode, "nesting_num_layers_minus1" ); sei.m_nestingNumLayersMinus1 = uiCode; + for (UInt i = 0; i <= sei.m_nestingNumLayersMinus1; i++) + { + READ_CODE( 6, uiCode, "nesting_layer_id" ); sei.m_nestingLayerId[i] = uiCode; + } + } + } + + // byte alignment + while ( m_pcBitstream->getNumBitsRead() % 8 != 0 ) + { + UInt code; + READ_FLAG( code, "nesting_zero_bit" ); + } + + sei.m_callerOwnsSEIs = false; + + // read nested SEI messages + do { + xReadSEImessage(sei.m_nestedSEIs, nalUnitType, sps); + } while (m_pcBitstream->getNumBitsLeft() > 8); + +} +#endif + Void SEIReader::xParseByteAlign() { Index: /trunk/source/Lib/TLibDecoder/SEIread.h =================================================================== --- /trunk/source/Lib/TLibDecoder/SEIread.h (revision 188) +++ /trunk/source/Lib/TLibDecoder/SEIread.h (revision 189) @@ -70,4 +70,13 @@ Void xParseSEITemporalLevel0Index (SEITemporalLevel0Index &sei, UInt payloadSize); Void xParseSEIGradualDecodingRefreshInfo (SEIGradualDecodingRefreshInfo &sei, UInt payloadSize); +#if J0149_TONE_MAPPING_SEI + Void xParseSEIToneMappingInfo (SEIToneMappingInfo& sei, UInt payloadSize); +#endif +#if L0208_SOP_DESCRIPTION_SEI + Void xParseSEISOPDescription (SEISOPDescription &sei, UInt payloadSize); +#endif +#if K0180_SCALABLE_NESTING_SEI + Void xParseSEIScalableNesting (SEIScalableNesting& sei, const NalUnitType nalUnitType, UInt payloadSize, TComSPS *sps); +#endif Void xParseByteAlign(); }; Index: /trunk/source/Lib/TLibDecoder/TDecCAVLC.cpp =================================================================== --- /trunk/source/Lib/TLibDecoder/TDecCAVLC.cpp (revision 188) +++ /trunk/source/Lib/TLibDecoder/TDecCAVLC.cpp (revision 189) @@ -593,11 +593,9 @@ READ_UVLC( uiCode, "bit_depth_luma_minus8" ); - g_bitDepthY = 8 + uiCode; - pcSPS->setBitDepthY(g_bitDepthY); + pcSPS->setBitDepthY( uiCode + 8 ); pcSPS->setQpBDOffsetY( (Int) (6*uiCode) ); READ_UVLC( uiCode, "bit_depth_chroma_minus8" ); - g_bitDepthC = 8 + uiCode; - pcSPS->setBitDepthC(g_bitDepthC); + pcSPS->setBitDepthC( uiCode + 8 ); pcSPS->setQpBDOffsetC( (Int) (6*uiCode) ); @@ -608,6 +606,11 @@ for(UInt i=0; i <= pcSPS->getMaxTLayers()-1; i++) { +#if L0323_DPB + READ_UVLC ( uiCode, "sps_max_dec_pic_buffering_minus1"); + pcSPS->setMaxDecPicBuffering( uiCode + 1, i); +#else READ_UVLC ( uiCode, "sps_max_dec_pic_buffering"); pcSPS->setMaxDecPicBuffering( uiCode, i); +#endif READ_UVLC ( uiCode, "sps_num_reorder_pics" ); pcSPS->setNumReorderPics(uiCode, i); @@ -628,9 +631,11 @@ READ_UVLC( uiCode, "log2_min_coding_block_size_minus3" ); - UInt log2MinCUSize = uiCode + 3; + Int log2MinCUSize = uiCode + 3; + pcSPS->setLog2MinCodingBlockSize(log2MinCUSize); READ_UVLC( uiCode, "log2_diff_max_min_coding_block_size" ); - UInt uiMaxCUDepthCorrect = uiCode; - pcSPS->setMaxCUWidth ( 1<<(log2MinCUSize + uiMaxCUDepthCorrect) ); g_uiMaxCUWidth = 1<<(log2MinCUSize + uiMaxCUDepthCorrect); - pcSPS->setMaxCUHeight ( 1<<(log2MinCUSize + uiMaxCUDepthCorrect) ); g_uiMaxCUHeight = 1<<(log2MinCUSize + uiMaxCUDepthCorrect); + pcSPS->setLog2DiffMaxMinCodingBlockSize(uiCode); + Int maxCUDepthDelta = uiCode; + pcSPS->setMaxCUWidth ( 1<<(log2MinCUSize + maxCUDepthDelta) ); + pcSPS->setMaxCUHeight ( 1<<(log2MinCUSize + maxCUDepthDelta) ); READ_UVLC( uiCode, "log2_min_transform_block_size_minus2" ); pcSPS->setQuadtreeTULog2MinSize( uiCode + 2 ); @@ -640,14 +645,8 @@ READ_UVLC( uiCode, "max_transform_hierarchy_depth_inter" ); pcSPS->setQuadtreeTUMaxDepthInter( uiCode+1 ); READ_UVLC( uiCode, "max_transform_hierarchy_depth_intra" ); pcSPS->setQuadtreeTUMaxDepthIntra( uiCode+1 ); - g_uiAddCUDepth = 0; - while( ( pcSPS->getMaxCUWidth() >> uiMaxCUDepthCorrect ) > ( 1 << ( pcSPS->getQuadtreeTULog2MinSize() + g_uiAddCUDepth ) ) ) - { - g_uiAddCUDepth++; - } - pcSPS->setMaxCUDepth( uiMaxCUDepthCorrect+g_uiAddCUDepth ); - g_uiMaxCUDepth = uiMaxCUDepthCorrect+g_uiAddCUDepth; - // BB: these parameters may be removed completly and replaced by the fixed values - pcSPS->setMinTrDepth( 0 ); - pcSPS->setMaxTrDepth( 1 ); + + Int addCuDepth = max (0, log2MinCUSize - (Int)pcSPS->getQuadtreeTULog2MinSize() ); + pcSPS->setMaxCUDepth( maxCUDepthDelta + addCuDepth ); + READ_FLAG( uiCode, "scaling_list_enabled_flag" ); pcSPS->setScalingListFlag ( uiCode ); if(pcSPS->getScalingListFlag()) @@ -712,4 +711,16 @@ parseVUI(pcSPS->getVuiParameters(), pcSPS); } + +#if SCALED_REF_LAYER_OFFSETS + if( pcSPS->getLayerId() > 0 ) + { + Int iCode; + Window& scaledWindow = pcSPS->getScaledRefLayerWindow(); + READ_SVLC( iCode, "scaled_ref_layer_left_offset" ); scaledWindow.setWindowLeftOffset (iCode << 1); + READ_SVLC( iCode, "scaled_ref_layer_top_offset" ); scaledWindow.setWindowTopOffset (iCode << 1); + READ_SVLC( iCode, "scaled_ref_layer_right_offset" ); scaledWindow.setWindowRightOffset (iCode << 1); + READ_SVLC( iCode, "scaled_ref_layer_bottom_offset" ); scaledWindow.setWindowBottomOffset(iCode << 1); + } +#endif READ_FLAG( uiCode, "sps_extension_flag"); @@ -746,5 +757,9 @@ for(UInt i = 0; i <= pcVPS->getMaxTLayers()-1; i++) { +#if L0323_DPB + READ_UVLC( uiCode, "vps_max_dec_pic_buffering_minus1[i]" ); pcVPS->setMaxDecPicBuffering( uiCode + 1, i ); +#else READ_UVLC( uiCode, "vps_max_dec_pic_buffering[i]" ); pcVPS->setMaxDecPicBuffering( uiCode, i ); +#endif READ_UVLC( uiCode, "vps_num_reorder_pics[i]" ); pcVPS->setNumReorderPics( uiCode, i ); READ_UVLC( uiCode, "vps_max_latency_increase[i]" ); pcVPS->setMaxLatencyIncrease( uiCode, i ); @@ -785,4 +800,7 @@ } } +#if DERIVE_LAYER_ID_LIST_VARIABLES + pcVPS->deriveLayerIdListVariables(); +#endif #if L0043_TIMING_INFO TimingInfo *timingInfo = pcVPS->getTimingInfo(); @@ -900,14 +918,46 @@ } #endif +#if VPS_MOVE_DIR_DEPENDENCY_FLAG +#if VPS_EXTN_DIRECT_REF_LAYERS + // For layer 0 + vps->setNumDirectRefLayers(0, 0); + // For other layers + for( Int layerCtr = 1; layerCtr <= vps->getMaxLayers() - 1; layerCtr++) + { + UInt numDirectRefLayers = 0; + for( Int refLayerCtr = 0; refLayerCtr < layerCtr; refLayerCtr++) + { + READ_FLAG(uiCode, "direct_dependency_flag[i][j]" ); vps->setDirectDependencyFlag(layerCtr, refLayerCtr, uiCode? true : false); + if(uiCode) + { + vps->setRefLayerId(layerCtr, numDirectRefLayers, refLayerCtr); + numDirectRefLayers++; + } + } + vps->setNumDirectRefLayers(layerCtr, numDirectRefLayers); + } +#endif +#endif #if VPS_EXTN_PROFILE_INFO // Profile-tier-level signalling +#if VPS_PROFILE_OUTPUT_LAYERS + READ_CODE( 10, uiCode, "vps_number_layer_sets_minus1" ); assert( uiCode == (vps->getNumLayerSets() - 1) ); + READ_CODE( 6, uiCode, "vps_num_profile_tier_level_minus1"); vps->setNumProfileTierLevel( uiCode + 1 ); + vps->getPTLForExtnPtr()->resize(vps->getNumProfileTierLevel()); + for(Int idx = 1; idx <= vps->getNumProfileTierLevel() - 1; idx++) +#else vps->getPTLForExtnPtr()->resize(vps->getNumLayerSets()); for(Int idx = 1; idx <= vps->getNumLayerSets() - 1; idx++) +#endif { READ_FLAG( uiCode, "vps_profile_present_flag[i]" ); vps->setProfilePresentFlag(idx, uiCode ? true : false); if( !vps->getProfilePresentFlag(idx) ) { +#if VPS_PROFILE_OUTPUT_LAYERS + READ_CODE( 6, uiCode, "profile_ref_minus1[i]" ); vps->setProfileLayerSetRef(idx, uiCode + 1); +#else READ_UVLC( uiCode, "vps_profile_layer_set_ref_minus1[i]" ); vps->setProfileLayerSetRef(idx, uiCode + 1); +#endif assert( vps->getProfileLayerSetRef(idx) < idx ); // Copy profile information as indicated @@ -918,4 +968,66 @@ #endif +#if VPS_PROFILE_OUTPUT_LAYERS + READ_FLAG( uiCode, "more_output_layer_sets_than_default_flag" ); vps->setMoreOutputLayerSetsThanDefaultFlag( uiCode ? true : false ); + Int numOutputLayerSets = 0; + if(! vps->getMoreOutputLayerSetsThanDefaultFlag() ) + { + numOutputLayerSets = vps->getNumLayerSets(); + } + else + { + READ_CODE( 10, uiCode, "num_add_output_layer_sets" ); vps->setNumAddOutputLayerSets( uiCode ); + numOutputLayerSets = vps->getNumLayerSets() + vps->getNumAddOutputLayerSets(); + } + if( numOutputLayerSets > 1 ) + { + READ_FLAG( uiCode, "default_one_target_output_layer_flag" ); vps->setDefaultOneTargetOutputLayerFlag( uiCode ? true : false ); + } + vps->setNumOutputLayerSets( numOutputLayerSets ); + + for(i = 1; i < numOutputLayerSets; i++) + { + if( i > (vps->getNumLayerSets() - 1) ) + { + Int numBits = 1; + while ((1 << numBits) < (vps->getNumLayerSets() - 1)) + { + numBits++; + } + READ_CODE( numBits, uiCode, "output_layer_set_idx_minus1"); vps->setOutputLayerSetIdx( i, uiCode + 1); + Int lsIdx = vps->getOutputLayerSetIdx(i); + for(j = 0; j < vps->getNumLayersInIdList(lsIdx) - 1; j++) + { + READ_FLAG( uiCode, "output_layer_flag[i][j]"); vps->setOutputLayerFlag(i, j, uiCode); + } + } + else + { + // i <= (vps->getNumLayerSets() - 1) + // Assign OutputLayerFlag depending on default_one_target_output_layer_flag + Int lsIdx = i; + if( vps->getDefaultOneTargetOutputLayerFlag() ) + { + for(j = 0; j < vps->getNumLayersInIdList(lsIdx); j++) + { + vps->setOutputLayerFlag(i, j, (j == (vps->getNumLayersInIdList(lsIdx)-1))); + } + } + else + { + for(j = 0; j < vps->getNumLayersInIdList(lsIdx); j++) + { + vps->setOutputLayerFlag(i, j, 1); + } + } + } + Int numBits = 1; + while ((1 << numBits) < (vps->getNumProfileTierLevel())) + { + numBits++; + } + READ_CODE( numBits, uiCode, "profile_level_tier_idx[i]" ); vps->setProfileLevelTierIdx(i, uiCode); + } +#else #if VPS_EXTN_OP_LAYER_SETS // Target output layer signalling @@ -923,5 +1035,9 @@ for(i = 0; i < vps->getNumOutputLayerSets(); i++) { +#if VPS_OUTPUT_LAYER_SET_IDX + READ_UVLC( uiCode, "vps_output_layer_set_idx_minus1[i]"); vps->setOutputLayerSetIdx(i, uiCode + 1); +#else READ_UVLC( uiCode, "vps_output_layer_set_idx[i]"); vps->setOutputLayerSetIdx(i, uiCode); +#endif Int lsIdx = vps->getOutputLayerSetIdx(i); for(j = 0; j <= vps->getMaxLayerId(); j++) @@ -932,6 +1048,13 @@ } } - } -#endif + } +#endif +#endif +#if JCTVC_M0458_INTERLAYER_RPS_SIG + READ_FLAG(uiCode, "max_one_active_ref_layer_flag" ); + vps->setMaxOneActiveRefLayerFlag(uiCode); +#endif + +#if !VPS_MOVE_DIR_DEPENDENCY_FLAG #if VPS_EXTN_DIRECT_REF_LAYERS // For layer 0 @@ -952,4 +1075,5 @@ vps->setNumDirectRefLayers(layerCtr, numDirectRefLayers); } +#endif #endif } @@ -1074,6 +1198,6 @@ iPOCmsb = iPrevPOCmsb; } - if ( rpcSlice->getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA - || rpcSlice->getNalUnitType() == NAL_UNIT_CODED_SLICE_BLANT + if ( rpcSlice->getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_W_LP + || rpcSlice->getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_W_RADL || rpcSlice->getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_N_LP ) { @@ -1084,10 +1208,10 @@ TComReferencePictureSet* rps; + rps = rpcSlice->getLocalRPS(); + rpcSlice->setRPS(rps); READ_FLAG( uiCode, "short_term_ref_pic_set_sps_flag" ); if(uiCode == 0) // use short-term reference picture set explicitly signalled in slice header { - rps = rpcSlice->getLocalRPS(); parseShortTermRefPicSet(sps,rps, sps->getRPSList()->getNumberOfReferencePictureSets()); - rpcSlice->setRPS(rps); } else // use reference to short-term reference picture set in PPS @@ -1106,7 +1230,5 @@ uiCode = 0; } - rpcSlice->setRPS(sps->getRPSList()->getReferencePictureSet(uiCode)); - - rps = rpcSlice->getRPS(); + memcpy(rps,sps->getRPSList()->getReferencePictureSet(uiCode),sizeof(TComReferencePictureSet)); } if(sps->getLongTermRefsPresent()) @@ -1131,5 +1253,5 @@ rps->setNumberOfLongtermPictures(numOfLtrp); Int maxPicOrderCntLSB = 1 << rpcSlice->getSPS()->getBitsForPOC(); - Int prevLSB = 0, prevDeltaMSB = 0, deltaPocMSBCycleLT = 0;; + Int prevDeltaMSB = 0, deltaPocMSBCycleLT = 0;; for(Int j=offset+rps->getNumberOfLongtermPictures()-1, k = 0; k < numOfLtrp; j--, k++) { @@ -1158,6 +1280,6 @@ READ_UVLC( uiCode, "delta_poc_msb_cycle_lt[i]" ); Bool deltaFlag = false; - // First LTRP || First LTRP from SH || curr LSB != prev LSB - if( (j == offset+rps->getNumberOfLongtermPictures()-1) || (j == offset+(numOfLtrp-numLtrpInSPS)-1) || (pocLsbLt != prevLSB) ) + // First LTRP || First LTRP from SH + if( (j == offset+rps->getNumberOfLongtermPictures()-1) || (j == offset+(numOfLtrp-numLtrpInSPS)-1) ) { deltaFlag = true; @@ -1184,5 +1306,4 @@ rps->setCheckLTMSBPresent(j,false); } - prevLSB = pocLsbLt; prevDeltaMSB = deltaPocMSBCycleLT; } @@ -1190,6 +1311,6 @@ rps->setNumberOfPictures(offset); } - if ( rpcSlice->getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA - || rpcSlice->getNalUnitType() == NAL_UNIT_CODED_SLICE_BLANT + if ( rpcSlice->getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_W_LP + || rpcSlice->getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_W_RADL || rpcSlice->getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_N_LP ) { @@ -1202,4 +1323,6 @@ rpcSlice->setRPS(rps); } + + if (rpcSlice->getSPS()->getTMVPFlagsPresent()) { @@ -1212,4 +1335,51 @@ } } + +#if REF_IDX_FRAMEWORK +#if JCTVC_M0458_INTERLAYER_RPS_SIG + rpcSlice->setActiveNumILRRefIdx(0); + if((sps->getLayerId() > 0) && (rpcSlice->getNumILRRefIdx() > 0) ) + { + READ_FLAG(uiCode,"inter_layer_pred_enabled_flag"); + rpcSlice->setInterLayerPredEnabledFlag(uiCode); + if( rpcSlice->getInterLayerPredEnabledFlag()) + { + if(rpcSlice->getNumILRRefIdx() > 1) + { + Int numBits = 1; + while ((1 << numBits) < rpcSlice->getNumILRRefIdx()) + { + numBits++; + } + if( !rpcSlice->getVPS()->getMaxOneActiveRefLayerFlag()) + { + READ_CODE( numBits, uiCode,"num_inter_layer_ref_pics_minus1" ); + rpcSlice->setActiveNumILRRefIdx(uiCode + 1); + } + else + { + rpcSlice->setActiveNumILRRefIdx(1); + } + for(Int i = 0; i < rpcSlice->getActiveNumILRRefIdx(); i++ ) + { + READ_CODE( numBits,uiCode,"inter_layer_pred_layer_idc[i]" ); + rpcSlice->setInterLayerPredLayerIdc(uiCode,i); + } + } + else + { + rpcSlice->setActiveNumILRRefIdx(1); + rpcSlice->setInterLayerPredLayerIdc(0,0); + } + } + } +#else + if( rpcSlice->getLayerId() > 0 ) + { + rpcSlice->setNumILRRefIdx( rpcSlice->getVPS()->getNumDirectRefLayers( rpcSlice->getLayerId() ) ); + } +#endif +#endif + if(sps->getUseSAO()) { @@ -1423,6 +1593,10 @@ if(!rpcSlice->getDeblockingFilterDisable()) { - READ_SVLC( iCode, "beta_offset_div2" ); rpcSlice->setDeblockingFilterBetaOffsetDiv2(iCode); - READ_SVLC( iCode, "tc_offset_div2" ); rpcSlice->setDeblockingFilterTcOffsetDiv2(iCode); + READ_SVLC( iCode, "slice_beta_offset_div2" ); rpcSlice->setDeblockingFilterBetaOffsetDiv2(iCode); + assert(rpcSlice->getDeblockingFilterBetaOffsetDiv2() >= -6 && + rpcSlice->getDeblockingFilterBetaOffsetDiv2() <= 6); + READ_SVLC( iCode, "slice_tc_offset_div2" ); rpcSlice->setDeblockingFilterTcOffsetDiv2(iCode); + assert(rpcSlice->getDeblockingFilterTcOffsetDiv2() >= -6 && + rpcSlice->getDeblockingFilterTcOffsetDiv2() <= 6); } } @@ -1456,9 +1630,8 @@ } - if( pps->getTilesEnabledFlag() || pps->getEntropyCodingSyncEnabledFlag() ) - { UInt *entryPointOffset = NULL; UInt numEntryPointOffsets, offsetLenMinus1; - + if( pps->getTilesEnabledFlag() || pps->getEntropyCodingSyncEnabledFlag() ) + { READ_UVLC(numEntryPointOffsets, "num_entry_point_offsets"); rpcSlice->setNumEntryPointOffsets ( numEntryPointOffsets ); if (numEntryPointOffsets>0) @@ -1477,4 +1650,43 @@ #endif } + } + else + { + rpcSlice->setNumEntryPointOffsets ( 0 ); + } + + if(pps->getSliceHeaderExtensionPresentFlag()) + { + READ_UVLC(uiCode,"slice_header_extension_length"); + for(Int i=0; ireadByteAlignment(); + + if( pps->getTilesEnabledFlag() || pps->getEntropyCodingSyncEnabledFlag() ) + { + Int endOfSliceHeaderLocation = m_pcBitstream->getByteLocation(); + Int curEntryPointOffset = 0; + Int prevEntryPointOffset = 0; + for (UInt idx=0; idxnumEmulationPreventionBytesRead(); curByteIdx++ ) + { + if ( m_pcBitstream->getEmulationPreventionByteLocation( curByteIdx ) >= ( prevEntryPointOffset + endOfSliceHeaderLocation ) && + m_pcBitstream->getEmulationPreventionByteLocation( curByteIdx ) < ( curEntryPointOffset + endOfSliceHeaderLocation ) ) + { + emulationPreventionByteCount++; + } + } + + entryPointOffset[ idx ] -= emulationPreventionByteCount; + prevEntryPointOffset = curEntryPointOffset; + } if ( pps->getTilesEnabledFlag() ) @@ -1512,19 +1724,5 @@ } } - else - { - rpcSlice->setNumEntryPointOffsets ( 0 ); - } - - if(pps->getSliceHeaderExtensionPresentFlag()) - { - READ_UVLC(uiCode,"slice_header_extension_length"); - for(Int i=0; ireadByteAlignment(); + return; } @@ -1771,112 +1969,4 @@ // ==================================================================================================================== - -/** Parse PCM alignment zero bits. -* \returns Void -*/ -Void TDecCavlc::xReadPCMAlignZero( ) -{ - UInt uiNumberOfBits = m_pcBitstream->getNumBitsUntilByteAligned(); - - if(uiNumberOfBits) - { - UInt uiBits; - UInt uiSymbol; - - for(uiBits = 0; uiBits < uiNumberOfBits; uiBits++) - { - xReadFlag( uiSymbol ); - assert( uiSymbol == 0 ); - } - } -} - -Void TDecCavlc::xReadUnaryMaxSymbol( UInt& ruiSymbol, UInt uiMaxSymbol ) -{ - if (uiMaxSymbol == 0) - { - ruiSymbol = 0; - return; - } - - xReadFlag( ruiSymbol ); - - if (ruiSymbol == 0 || uiMaxSymbol == 1) - { - return; - } - - UInt uiSymbol = 0; - UInt uiCont; - - do - { - xReadFlag( uiCont ); - uiSymbol++; - } - while( uiCont && (uiSymbol < uiMaxSymbol-1) ); - - if( uiCont && (uiSymbol == uiMaxSymbol-1) ) - { - uiSymbol++; - } - - ruiSymbol = uiSymbol; -} - -Void TDecCavlc::xReadExGolombLevel( UInt& ruiSymbol ) -{ - UInt uiSymbol ; - UInt uiCount = 0; - do - { - xReadFlag( uiSymbol ); - uiCount++; - } - while( uiSymbol && (uiCount != 13)); - - ruiSymbol = uiCount-1; - - if( uiSymbol ) - { - xReadEpExGolomb( uiSymbol, 0 ); - ruiSymbol += uiSymbol+1; - } - - return; -} - -Void TDecCavlc::xReadEpExGolomb( UInt& ruiSymbol, UInt uiCount ) -{ - UInt uiSymbol = 0; - UInt uiBit = 1; - - - while( uiBit ) - { - xReadFlag( uiBit ); - uiSymbol += uiBit << uiCount++; - } - - uiCount--; - while( uiCount-- ) - { - xReadFlag( uiBit ); - uiSymbol += uiBit << uiCount; - } - - ruiSymbol = uiSymbol; - - return; -} - -UInt TDecCavlc::xGetBit() -{ - UInt ruiCode; - m_pcBitstream->read( 1, ruiCode ); - return ruiCode; -} - - /** parse explicit wp tables * \param TComSlice* pcSlice @@ -1895,8 +1985,10 @@ // decode delta_luma_log2_weight_denom : READ_UVLC( uiLog2WeightDenomLuma, "luma_log2_weight_denom" ); // ue(v): luma_log2_weight_denom + assert( uiLog2WeightDenomLuma <= 7 ); if( bChroma ) { READ_SVLC( iDeltaDenom, "delta_chroma_log2_weight_denom" ); // se(v): delta_chroma_log2_weight_denom assert((iDeltaDenom + (Int)uiLog2WeightDenomLuma)>=0); + assert((iDeltaDenom + (Int)uiLog2WeightDenomLuma)<=7); uiLog2WeightDenomChroma = (UInt)(iDeltaDenom + uiLog2WeightDenomLuma); } @@ -1937,6 +2029,10 @@ Int iDeltaWeight; READ_SVLC( iDeltaWeight, "delta_luma_weight_lX" ); // se(v): delta_luma_weight_l0[i] + assert( iDeltaWeight >= -128 ); + assert( iDeltaWeight <= 127 ); wp[0].iWeight = (iDeltaWeight + (1<= -128 ); + assert( wp[0].iOffset <= 127 ); } else @@ -1953,8 +2049,12 @@ Int iDeltaWeight; READ_SVLC( iDeltaWeight, "delta_chroma_weight_lX" ); // se(v): chroma_weight_l0[i][j] + assert( iDeltaWeight >= -128 ); + assert( iDeltaWeight <= 127 ); wp[j].iWeight = (iDeltaWeight + (1<= -512 ); + assert( iDeltaChroma <= 511 ); Int pred = ( 128 - ( ( 128*wp[j].iWeight)>>(wp[j].uiLog2WeightDenom) ) ); wp[j].iOffset = Clip3(-128, 127, (iDeltaChroma + pred) ); Index: /trunk/source/Lib/TLibDecoder/TDecCAVLC.h =================================================================== --- /trunk/source/Lib/TLibDecoder/TDecCAVLC.h (revision 188) +++ /trunk/source/Lib/TLibDecoder/TDecCAVLC.h (revision 189) @@ -61,14 +61,5 @@ protected: - Void xReadEpExGolomb ( UInt& ruiSymbol, UInt uiCount ); - Void xReadExGolombLevel ( UInt& ruiSymbol ); - Void xReadUnaryMaxSymbol ( UInt& ruiSymbol, UInt uiMaxSymbol ); - - Void xReadPCMAlignZero (); - - UInt xGetBit (); - void parseShortTermRefPicSet (TComSPS* pcSPS, TComReferencePictureSet* pcRPS, Int idx); -private: public: Index: /trunk/source/Lib/TLibDecoder/TDecCu.cpp =================================================================== --- /trunk/source/Lib/TLibDecoder/TDecCu.cpp (revision 188) +++ /trunk/source/Lib/TLibDecoder/TDecCu.cpp (revision 189) @@ -370,5 +370,5 @@ m_pcEntropyDecoder->decodePredInfo( pcCU, uiAbsPartIdx, uiDepth, m_ppcCU[uiDepth]); #endif - + // Coefficient decoding Bool bCodeDQP = getdQPFlag(); Index: /trunk/source/Lib/TLibDecoder/TDecGop.cpp =================================================================== --- /trunk/source/Lib/TLibDecoder/TDecGop.cpp (revision 188) +++ /trunk/source/Lib/TLibDecoder/TDecGop.cpp (revision 189) @@ -247,4 +247,11 @@ for (Int iRefIndex = 0; iRefIndex < pcSlice->getNumRefIdx(RefPicList(iRefList)); iRefIndex++) { +#if REF_IDX_FRAMEWORK && VPS_EXTN_DIRECT_REF_LAYERS_CONTINUE + if( pcSlice->getRefPic(RefPicList(iRefList), iRefIndex)->isILR( m_layerId ) ) + { + printf( "%d(%d) ", pcSlice->getRefPOC(RefPicList(iRefList), iRefIndex), pcSlice->getRefPic(RefPicList(iRefList), iRefIndex)->getLayerId() ); + } + else +#endif printf ("%d ", pcSlice->getRefPOC(RefPicList(iRefList), iRefIndex)); } Index: /trunk/source/Lib/TLibDecoder/TDecSlice.h =================================================================== --- /trunk/source/Lib/TLibDecoder/TDecSlice.h (revision 188) +++ /trunk/source/Lib/TLibDecoder/TDecSlice.h (revision 189) @@ -91,4 +91,5 @@ Void initCtxMem( UInt i ); Void setCtxMem( TDecSbac* sb, Int b ) { CTXMem[b] = sb; } + Int getCtxMemSize( ) { return (Int)CTXMem.size(); } #if SVC_EXTENSION TDecTop* getLayerDec ( UInt LayerId ) { return m_ppcTDecTop[LayerId]; } Index: /trunk/source/Lib/TLibDecoder/TDecTop.cpp =================================================================== --- /trunk/source/Lib/TLibDecoder/TDecTop.cpp (revision 188) +++ /trunk/source/Lib/TLibDecoder/TDecTop.cpp (revision 189) @@ -113,5 +113,4 @@ if(m_cIlpPic[i]) { - //m_cIlpPic[i]->setPicYuvRec(NULL); m_cIlpPic[i]->destroy(); delete m_cIlpPic[i]; @@ -143,4 +142,11 @@ if(m_layerId>0) { + g_bitDepthY = pcSPS->getBitDepthY(); + g_bitDepthC = pcSPS->getBitDepthC(); + g_uiMaxCUWidth = pcSPS->getMaxCUWidth(); + g_uiMaxCUHeight = pcSPS->getMaxCUHeight(); + g_uiMaxCUDepth = pcSPS->getMaxCUDepth(); + g_uiAddCUDepth = max (0, pcSPS->getLog2MinCodingBlockSize() - (Int)pcSPS->getQuadtreeTULog2MinSize() ); + Int numReorderPics[MAX_TLAYER]; Window &conformanceWindow = pcSPS->getConformanceWindow(); @@ -154,8 +160,8 @@ if (m_cIlpPic[0] == NULL) { - for (Int j=0; j<1/*MAX_NUM_REF*/; j++) - { + for (Int j=0; j< 1/*MAX_NUM_REF*/; j++) // to be set to NumDirectRefLayers[LayerIdInVps[nuh_layer_id]] + { + m_cIlpPic[j] = new TComPic; - //m_cIlpPic[j]->createWithOutYuv(m_iSourceWidth, m_iSourceHeight, g_uiMaxCUWidth, g_uiMaxCUHeight, g_uiMaxCUDepth, &m_cSPS, true); #if SVC_UPSAMPLING m_cIlpPic[j]->create(pcSPS->getPicWidthInLumaSamples(), pcSPS->getPicHeightInLumaSamples(), g_uiMaxCUWidth, g_uiMaxCUHeight, g_uiMaxCUDepth, conformanceWindow, defaultDisplayWindow, numReorderPics, pcSPS, true); @@ -176,8 +182,7 @@ if(m_cIlpPic[0]) { - //m_cIlpPic[0]->setPicYuvRec(pcPic->getFullPelBaseRec()); m_cIlpPic[0]->copyUpsampledPictureYuv(pcPic->getFullPelBaseRec(), m_cIlpPic[0]->getPicYuvRec()); m_cIlpPic[0]->getSlice(0)->setPOC(pcPic->getPOC()); - m_cIlpPic[0]->setLayerId(0); //set reference layerId + m_cIlpPic[0]->setLayerId(pcPic->getSlice(0)->getBaseColPic()->getLayerId()); //set reference layerId m_cIlpPic[0]->getPicYuvRec()->setBorderExtension(false); m_cIlpPic[0]->getPicYuvRec()->extendPicBorder(); @@ -231,5 +236,9 @@ } +#if L0323_DPB + m_iMaxRefPicNum = pcSlice->getSPS()->getMaxDecPicBuffering(pcSlice->getTLayer())+pcSlice->getSPS()->getNumReorderPics(pcSlice->getTLayer()); // m_uiMaxDecPicBuffering has the space for the picture currently being decoded +#else m_iMaxRefPicNum = pcSlice->getSPS()->getMaxDecPicBuffering(pcSlice->getTLayer())+pcSlice->getSPS()->getNumReorderPics(pcSlice->getTLayer()) + 1; // +1 to have space for the picture currently being decoded +#endif if (m_cListPic.size() < (UInt)m_iMaxRefPicNum) { @@ -239,5 +248,9 @@ if(m_layerId > 0) { +#if VPS_EXTN_DIRECT_REF_LAYERS_CONTINUE + TDecTop *pcTDecTopBase = (TDecTop *)getRefLayerDec( m_layerId ); +#else TDecTop *pcTDecTopBase = (TDecTop *)getLayerDec( m_layerId-1 ); +#endif //TComPic* pcPic = *(pcTDecTopBase->getListPic()->begin()); TComPicYuv* pcPicYuvRecBase = (*(pcTDecTopBase->getListPic()->begin()))->getPicYuvRec(); @@ -339,4 +352,5 @@ cFillSlice.setSPS( m_parameterSetManagerDecoder[m_layerId].getFirstSPS() ); cFillSlice.setPPS( m_parameterSetManagerDecoder[m_layerId].getFirstPPS() ); + cFillSlice.setVPS( m_parameterSetManagerDecoder[m_layerId].getFirstVPS() ); cFillSlice.initSlice( m_layerId ); #else @@ -350,4 +364,5 @@ cFillPic->getSlice(0)->setSPS( m_parameterSetManagerDecoder[m_layerId].getFirstSPS() ); cFillPic->getSlice(0)->setPPS( m_parameterSetManagerDecoder[m_layerId].getFirstPPS() ); + cFillPic->getSlice(0)->setVPS( m_parameterSetManagerDecoder[m_layerId].getFirstVPS() ); cFillPic->getSlice(0)->initSlice( m_layerId ); #else @@ -405,5 +420,5 @@ assert (sps != 0); - if( false == m_parameterSetManagerDecoder[m_layerId].activatePPS(m_apcSlicePilot->getPPSId(), m_apcSlicePilot->getIdrPicFlag()) ) + if( false == m_parameterSetManagerDecoder[m_layerId].activatePPS(m_apcSlicePilot->getPPSId(), m_apcSlicePilot->isIRAP()) ) #else m_parameterSetManagerDecoder.applyPrefetchedPS(); @@ -415,5 +430,5 @@ assert (sps != 0); - if (false == m_parameterSetManagerDecoder.activatePPS(m_apcSlicePilot->getPPSId(),m_apcSlicePilot->getIdrPicFlag())) + if (false == m_parameterSetManagerDecoder.activatePPS(m_apcSlicePilot->getPPSId(),m_apcSlicePilot->isIRAP())) #endif { @@ -422,16 +437,41 @@ } + if( pps->getDependentSliceSegmentsEnabledFlag() ) + { + Int NumCtx = pps->getEntropyCodingSyncEnabledFlag()?2:1; + + if (m_cSliceDecoder.getCtxMemSize() != NumCtx) + { + m_cSliceDecoder.initCtxMem(NumCtx); + for ( UInt st = 0; st < NumCtx; st++ ) + { + TDecSbac* ctx = NULL; + ctx = new TDecSbac; + ctx->init( &m_cBinCABAC ); + m_cSliceDecoder.setCtxMem( ctx, st ); + } + } + } + m_apcSlicePilot->setPPS(pps); m_apcSlicePilot->setSPS(sps); + pps->setSPS(sps); pps->setNumSubstreams(pps->getEntropyCodingSyncEnabledFlag() ? ((sps->getPicHeightInLumaSamples() + sps->getMaxCUHeight() - 1) / sps->getMaxCUHeight()) * (pps->getNumColumnsMinus1() + 1) : 1); pps->setMinCuDQPSize( sps->getMaxCUWidth() >> ( pps->getMaxCuDQPDepth()) ); - for (Int i = 0; i < sps->getMaxCUDepth() - g_uiAddCUDepth; i++) + g_bitDepthY = sps->getBitDepthY(); + g_bitDepthC = sps->getBitDepthC(); + g_uiMaxCUWidth = sps->getMaxCUWidth(); + g_uiMaxCUHeight = sps->getMaxCUHeight(); + g_uiMaxCUDepth = sps->getMaxCUDepth(); + g_uiAddCUDepth = max (0, sps->getLog2MinCodingBlockSize() - (Int)sps->getQuadtreeTULog2MinSize() ); + + for (Int i = 0; i < sps->getLog2DiffMaxMinCodingBlockSize(); i++) { sps->setAMPAcc( i, sps->getUseAMP() ); } - for (Int i = sps->getMaxCUDepth() - g_uiAddCUDepth; i < sps->getMaxCUDepth(); i++) + for (Int i = sps->getLog2DiffMaxMinCodingBlockSize(); i < sps->getMaxCUDepth(); i++) { sps->setAMPAcc( i, 0 ); @@ -439,6 +479,6 @@ m_cSAO.destroy(); - m_cSAO.create( sps->getPicWidthInLumaSamples(), sps->getPicHeightInLumaSamples(), g_uiMaxCUWidth, g_uiMaxCUHeight ); - m_cLoopFilter. create( g_uiMaxCUDepth ); + m_cSAO.create( sps->getPicWidthInLumaSamples(), sps->getPicHeightInLumaSamples(), sps->getMaxCUWidth(), sps->getMaxCUHeight() ); + m_cLoopFilter.create( sps->getMaxCUDepth() ); } @@ -451,4 +491,5 @@ TComPic*& pcPic = m_pcPic; #if SVC_EXTENSION + m_apcSlicePilot->setVPS( m_parameterSetManagerDecoder[m_layerId].getPrefetchedVPS(0) ); m_apcSlicePilot->initSlice( nalu.m_layerId ); #else @@ -467,10 +508,11 @@ m_apcSlicePilot->setNalUnitType(nalu.m_nalUnitType); - if((m_apcSlicePilot->getNalUnitType() == NAL_UNIT_CODED_SLICE_TRAIL_N) || - (m_apcSlicePilot->getNalUnitType() == NAL_UNIT_CODED_SLICE_TSA_N) || - (m_apcSlicePilot->getNalUnitType() == NAL_UNIT_CODED_SLICE_STSA_N)) - { - m_apcSlicePilot->setTemporalLayerNonReferenceFlag(true); - } + Bool nonReferenceFlag = (m_apcSlicePilot->getNalUnitType() == NAL_UNIT_CODED_SLICE_TRAIL_N || + m_apcSlicePilot->getNalUnitType() == NAL_UNIT_CODED_SLICE_TSA_N || + m_apcSlicePilot->getNalUnitType() == NAL_UNIT_CODED_SLICE_STSA_N || + m_apcSlicePilot->getNalUnitType() == NAL_UNIT_CODED_SLICE_RADL_N || + m_apcSlicePilot->getNalUnitType() == NAL_UNIT_CODED_SLICE_RASL_N); + m_apcSlicePilot->setTemporalLayerNonReferenceFlag(nonReferenceFlag); + m_apcSlicePilot->setReferenced(true); // Putting this as true ensures that picture is referenced the first time it is in an RPS m_apcSlicePilot->setTLayerInfo(nalu.m_temporalId); @@ -481,17 +523,15 @@ m_cEntropyDecoder.decodeSliceHeader (m_apcSlicePilot, &m_parameterSetManagerDecoder); #endif - if (m_apcSlicePilot->isNextSlice()) - { - // Skip pictures due to random access - if (isRandomAccessSkipPicture(iSkipFrame, iPOCLastDisplay)) - { - return false; - } - // Skip TFD pictures associated with BLA/BLANT pictures - if (isSkipPictureForBLA(iPOCLastDisplay)) - { - return false; - } - } + + // Skip pictures due to random access + if (isRandomAccessSkipPicture(iSkipFrame, iPOCLastDisplay)) + { + return false; + } + // Skip TFD pictures associated with BLA/BLANT pictures + if (isSkipPictureForBLA(iPOCLastDisplay)) + { + return false; + } // exit when a new picture is found @@ -506,5 +546,11 @@ } #else - if (m_apcSlicePilot->isNextSlice() && m_apcSlicePilot->getPOC()!=m_prevPOC && !m_bFirstSliceInSequence) + //we should only get a different poc for a new picture (with CTU address==0) + if (m_apcSlicePilot->isNextSlice() && m_apcSlicePilot->getPOC()!=m_prevPOC && !m_bFirstSliceInSequence && (!m_apcSlicePilot->getSliceCurStartCUAddr()==0)) + { + printf ("Warning, the first slice of a picture might have been lost!\n"); + } + // exit when a new picture is found + if (m_apcSlicePilot->isNextSlice() && (m_apcSlicePilot->getSliceCurStartCUAddr() == 0 && !m_bFirstSliceInPicture) && !m_bFirstSliceInSequence ) { if (m_prevPOC >= m_pocRandomAccess) @@ -537,52 +583,57 @@ { #if AVC_BASE - if( m_layerId == 1 ) - { - TComPic* pBLPic = (*m_ppcTDecTop[0]->getListPic()->begin()); - fstream* pFile = m_ppcTDecTop[0]->getBLReconFile(); - const Window &conf = pBLPic->getConformanceWindow(); - UInt uiWidth = pBLPic->getPicYuvRec()->getWidth() - conf.getWindowLeftOffset() - conf.getWindowRightOffset(); - UInt uiHeight = pBLPic->getPicYuvRec()->getHeight() - conf.getWindowTopOffset() - conf.getWindowBottomOffset(); - - if( pFile->good() ) - { - UInt64 uiPos = (UInt64) m_apcSlicePilot->getPOC() * uiWidth * uiHeight * 3 / 2; - - pFile->seekg((UInt)uiPos, ios::beg ); - - Pel* pPel = pBLPic->getPicYuvRec()->getLumaAddr(); - UInt uiStride = pBLPic->getPicYuvRec()->getStride(); - for( Int i = 0; i < uiHeight; i++ ) - { - for( Int j = 0; j < uiWidth; j++ ) + if( m_layerId == 1 && m_parameterSetManagerDecoder[0].getPrefetchedVPS(0)->getAvcBaseLayerFlag() ) + { + TComPic* pBLPic = (*m_ppcTDecTop[0]->getListPic()->begin()); + fstream* pFile = m_ppcTDecTop[0]->getBLReconFile(); +#if ILP_DECODED_PICTURE + UInt uiWidth = pBLPic->getPicYuvRec()->getWidth(); + UInt uiHeight = pBLPic->getPicYuvRec()->getHeight(); +#else + const Window &conf = pBLPic->getConformanceWindow(); + UInt uiWidth = pBLPic->getPicYuvRec()->getWidth() - conf.getWindowLeftOffset() - conf.getWindowRightOffset(); + UInt uiHeight = pBLPic->getPicYuvRec()->getHeight() - conf.getWindowTopOffset() - conf.getWindowBottomOffset(); +#endif + + if( pFile->good() ) + { + UInt64 uiPos = (UInt64) m_apcSlicePilot->getPOC() * uiWidth * uiHeight * 3 / 2; + + pFile->seekg((UInt)uiPos, ios::beg ); + + Pel* pPel = pBLPic->getPicYuvRec()->getLumaAddr(); + UInt uiStride = pBLPic->getPicYuvRec()->getStride(); + for( Int i = 0; i < uiHeight; i++ ) { - pPel[j] = pFile->get(); + for( Int j = 0; j < uiWidth; j++ ) + { + pPel[j] = pFile->get(); + } + pPel += uiStride; } - pPel += uiStride; - } - - pPel = pBLPic->getPicYuvRec()->getCbAddr(); - uiStride = pBLPic->getPicYuvRec()->getCStride(); - for( Int i = 0; i < uiHeight/2; i++ ) - { - for( Int j = 0; j < uiWidth/2; j++ ) + + pPel = pBLPic->getPicYuvRec()->getCbAddr(); + uiStride = pBLPic->getPicYuvRec()->getCStride(); + for( Int i = 0; i < uiHeight/2; i++ ) { - pPel[j] = pFile->get(); + for( Int j = 0; j < uiWidth/2; j++ ) + { + pPel[j] = pFile->get(); + } + pPel += uiStride; } - pPel += uiStride; - } - - pPel = pBLPic->getPicYuvRec()->getCrAddr(); - uiStride = pBLPic->getPicYuvRec()->getCStride(); - for( Int i = 0; i < uiHeight/2; i++ ) - { - for( Int j = 0; j < uiWidth/2; j++ ) + + pPel = pBLPic->getPicYuvRec()->getCrAddr(); + uiStride = pBLPic->getPicYuvRec()->getCStride(); + for( Int i = 0; i < uiHeight/2; i++ ) { - pPel[j] = pFile->get(); + for( Int j = 0; j < uiWidth/2; j++ ) + { + pPel[j] = pFile->get(); + } + pPel += uiStride; } - pPel += uiStride; - } - } - } + } + } #endif @@ -732,11 +783,11 @@ if (bNextSlice) { - pcSlice->checkCRA(pcSlice->getRPS(), m_pocCRA, m_prevRAPisBLA ); + pcSlice->checkCRA(pcSlice->getRPS(), m_pocCRA, m_prevRAPisBLA, m_cListPic ); // Set reference list -#if REF_LIST_BUGFIX +#if REF_IDX_FRAMEWORK if (m_layerId == 0) - { - pcSlice->setRefPicList( m_cListPic ); - } +#endif +#if FIX1071 + pcSlice->setRefPicList( m_cListPic, true ); #else pcSlice->setRefPicList( m_cListPic ); @@ -747,20 +798,36 @@ { #if AVC_BASE - pcSlice->setBaseColPic ( *m_ppcTDecTop[0]->getListPic()->begin() ); + if( m_parameterSetManagerDecoder[0].getActiveVPS()->getAvcBaseLayerFlag() ) + { + pcSlice->setBaseColPic ( *m_ppcTDecTop[0]->getListPic()->begin() ); #if AVC_SYNTAX - TComPic* pBLPic = pcSlice->getBaseColPic(); - if( pcSlice->getPOC() == 0 ) - { - // initialize partition order. - UInt* piTmp = &g_auiZscanToRaster[0]; - initZscanToRaster( pBLPic->getPicSym()->getMaxDepth() + 1, 1, 0, piTmp ); - initRasterToZscan( pBLPic->getPicSym()->getMaxCUWidth(), pBLPic->getPicSym()->getMaxCUHeight(), pBLPic->getPicSym()->getMaxDepth() + 1 ); - } - pBLPic->getSlice( 0 )->initBaseLayerRPL( pcSlice ); - pBLPic->readBLSyntax( m_ppcTDecTop[0]->getBLSyntaxFile(), SYNTAX_BYTES ); -#endif - + TComPic* pBLPic = pcSlice->getBaseColPic(); + if( pcSlice->getPOC() == 0 ) + { + // initialize partition order. + UInt* piTmp = &g_auiZscanToRaster[0]; + initZscanToRaster( pBLPic->getPicSym()->getMaxDepth() + 1, 1, 0, piTmp ); + initRasterToZscan( pBLPic->getPicSym()->getMaxCUWidth(), pBLPic->getPicSym()->getMaxCUHeight(), pBLPic->getPicSym()->getMaxDepth() + 1 ); + } + pBLPic->getSlice( 0 )->initBaseLayerRPL( pcSlice ); + pBLPic->readBLSyntax( m_ppcTDecTop[0]->getBLSyntaxFile(), SYNTAX_BYTES ); +#endif + } + else + { +#if VPS_EXTN_DIRECT_REF_LAYERS_CONTINUE + TDecTop *pcTDecTop = (TDecTop *)getRefLayerDec( m_layerId ); +#else + TDecTop *pcTDecTop = (TDecTop *)getLayerDec( m_layerId-1 ); +#endif + TComList *cListPic = pcTDecTop->getListPic(); + pcSlice->setBaseColPic ( *cListPic, m_layerId ); + } +#else +#if VPS_EXTN_DIRECT_REF_LAYERS_CONTINUE + TDecTop *pcTDecTop = (TDecTop *)getRefLayerDec( m_layerId ); #else TDecTop *pcTDecTop = (TDecTop *)getLayerDec( m_layerId-1 ); +#endif TComList *cListPic = pcTDecTop->getListPic(); pcSlice->setBaseColPic ( *cListPic, m_layerId ); @@ -769,5 +836,9 @@ if ( pcPic->isSpatialEnhLayer()) { +#if SCALED_REF_LAYER_OFFSETS + m_cPrediction.upsampleBasePic( pcPic->getFullPelBaseRec(), pcSlice->getBaseColPic()->getPicYuvRec(), pcPic->getPicYuvRec(), pcSlice->getSPS()->getScaledRefLayerWindow() ); +#else m_cPrediction.upsampleBasePic( pcPic->getFullPelBaseRec(), pcSlice->getBaseColPic()->getPicYuvRec(), pcPic->getPicYuvRec() ); +#endif } else @@ -778,5 +849,4 @@ #endif } -#endif #if REF_IDX_FRAMEWORK @@ -785,16 +855,14 @@ setILRPic(pcPic); #if REF_IDX_MFM - pcSlice->setRefPOCListILP(m_ppcTDecTop[m_layerId]->m_cIlpPic, pcSlice->getBaseColPic()); -#endif -#if REF_LIST_BUGFIX - pcSlice->setRefPicListSvc( m_cListPic, m_cIlpPic); -#else - pcSlice->addRefPicList ( m_cIlpPic, - 1, - ((pcSlice->getNalUnitType() >= NAL_UNIT_CODED_SLICE_BLA) && - (pcSlice->getNalUnitType() <= NAL_UNIT_CODED_SLICE_CRA)) ? 0: -1); -#endif - } -#endif + if( pcSlice->getSPS()->getMFMEnabledFlag() ) + { + pcSlice->setRefPOCListILP(m_ppcTDecTop[m_layerId]->m_cIlpPic, pcSlice->getBaseColPic()); + } +#endif + pcSlice->setRefPicList( m_cListPic, false, m_cIlpPic); + } +#endif + +#endif //SVC_EXTENSION // For generalized B @@ -839,4 +907,5 @@ //--------------- pcSlice->setRefPOCList(); +#if !L0034_COMBINED_LIST_CLEANUP pcSlice->setNoBackPredFlag( false ); if ( pcSlice->getSliceType() == B_SLICE ) @@ -855,4 +924,5 @@ } } +#endif } @@ -878,4 +948,33 @@ m_cTrQuant.setUseScalingList(false); } + +#if SIMPLIFIED_MV_POS_SCALING + if (m_layerId > 0) + { +#if SCALED_REF_LAYER_OFFSETS + const Window &scalEL = pcSlice->getSPS()->getScaledRefLayerWindow(); + + Int widthBL = pcSlice->getBaseColPic()->getPicYuvRec()->getWidth(); + Int heightBL = pcSlice->getBaseColPic()->getPicYuvRec()->getHeight(); + + Int widthEL = pcPic->getPicYuvRec()->getWidth() - scalEL.getWindowLeftOffset() - scalEL.getWindowRightOffset(); + Int heightEL = pcPic->getPicYuvRec()->getHeight() - scalEL.getWindowTopOffset() - scalEL.getWindowBottomOffset(); +#else + const Window &confBL = pcSlice->getBaseColPic()->getPicYuvRec()->getConformanceWindow(); + const Window &confEL = pcPic->getPicYuvRec()->getConformanceWindow(); + + Int widthBL = pcSlice->getBaseColPic()->getPicYuvRec()->getWidth () - confBL.getWindowLeftOffset() - confBL.getWindowRightOffset(); + Int heightBL = pcSlice->getBaseColPic()->getPicYuvRec()->getHeight() - confBL.getWindowTopOffset() - confBL.getWindowBottomOffset(); + + Int widthEL = pcPic->getPicYuvRec()->getWidth() - confEL.getWindowLeftOffset() - confEL.getWindowRightOffset(); + Int heightEL = pcPic->getPicYuvRec()->getHeight() - confEL.getWindowTopOffset() - confEL.getWindowBottomOffset(); +#endif + g_mvScalingFactor[m_layerId][0] = Clip3(-4096, 4095, ((widthEL << 8) + (widthBL >> 1)) / widthBL); + g_mvScalingFactor[m_layerId][1] = Clip3(-4096, 4095, ((heightEL << 8) + (heightBL >> 1)) / heightBL); + + g_posScalingFactor[m_layerId][0] = ((widthBL << 16) + (widthEL >> 1)) / widthEL; + g_posScalingFactor[m_layerId][1] = ((heightBL << 16) + (heightEL >> 1)) / heightEL; + } +#endif // Decode a picture @@ -947,5 +1046,5 @@ { #if SVC_EXTENSION - if(nalUnitType == NAL_UNIT_SEI_SUFFIX) + if(nalUnitType == NAL_UNIT_SUFFIX_SEI) { m_seiReader.parseSEImessage( bs, m_pcPic->getSEIs(), nalUnitType, m_parameterSetManagerDecoder[m_layerId].getActiveSPS() ); @@ -967,5 +1066,5 @@ } #else - if(nalUnitType == NAL_UNIT_SEI_SUFFIX) + if(nalUnitType == NAL_UNIT_SUFFIX_SEI) { m_seiReader.parseSEImessage( bs, m_pcPic->getSEIs(), nalUnitType, m_parameterSetManagerDecoder.getActiveSPS() ); @@ -1003,4 +1102,26 @@ case NAL_UNIT_VPS: xDecodeVPS(); +#if AVC_BASE + if( m_parameterSetManagerDecoder[0].getPrefetchedVPS(0)->getAvcBaseLayerFlag() ) + { + if( !m_ppcTDecTop[0]->getBLReconFile()->good() ) + { + printf( "Base layer YUV input reading error\n" ); + exit(EXIT_FAILURE); + } +#if AVC_SYNTAX + if( !m_ppcTDecTop[0]->getBLSyntaxFile()->good() ) + { + printf( "Base layer syntax input reading error\n" ); + exit(EXIT_FAILURE); + } +#endif + } + else + { + TComList *cListPic = m_ppcTDecTop[0]->getListPic(); + cListPic->clear(); + } +#endif return false; @@ -1008,4 +1129,5 @@ xDecodeSPS(); #if AVC_BASE + if( m_parameterSetManagerDecoder[0].getPrefetchedVPS(0)->getAvcBaseLayerFlag() ) { TComPic* pBLPic = (*m_ppcTDecTop[0]->getListPic()->begin()); @@ -1019,10 +1141,10 @@ #if AVC_SYNTAX - pBLPic->create( m_ppcTDecTop[0]->getBLWidth(), m_ppcTDecTop[0]->getBLHeight(), g_uiMaxCUWidth, g_uiMaxCUHeight, g_uiMaxCUDepth, conformanceWindow, defaultDisplayWindow, numReorderPics, sps, true); -#else - pBLPic->create( m_ppcTDecTop[0]->getBLWidth(), m_ppcTDecTop[0]->getBLHeight(), g_uiMaxCUWidth, g_uiMaxCUHeight, g_uiMaxCUDepth, conformanceWindow, defaultDisplayWindow, numReorderPics, NULL, true); -#endif -#else - pBLPic->create( m_ppcTDecTop[0]->getBLWidth(), m_ppcTDecTop[0]->getBLHeight(), g_uiMaxCUWidth, g_uiMaxCUHeight, g_uiMaxCUDepth, onformanceWindow, defaultDisplayWindow, numReorderPics, true); + pBLPic->create( m_ppcTDecTop[0]->getBLWidth(), m_ppcTDecTop[0]->getBLHeight(), sps->getMaxCUWidth(), sps->getMaxCUHeight(), sps->getMaxCUDepth(), conformanceWindow, defaultDisplayWindow, numReorderPics, sps, true); +#else + pBLPic->create( m_ppcTDecTop[0]->getBLWidth(), m_ppcTDecTop[0]->getBLHeight(), sps->getMaxCUWidth(), sps->getMaxCUHeight(), sps->getMaxCUDepth(), conformanceWindow, defaultDisplayWindow, numReorderPics, NULL, true); +#endif +#else + pBLPic->create( m_ppcTDecTop[0]->getBLWidth(), m_ppcTDecTop[0]->getBLHeight(), sps->getMaxCUWidth(), sps->getMaxCUHeight(), sps->getMaxCUDepth(), onformanceWindow, defaultDisplayWindow, numReorderPics, true); #endif } @@ -1035,6 +1157,6 @@ return false; - case NAL_UNIT_SEI: - case NAL_UNIT_SEI_SUFFIX: + case NAL_UNIT_PREFIX_SEI: + case NAL_UNIT_SUFFIX_SEI: xDecodeSEI( nalu.m_Bitstream, nalu.m_nalUnitType ); return false; @@ -1042,18 +1164,18 @@ case NAL_UNIT_CODED_SLICE_TRAIL_R: case NAL_UNIT_CODED_SLICE_TRAIL_N: - case NAL_UNIT_CODED_SLICE_TLA: + case NAL_UNIT_CODED_SLICE_TLA_R: case NAL_UNIT_CODED_SLICE_TSA_N: case NAL_UNIT_CODED_SLICE_STSA_R: case NAL_UNIT_CODED_SLICE_STSA_N: - case NAL_UNIT_CODED_SLICE_BLA: - case NAL_UNIT_CODED_SLICE_BLANT: + case NAL_UNIT_CODED_SLICE_BLA_W_LP: + case NAL_UNIT_CODED_SLICE_BLA_W_RADL: case NAL_UNIT_CODED_SLICE_BLA_N_LP: - case NAL_UNIT_CODED_SLICE_IDR: + case NAL_UNIT_CODED_SLICE_IDR_W_RADL: case NAL_UNIT_CODED_SLICE_IDR_N_LP: case NAL_UNIT_CODED_SLICE_CRA: case NAL_UNIT_CODED_SLICE_RADL_N: - case NAL_UNIT_CODED_SLICE_DLP: + case NAL_UNIT_CODED_SLICE_RADL_R: case NAL_UNIT_CODED_SLICE_RASL_N: - case NAL_UNIT_CODED_SLICE_TFD: + case NAL_UNIT_CODED_SLICE_RASL_R: #if SVC_EXTENSION return xDecodeSlice(nalu, iSkipFrame, iPOCLastDisplay, curLayerId, bNewPOC); @@ -1077,5 +1199,5 @@ Bool TDecTop::isSkipPictureForBLA(Int& iPOCLastDisplay) { - if (m_prevRAPisBLA && m_apcSlicePilot->getPOC() < m_pocCRA && (m_apcSlicePilot->getNalUnitType() == NAL_UNIT_CODED_SLICE_TFD || m_apcSlicePilot->getNalUnitType() == NAL_UNIT_CODED_SLICE_RASL_N)) + if (m_prevRAPisBLA && m_apcSlicePilot->getPOC() < m_pocCRA && (m_apcSlicePilot->getNalUnitType() == NAL_UNIT_CODED_SLICE_RASL_R || m_apcSlicePilot->getNalUnitType() == NAL_UNIT_CODED_SLICE_RASL_N)) { iPOCLastDisplay++; @@ -1108,12 +1230,12 @@ { if ( m_apcSlicePilot->getNalUnitType() == NAL_UNIT_CODED_SLICE_CRA - || m_apcSlicePilot->getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA + || m_apcSlicePilot->getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_W_LP || m_apcSlicePilot->getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_N_LP - || m_apcSlicePilot->getNalUnitType() == NAL_UNIT_CODED_SLICE_BLANT ) + || m_apcSlicePilot->getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_W_RADL ) { // set the POC random access since we need to skip the reordered pictures in the case of CRA/CRANT/BLA/BLANT. m_pocRandomAccess = m_apcSlicePilot->getPOC(); } - else if ( m_apcSlicePilot->getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR || m_apcSlicePilot->getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR_N_LP ) + else if ( m_apcSlicePilot->getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR_W_RADL || m_apcSlicePilot->getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR_N_LP ) { m_pocRandomAccess = -MAX_INT; // no need to skip the reordered pictures in IDR, they are decodable. @@ -1131,5 +1253,5 @@ } // skip the reordered pictures, if necessary - else if (m_apcSlicePilot->getPOC() < m_pocRandomAccess && (m_apcSlicePilot->getNalUnitType() == NAL_UNIT_CODED_SLICE_TFD || m_apcSlicePilot->getNalUnitType() == NAL_UNIT_CODED_SLICE_RASL_N)) + else if (m_apcSlicePilot->getPOC() < m_pocRandomAccess && (m_apcSlicePilot->getNalUnitType() == NAL_UNIT_CODED_SLICE_RASL_R || m_apcSlicePilot->getNalUnitType() == NAL_UNIT_CODED_SLICE_RASL_N)) { iPOCLastDisplay++; @@ -1140,3 +1262,26 @@ } +#if VPS_EXTN_DIRECT_REF_LAYERS_CONTINUE +TDecTop* TDecTop::getRefLayerDec( UInt layerId ) +{ + TComVPS* vps = m_parameterSetManagerDecoder[0].getActiveVPS(); + if( vps->getNumDirectRefLayers( m_layerId ) <= 0 ) + { +#if ZERO_NUM_DIRECT_LAYERS + return (TDecTop *)getLayerDec( 0 ); +#else + return NULL; +#endif + } + + // currently only one reference layer is supported + assert( vps->getNumDirectRefLayers( m_layerId ) == 1 ); +#if JCTVC_M0458_INTERLAYER_RPS_SIG + assert( vps->getMaxOneActiveRefLayerFlag() == 1 ); +#endif + + return (TDecTop *)getLayerDec( vps->getRefLayerId( m_layerId, 0 ) ); +} +#endif + //! \} Index: /trunk/source/Lib/TLibDecoder/TDecTop.h =================================================================== --- /trunk/source/Lib/TLibDecoder/TDecTop.h (revision 188) +++ /trunk/source/Lib/TLibDecoder/TDecTop.h (revision 189) @@ -154,6 +154,9 @@ Void setNumLayer (UInt uiNum) { m_numLayer = uiNum; } TComList* getListPic() { return &m_cListPic; } - Void setLayerDec(TDecTop **p) { m_ppcTDecTop = p; } - TDecTop* getLayerDec(UInt layer) { return m_ppcTDecTop[layer]; } + Void setLayerDec(TDecTop **p) { m_ppcTDecTop = p; } + TDecTop* getLayerDec(UInt layer) { return m_ppcTDecTop[layer]; } +#if VPS_EXTN_DIRECT_REF_LAYERS_CONTINUE + TDecTop* getRefLayerDec(UInt layerId); +#endif #if AVC_BASE Void setBLReconFile( fstream* pFile ) { m_pBLReconFile = pFile; } Index: /trunk/source/Lib/TLibEncoder/SEIwrite.cpp =================================================================== --- /trunk/source/Lib/TLibEncoder/SEIwrite.cpp (revision 188) +++ /trunk/source/Lib/TLibEncoder/SEIwrite.cpp (revision 189) @@ -84,4 +84,19 @@ fprintf( g_hTrace, "=========== Decoding Unit Information SEI message ===========\n"); break; +#if J0149_TONE_MAPPING_SEI + case SEI::TONE_MAPPING_INFO: + fprintf( g_hTrace, "=========== Tone Mapping Info SEI message ===========\n"); + break; +#endif +#if L0208_SOP_DESCRIPTION_SEI + case SEI::SOP_DESCRIPTION: + fprintf( g_hTrace, "=========== SOP Description SEI message ===========\n"); + break; +#endif +#if K0180_SCALABLE_NESTING_SEI + case SEI::SCALABLE_NESTING: + fprintf( g_hTrace, "=========== Scalable Nesting SEI message ===========\n"); + break; +#endif default: fprintf( g_hTrace, "=========== Unknown SEI message ===========\n"); @@ -91,5 +106,9 @@ #endif +#if K0180_SCALABLE_NESTING_SEI +void SEIWriter::xWriteSEIpayloadData(TComBitIf& bs, const SEI& sei, TComSPS *sps) +#else void SEIWriter::xWriteSEIpayloadData(const SEI& sei, TComSPS *sps) +#endif { switch (sei.payloadType()) @@ -128,4 +147,19 @@ xWriteSEIGradualDecodingRefreshInfo(*static_cast(&sei)); break; +#if J0149_TONE_MAPPING_SEI + case SEI::TONE_MAPPING_INFO: + xWriteSEIToneMappingInfo(*static_cast(&sei)); + break; +#endif +#if L0208_SOP_DESCRIPTION_SEI + case SEI::SOP_DESCRIPTION: + xWriteSEISOPDescription(*static_cast(&sei)); + break; +#endif +#if K0180_SCALABLE_NESTING_SEI + case SEI::SCALABLE_NESTING: + xWriteSEIScalableNesting(bs, *static_cast(&sei), sps); + break; +#endif default: assert(!"Unhandled SEI message"); @@ -145,4 +179,18 @@ setBitstream(&bs_count); + +#if K0180_SCALABLE_NESTING_SEI + +#if ENC_DEC_TRACE + Bool traceEnable = g_HLSTraceEnable; + g_HLSTraceEnable = false; +#endif + xWriteSEIpayloadData(bs_count, sei, sps); +#if ENC_DEC_TRACE + g_HLSTraceEnable = traceEnable; +#endif + +#else + #if ENC_DEC_TRACE g_HLSTraceEnable = false; @@ -152,4 +200,7 @@ g_HLSTraceEnable = true; #endif + +#endif + UInt payload_data_num_bits = bs_count.getNumberOfWrittenBits(); assert(0 == payload_data_num_bits % 8); @@ -158,4 +209,7 @@ #if ENC_DEC_TRACE +#if K0180_SCALABLE_NESTING_SEI + if (g_HLSTraceEnable) +#endif xTraceSEIHeader(); #endif @@ -177,8 +231,15 @@ /* payloadData */ #if ENC_DEC_TRACE +#if K0180_SCALABLE_NESTING_SEI + if (g_HLSTraceEnable) +#endif xTraceSEIMessageType(sei.payloadType()); #endif +#if K0180_SCALABLE_NESTING_SEI + xWriteSEIpayloadData(bs, sei, sps); +#else xWriteSEIpayloadData(sei, sps); +#endif } @@ -421,4 +482,79 @@ xWriteByteAlign(); } + +#if J0149_TONE_MAPPING_SEI +Void SEIWriter::xWriteSEIToneMappingInfo(const SEIToneMappingInfo& sei) +{ + Int i; + WRITE_UVLC( sei.m_toneMapId, "tone_map_id" ); + WRITE_FLAG( sei.m_toneMapCancelFlag, "tone_map_cancel_flag" ); + if( !sei.m_toneMapCancelFlag ) + { + WRITE_FLAG( sei.m_toneMapPersistenceFlag, "tone_map_persistence_flag" ); + WRITE_CODE( sei.m_codedDataBitDepth, 8, "coded_data_bit_depth" ); + WRITE_CODE( sei.m_targetBitDepth, 8, "target_bit_depth" ); + WRITE_UVLC( sei.m_modelId, "model_id" ); + switch(sei.m_modelId) + { + case 0: + { + WRITE_CODE( sei.m_minValue, 32, "min_value" ); + WRITE_CODE( sei.m_maxValue, 32, "max_value" ); + break; + } + case 1: + { + WRITE_CODE( sei.m_sigmoidMidpoint, 32, "sigmoid_midpoint" ); + WRITE_CODE( sei.m_sigmoidWidth, 32, "sigmoid_width" ); + break; + } + case 2: + { + UInt num = 1u << sei.m_targetBitDepth; + for(i = 0; i < num; i++) + { + WRITE_CODE( sei.m_startOfCodedInterval[i], (( sei.m_codedDataBitDepth + 7 ) >> 3 ) << 3, "start_of_coded_interval" ); + } + break; + } + case 3: + { + WRITE_CODE( sei.m_numPivots, 16, "num_pivots" ); + for(i = 0; i < sei.m_numPivots; i++ ) + { + WRITE_CODE( sei.m_codedPivotValue[i], (( sei.m_codedDataBitDepth + 7 ) >> 3 ) << 3, "coded_pivot_value" ); + WRITE_CODE( sei.m_targetPivotValue[i], (( sei.m_targetBitDepth + 7 ) >> 3 ) << 3, "target_pivot_value"); + } + break; + } + case 4: + { + WRITE_CODE( sei.m_cameraIsoSpeedIdc, 8, "camera_iso_speed_idc" ); + if( sei.m_cameraIsoSpeedIdc == 255) //Extended_ISO + { + WRITE_CODE( sei.m_cameraIsoSpeedValue, 32, "camera_iso_speed_value" ); + } + WRITE_FLAG( sei.m_exposureCompensationValueSignFlag, "exposure_compensation_value_sign_flag" ); + WRITE_CODE( sei.m_exposureCompensationValueNumerator, 16, "exposure_compensation_value_numerator" ); + WRITE_CODE( sei.m_exposureCompensationValueDenomIdc, 16, "exposure_compensation_value_denom_idc" ); + WRITE_CODE( sei.m_refScreenLuminanceWhite, 32, "ref_screen_luminance_white" ); + WRITE_CODE( sei.m_extendedRangeWhiteLevel, 32, "extended_range_white_level" ); + WRITE_CODE( sei.m_nominalBlackLevelLumaCodeValue, 16, "nominal_black_level_luma_code_value" ); + WRITE_CODE( sei.m_nominalWhiteLevelLumaCodeValue, 16, "nominal_white_level_luma_code_value" ); + WRITE_CODE( sei.m_extendedWhiteLevelLumaCodeValue, 16, "extended_white_level_luma_code_value" ); + break; + } + default: + { + assert(!"Undefined SEIToneMapModelId"); + break; + } + }//switch m_modelId + }//if(!sei.m_toneMapCancelFlag) + + xWriteByteAlign(); +} +#endif + Void SEIWriter::xWriteSEIDisplayOrientation(const SEIDisplayOrientation &sei) { @@ -455,4 +591,71 @@ } +#if L0208_SOP_DESCRIPTION_SEI +Void SEIWriter::xWriteSEISOPDescription(const SEISOPDescription& sei) +{ + WRITE_UVLC( sei.m_sopSeqParameterSetId, "sop_seq_parameter_set_id" ); + WRITE_UVLC( sei.m_numPicsInSopMinus1, "num_pics_in_sop_minus1" ); + for (UInt i = 0; i <= sei.m_numPicsInSopMinus1; i++) + { + WRITE_CODE( sei.m_sopDescVclNaluType[i], 6, "sop_desc_vcl_nalu_type" ); + WRITE_CODE( sei.m_sopDescTemporalId[i], 3, "sop_desc_temporal_id" ); + if (sei.m_sopDescVclNaluType[i] != NAL_UNIT_CODED_SLICE_IDR_W_RADL && sei.m_sopDescVclNaluType[i] != NAL_UNIT_CODED_SLICE_IDR_N_LP) + { + WRITE_UVLC( sei.m_sopDescStRpsIdx[i], "sop_desc_st_rps_idx" ); + } + if (i > 0) + { + WRITE_SVLC( sei.m_sopDescPocDelta[i], "sop_desc_poc_delta" ); + } + } + + xWriteByteAlign(); +} +#endif + +#if K0180_SCALABLE_NESTING_SEI +Void SEIWriter::xWriteSEIScalableNesting(TComBitIf& bs, const SEIScalableNesting& sei, TComSPS *sps) +{ + WRITE_FLAG( sei.m_bitStreamSubsetFlag, "bitstream_subset_flag" ); + WRITE_FLAG( sei.m_nestingOpFlag, "nesting_op_flag " ); + if (sei.m_nestingOpFlag) + { + WRITE_FLAG( sei.m_defaultOpFlag, "default_op_flag" ); + WRITE_UVLC( sei.m_nestingNumOpsMinus1, "nesting_num_ops" ); + for (UInt i = (sei.m_defaultOpFlag ? 1 : 0); i <= sei.m_nestingNumOpsMinus1; i++) + { + WRITE_CODE( sei.m_nestingNoOpMaxTemporalIdPlus1, 3, "nesting_no_op_max_temporal_id" ); + WRITE_CODE( sei.m_nestingMaxTemporalIdPlus1[i], 3, "nesting_max_temporal_id" ); + WRITE_UVLC( sei.m_nestingOpIdx[i], "nesting_op_idx" ); + } + } + else + { + WRITE_FLAG( sei.m_allLayersFlag, "all_layers_flag" ); + if (!sei.m_allLayersFlag) + { + WRITE_CODE( sei.m_nestingNoOpMaxTemporalIdPlus1, 3, "nesting_no_op_max_temporal_id" ); + WRITE_UVLC( sei.m_nestingNumLayersMinus1, "nesting_num_layers" ); + for (UInt i = 0; i <= sei.m_nestingNumLayersMinus1; i++) + { + WRITE_CODE( sei.m_nestingLayerId[i], 6, "nesting_layer_id" ); + } + } + } + + // byte alignment + while ( m_pcBitIf->getNumberOfWrittenBits() % 8 != 0 ) + { + WRITE_FLAG( 0, "nesting_zero_bit" ); + } + + // write nested SEI messages + for (SEIMessages::const_iterator it = sei.m_nestedSEIs.begin(); it != sei.m_nestedSEIs.end(); it++) + { + writeSEImessage(bs, *(*it), sps); + } +} +#endif + Void SEIWriter::xWriteByteAlign() { Index: /trunk/source/Lib/TLibEncoder/SEIwrite.h =================================================================== --- /trunk/source/Lib/TLibEncoder/SEIwrite.h (revision 188) +++ /trunk/source/Lib/TLibEncoder/SEIwrite.h (revision 189) @@ -50,5 +50,9 @@ protected: +#if K0180_SCALABLE_NESTING_SEI + Void xWriteSEIpayloadData(TComBitIf& bs, const SEI& sei, TComSPS *sps); +#else Void xWriteSEIpayloadData(const SEI& sei, TComSPS *sps); +#endif Void xWriteSEIuserDataUnregistered(const SEIuserDataUnregistered &sei); Void xWriteSEIActiveParameterSets(const SEIActiveParameterSets& sei); @@ -63,4 +67,13 @@ Void xWriteSEITemporalLevel0Index(const SEITemporalLevel0Index &sei); Void xWriteSEIGradualDecodingRefreshInfo(const SEIGradualDecodingRefreshInfo &sei); +#if J0149_TONE_MAPPING_SEI + Void xWriteSEIToneMappingInfo(const SEIToneMappingInfo& sei); +#endif +#if L0208_SOP_DESCRIPTION_SEI + Void xWriteSEISOPDescription(const SEISOPDescription& sei); +#endif +#if K0180_SCALABLE_NESTING_SEI + Void xWriteSEIScalableNesting(TComBitIf& bs, const SEIScalableNesting& sei, TComSPS *sps); +#endif Void xWriteByteAlign(); }; Index: /trunk/source/Lib/TLibEncoder/TEncCavlc.cpp =================================================================== --- /trunk/source/Lib/TLibEncoder/TEncCavlc.cpp (revision 188) +++ /trunk/source/Lib/TLibEncoder/TEncCavlc.cpp (revision 189) @@ -39,5 +39,5 @@ #include "TEncCavlc.h" #include "SEIwrite.h" - +#include //! \ingroup TLibEncoder //! \{ @@ -285,5 +285,4 @@ WRITE_FLAG(pcVUI->getNeutralChromaIndicationFlag(), "neutral_chroma_indication_flag"); WRITE_FLAG(pcVUI->getFieldSeqFlag(), "field_seq_flag"); - assert(pcVUI->getFieldSeqFlag() == 0); // not currently supported WRITE_FLAG(pcVUI->getFrameFieldInfoPresentFlag(), "frame_field_info_present_flag"); @@ -474,5 +473,9 @@ for(UInt i=0; i <= pcSPS->getMaxTLayers()-1; i++) { +#if L0323_DPB + WRITE_UVLC( pcSPS->getMaxDecPicBuffering(i) - 1, "sps_max_dec_pic_buffering_minus1[i]" ); +#else WRITE_UVLC( pcSPS->getMaxDecPicBuffering(i), "sps_max_dec_pic_buffering[i]" ); +#endif WRITE_UVLC( pcSPS->getNumReorderPics(i), "sps_num_reorder_pics[i]" ); WRITE_UVLC( pcSPS->getMaxLatencyIncrease(i), "sps_max_latency_increase[i]" ); @@ -484,14 +487,6 @@ assert( pcSPS->getMaxCUWidth() == pcSPS->getMaxCUHeight() ); - UInt MinCUSize = pcSPS->getMaxCUWidth() >> ( pcSPS->getMaxCUDepth()-g_uiAddCUDepth ); - UInt log2MinCUSize = 0; - while(MinCUSize > 1) - { - MinCUSize >>= 1; - log2MinCUSize++; - } - - WRITE_UVLC( log2MinCUSize - 3, "log2_min_coding_block_size_minus3" ); - WRITE_UVLC( pcSPS->getMaxCUDepth()-g_uiAddCUDepth, "log2_diff_max_min_coding_block_size" ); + WRITE_UVLC( pcSPS->getLog2MinCodingBlockSize() - 3, "log2_min_coding_block_size_minus3" ); + WRITE_UVLC( pcSPS->getLog2DiffMaxMinCodingBlockSize(), "log2_diff_max_min_coding_block_size" ); WRITE_UVLC( pcSPS->getQuadtreeTULog2MinSize() - 2, "log2_min_transform_block_size_minus2" ); WRITE_UVLC( pcSPS->getQuadtreeTULog2MaxSize() - pcSPS->getQuadtreeTULog2MinSize(), "log2_diff_max_min_transform_block_size" ); @@ -558,4 +553,14 @@ codeVUI(pcSPS->getVuiParameters(), pcSPS); } +#if SCALED_REF_LAYER_OFFSETS + if( pcSPS->getLayerId() > 0 ) + { + Window scaledWindow = pcSPS->getScaledRefLayerWindow(); + WRITE_SVLC( scaledWindow.getWindowLeftOffset() >> 1, "scaled_ref_layer_left_offset" ); + WRITE_SVLC( scaledWindow.getWindowTopOffset() >> 1, "scaled_ref_layer_top_offset" ); + WRITE_SVLC( scaledWindow.getWindowRightOffset() >> 1, "scaled_ref_layer_right_offset" ); + WRITE_SVLC( scaledWindow.getWindowBottomOffset() >> 1, "scaled_ref_layer_bottom_offset" ); + } +#endif WRITE_FLAG( 0, "sps_extension_flag" ); @@ -583,5 +588,9 @@ for(UInt i=0; i <= pcVPS->getMaxTLayers()-1; i++) { +#if L0323_DPB + WRITE_UVLC( pcVPS->getMaxDecPicBuffering(i) - 1, "vps_max_dec_pic_buffering_minus1[i]" ); +#else WRITE_UVLC( pcVPS->getMaxDecPicBuffering(i), "vps_max_dec_pic_buffering[i]" ); +#endif WRITE_UVLC( pcVPS->getNumReorderPics(i), "vps_num_reorder_pics[i]" ); WRITE_UVLC( pcVPS->getMaxLatencyIncrease(i), "vps_max_latency_increase[i]" ); @@ -623,4 +632,7 @@ } } +#if DERIVE_LAYER_ID_LIST_VARIABLES + pcVPS->deriveLayerIdListVariables(); +#endif #if L0043_TIMING_INFO TimingInfo *timingInfo = pcVPS->getTimingInfo(); @@ -703,16 +715,74 @@ } #endif +#if VPS_MOVE_DIR_DEPENDENCY_FLAG +#if VPS_EXTN_DIRECT_REF_LAYERS + for( Int layerCtr = 1; layerCtr <= vps->getMaxLayers() - 1; layerCtr++) + { + for( Int refLayerCtr = 0; refLayerCtr < layerCtr; refLayerCtr++) + { + WRITE_FLAG(vps->getDirectDependencyFlag(layerCtr, refLayerCtr), "direct_dependency_flag[i][j]" ); + } + } +#endif +#endif #if VPS_EXTN_PROFILE_INFO // Profile-tier-level signalling +#if VPS_PROFILE_OUTPUT_LAYERS + WRITE_CODE( vps->getNumLayerSets() - 1 , 10, "vps_number_layer_sets_minus1" ); + WRITE_CODE( vps->getNumProfileTierLevel() - 1, 6, "vps_num_profile_tier_level_minus1"); + for(Int idx = 1; idx <= vps->getNumProfileTierLevel() - 1; idx++) +#else for(Int idx = 1; idx <= vps->getNumLayerSets() - 1; idx++) +#endif { WRITE_FLAG( vps->getProfilePresentFlag(idx), "vps_profile_present_flag[i]" ); if( !vps->getProfilePresentFlag(idx) ) { +#if VPS_PROFILE_OUTPUT_LAYERS + WRITE_CODE( vps->getProfileLayerSetRef(idx) - 1, 6, "profile_ref_minus1[i]" ); +#else WRITE_UVLC( vps->getProfileLayerSetRef(idx) - 1, "vps_profile_layer_set_ref_minus1[i]" ); +#endif } codePTL( vps->getPTLForExtn(idx), vps->getProfilePresentFlag(idx), vps->getMaxTLayers() - 1 ); } #endif + +#if VPS_PROFILE_OUTPUT_LAYERS + Int numOutputLayerSets = vps->getNumOutputLayerSets() ; + WRITE_FLAG( (numOutputLayerSets > vps->getNumLayerSets()), "more_output_layer_sets_than_default_flag" ); + if(numOutputLayerSets > vps->getNumLayerSets()) + { + WRITE_CODE( numOutputLayerSets - vps->getNumLayerSets(), 10, "num_add_output_layer_sets" ); + } + if( numOutputLayerSets > 1 ) + { + WRITE_FLAG( vps->getDefaultOneTargetOutputLayerFlag(), "default_one_target_output_layer_flag" ); + } + + for(i = 1; i < numOutputLayerSets; i++) + { + if( i > (vps->getNumLayerSets() - 1) ) + { + Int numBits = 1; + while ((1 << numBits) < (vps->getNumLayerSets() - 1)) + { + numBits++; + } + WRITE_CODE( vps->getOutputLayerSetIdx(i) - 1, numBits, "output_layer_set_idx_minus1"); + Int lsIdx = vps->getOutputLayerSetIdx(i); + for(j = 0; j < vps->getNumLayersInIdList(lsIdx) - 1; j++) + { + WRITE_FLAG( vps->getOutputLayerFlag(i,j), "output_layer_flag[i][j]"); + } + } + Int numBits = 1; + while ((1 << numBits) < (vps->getNumProfileTierLevel())) + { + numBits++; + } + WRITE_CODE( vps->getProfileLevelTierIdx(i), numBits, "profile_level_tier_idx[i]" ); + } +#else #if VPS_EXTN_OP_LAYER_SETS // Target output layer signalling @@ -720,5 +790,10 @@ for(i = 0; i < vps->getNumOutputLayerSets(); i++) { +#if VPS_OUTPUT_LAYER_SET_IDX + assert(vps->getOutputLayerSetIdx(i) > 0); + WRITE_UVLC( vps->getOutputLayerSetIdx(i) - 1, "vps_output_layer_set_idx_minus1[i]"); +#else WRITE_UVLC( vps->getOutputLayerSetIdx(i), "vps_output_layer_set_idx[i]"); +#endif Int lsIdx = vps->getOutputLayerSetIdx(i); for(j = 0; j <= vps->getMaxLayerId(); j++) @@ -731,4 +806,9 @@ } #endif +#endif +#if JCTVC_M0458_INTERLAYER_RPS_SIG + WRITE_FLAG(vps->getMaxOneActiveRefLayerFlag(), "max_one_active_ref_layer_flag"); +#endif +#if !VPS_MOVE_DIR_DEPENDENCY_FLAG #if VPS_EXTN_DIRECT_REF_LAYERS for( Int layerCtr = 1; layerCtr <= vps->getMaxLayers() - 1; layerCtr++) @@ -739,4 +819,5 @@ } } +#endif #endif } @@ -810,5 +891,35 @@ WRITE_CODE( picOrderCntLSB, pcSlice->getSPS()->getBitsForPOC(), "pic_order_cnt_lsb"); TComReferencePictureSet* rps = pcSlice->getRPS(); + +#if FIX1071 + // Deal with bitstream restriction stating that: + // – If the current picture is a BLA or CRA picture, the value of NumPocTotalCurr shall be equal to 0. + // Ideally this process should not be repeated for each slice in a picture + TComReferencePictureSet altRps; + Bool useAltRps = false; +#if SVC_EXTENSION + if( pcSlice->getLayerId() == 0 ) +#endif + if (pcSlice->getRapPicFlag()) + { + for (Int picIdx = 0; !useAltRps && picIdx < rps->getNumberOfPictures(); picIdx++) + { + useAltRps = rps->getUsed(picIdx); + } + if (useAltRps) + { + memcpy(&altRps, rps, sizeof(TComReferencePictureSet)); + rps = &altRps; + for (Int picIdx = 0; picIdx < rps->getNumberOfPictures(); picIdx++) + { + rps->setUsed(picIdx, false); + } + } + } + + if(pcSlice->getRPSidx() < 0 || useAltRps) +#else if(pcSlice->getRPSidx() < 0) +#endif { WRITE_FLAG( 0, "short_term_ref_pic_set_sps_flag"); @@ -902,4 +1013,5 @@ } } + if (pcSlice->getSPS()->getTMVPFlagsPresent()) { @@ -907,4 +1019,29 @@ } } + +#if JCTVC_M0458_INTERLAYER_RPS_SIG + if((pcSlice->getSPS()->getLayerId() > 0) && (pcSlice->getNumILRRefIdx() > 0) ) + { + WRITE_FLAG(pcSlice->getInterLayerPredEnabledFlag(),"inter_layer_pred_enabled_flag"); + if( pcSlice->getInterLayerPredEnabledFlag()) + { + if(pcSlice->getNumILRRefIdx() > 1) + { + Int numBits = 1; + while ((1 << numBits) < pcSlice->getNumILRRefIdx()) + { + numBits++; + } + if( !pcSlice->getVPS()->getMaxOneActiveRefLayerFlag()) + { + WRITE_CODE(pcSlice->getNumInterLayerRefPics(), numBits,"num_inter_layer_ref_pics_minus1"); + } + for(Int i = 0; i < pcSlice->getActiveNumILRRefIdx(); i++ ) + WRITE_CODE(pcSlice->getInterLayerPredLayerIdc(i),numBits,"inter_layer_pred_layer_idc[i]"); + } + } + } +#endif + if(pcSlice->getSPS()->getUseSAO()) { @@ -1065,4 +1202,5 @@ } } + if(pcSlice->getPPS()->getSliceHeaderExtensionPresentFlag()) { @@ -1389,82 +1527,4 @@ // ==================================================================================================================== - -/** Write PCM alignment bits. - * \returns Void - */ -Void TEncCavlc::xWritePCMAlignZero () -{ - m_pcBitIf->writeAlignZero(); -} - -Void TEncCavlc::xWriteUnaryMaxSymbol( UInt uiSymbol, UInt uiMaxSymbol ) -{ - if (uiMaxSymbol == 0) - { - return; - } - xWriteFlag( uiSymbol ? 1 : 0 ); - if ( uiSymbol == 0 ) - { - return; - } - - Bool bCodeLast = ( uiMaxSymbol > uiSymbol ); - - while( --uiSymbol ) - { - xWriteFlag( 1 ); - } - if( bCodeLast ) - { - xWriteFlag( 0 ); - } - return; -} - -Void TEncCavlc::xWriteExGolombLevel( UInt uiSymbol ) -{ - if( uiSymbol ) - { - xWriteFlag( 1 ); - UInt uiCount = 0; - Bool bNoExGo = (uiSymbol < 13); - - while( --uiSymbol && ++uiCount < 13 ) - { - xWriteFlag( 1 ); - } - if( bNoExGo ) - { - xWriteFlag( 0 ); - } - else - { - xWriteEpExGolomb( uiSymbol, 0 ); - } - } - else - { - xWriteFlag( 0 ); - } - return; -} - -Void TEncCavlc::xWriteEpExGolomb( UInt uiSymbol, UInt uiCount ) -{ - while( uiSymbol >= (UInt)(1<>uiCount) & 1 ); - } - return; -} - /** code explicit wp tables * \param TComSlice* pcSlice Index: /trunk/source/Lib/TLibEncoder/TEncCavlc.h =================================================================== --- /trunk/source/Lib/TLibEncoder/TEncCavlc.h (revision 188) +++ /trunk/source/Lib/TLibEncoder/TEncCavlc.h (revision 189) @@ -68,9 +68,4 @@ TComSlice* m_pcSlice; UInt m_uiCoeffCost; - - Void xWritePCMAlignZero (); - Void xWriteEpExGolomb ( UInt uiSymbol, UInt uiCount ); - Void xWriteExGolombLevel ( UInt uiSymbol ); - Void xWriteUnaryMaxSymbol ( UInt uiSymbol, UInt uiMaxSymbol ); Void codeShortTermRefPicSet ( TComSPS* pcSPS, TComReferencePictureSet* pcRPS, Bool calledFromSliceHeader, Int idx ); Index: /trunk/source/Lib/TLibEncoder/TEncCfg.h =================================================================== --- /trunk/source/Lib/TLibEncoder/TEncCfg.h (revision 188) +++ /trunk/source/Lib/TLibEncoder/TEncCfg.h (revision 189) @@ -158,4 +158,7 @@ Int m_loopFilterTcOffsetDiv2; Bool m_DeblockingFilterControlPresent; +#if L0386_DB_METRIC + Bool m_DeblockingFilterMetric; +#endif Bool m_bUseSAO; Int m_maxNumOffsetsPerPic; @@ -188,5 +191,7 @@ Bool m_bUseASR; Bool m_bUseHADME; +#if !L0034_COMBINED_LIST_CLEANUP Bool m_bUseLComb; +#endif Bool m_useRDOQ; Bool m_useRDOQTS; @@ -234,4 +239,31 @@ Int m_pictureTimingSEIEnabled; Int m_recoveryPointSEIEnabled; +#if J0149_TONE_MAPPING_SEI + Bool m_toneMappingInfoSEIEnabled; + Int m_toneMapId; + Bool m_toneMapCancelFlag; + Bool m_toneMapPersistenceFlag; + Int m_codedDataBitDepth; + Int m_targetBitDepth; + Int m_modelId; + Int m_minValue; + Int m_maxValue; + Int m_sigmoidMidpoint; + Int m_sigmoidWidth; + Int m_numPivots; + Int m_cameraIsoSpeedIdc; + Int m_cameraIsoSpeedValue; + Int m_exposureCompensationValueSignFlag; + Int m_exposureCompensationValueNumerator; + Int m_exposureCompensationValueDenomIdc; + Int m_refScreenLuminanceWhite; + Int m_extendedRangeWhiteLevel; + Int m_nominalBlackLevelLumaCodeValue; + Int m_nominalWhiteLevelLumaCodeValue; + Int m_extendedWhiteLevelLumaCodeValue; + Int* m_startOfCodedInterval; + Int* m_codedPivotValue; + Int* m_targetPivotValue; +#endif Int m_framePackingSEIEnabled; Int m_framePackingSEIType; @@ -243,4 +275,10 @@ Int m_gradualDecodingRefreshInfoEnabled; Int m_decodingUnitInfoSEIEnabled; +#if L0208_SOP_DESCRIPTION_SEI + Int m_SOPDescriptionSEIEnabled; +#endif +#if K0180_SCALABLE_NESTING_SEI + Int m_scalableNestingSEIEnabled; +#endif //====== Weighted Prediction ======== Bool m_useWeightedPred; //< Use of Weighting Prediction (P_SLICE) @@ -379,4 +417,7 @@ Void setLoopFilterTcOffset ( Int i ) { m_loopFilterTcOffsetDiv2 = i; } Void setDeblockingFilterControlPresent ( Bool b ) { m_DeblockingFilterControlPresent = b; } +#if L0386_DB_METRIC + Void setDeblockingFilterMetric ( Bool b ) { m_DeblockingFilterMetric = b; } +#endif //====== Motion search ======== @@ -433,4 +474,7 @@ Int getLoopFilterTcOffset () { return m_loopFilterTcOffsetDiv2; } Bool getDeblockingFilterControlPresent() { return m_DeblockingFilterControlPresent; } +#if L0386_DB_METRIC + Bool getDeblockingFilterMetric () { return m_DeblockingFilterMetric; } +#endif //==== Motion search ======== @@ -450,5 +494,7 @@ Void setUseASR ( Bool b ) { m_bUseASR = b; } Void setUseHADME ( Bool b ) { m_bUseHADME = b; } +#if !L0034_COMBINED_LIST_CLEANUP Void setUseLComb ( Bool b ) { m_bUseLComb = b; } +#endif Void setUseRDOQ ( Bool b ) { m_useRDOQ = b; } Void setUseRDOQTS ( Bool b ) { m_useRDOQTS = b; } @@ -472,5 +518,7 @@ Bool getUseASR () { return m_bUseASR; } Bool getUseHADME () { return m_bUseHADME; } +#if !L0034_COMBINED_LIST_CLEANUP Bool getUseLComb () { return m_bUseLComb; } +#endif Bool getUseRDOQ () { return m_useRDOQ; } Bool getUseRDOQTS () { return m_useRDOQTS; } @@ -569,4 +617,56 @@ Void setRecoveryPointSEIEnabled(Int b) { m_recoveryPointSEIEnabled = b; } Int getRecoveryPointSEIEnabled() { return m_recoveryPointSEIEnabled; } +#if J0149_TONE_MAPPING_SEI + Void setToneMappingInfoSEIEnabled(Bool b) { m_toneMappingInfoSEIEnabled = b; } + Bool getToneMappingInfoSEIEnabled() { return m_toneMappingInfoSEIEnabled; } + Void setTMISEIToneMapId(Int b) { m_toneMapId = b; } + Int getTMISEIToneMapId() { return m_toneMapId; } + Void setTMISEIToneMapCancelFlag(Bool b) { m_toneMapCancelFlag=b; } + Bool getTMISEIToneMapCancelFlag() { return m_toneMapCancelFlag; } + Void setTMISEIToneMapPersistenceFlag(Bool b) { m_toneMapPersistenceFlag = b; } + Bool getTMISEIToneMapPersistenceFlag() { return m_toneMapPersistenceFlag; } + Void setTMISEICodedDataBitDepth(Int b) { m_codedDataBitDepth = b; } + Int getTMISEICodedDataBitDepth() { return m_codedDataBitDepth; } + Void setTMISEITargetBitDepth(Int b) { m_targetBitDepth = b; } + Int getTMISEITargetBitDepth() { return m_targetBitDepth; } + Void setTMISEIModelID(Int b) { m_modelId = b; } + Int getTMISEIModelID() { return m_modelId; } + Void setTMISEIMinValue(Int b) { m_minValue = b; } + Int getTMISEIMinValue() { return m_minValue; } + Void setTMISEIMaxValue(Int b) { m_maxValue = b; } + Int getTMISEIMaxValue() { return m_maxValue; } + Void setTMISEISigmoidMidpoint(Int b) { m_sigmoidMidpoint = b; } + Int getTMISEISigmoidMidpoint() { return m_sigmoidMidpoint; } + Void setTMISEISigmoidWidth(Int b) { m_sigmoidWidth = b; } + Int getTMISEISigmoidWidth() { return m_sigmoidWidth; } + Void setTMISEIStartOfCodedInterva( Int* p ) { m_startOfCodedInterval = p; } + Int* getTMISEIStartOfCodedInterva() { return m_startOfCodedInterval; } + Void setTMISEINumPivots(Int b) { m_numPivots = b; } + Int getTMISEINumPivots() { return m_numPivots; } + Void setTMISEICodedPivotValue( Int* p ) { m_codedPivotValue = p; } + Int* getTMISEICodedPivotValue() { return m_codedPivotValue; } + Void setTMISEITargetPivotValue( Int* p ) { m_targetPivotValue = p; } + Int* getTMISEITargetPivotValue() { return m_targetPivotValue; } + Void setTMISEICameraIsoSpeedIdc(Int b) { m_cameraIsoSpeedIdc = b; } + Int getTMISEICameraIsoSpeedIdc() { return m_cameraIsoSpeedIdc; } + Void setTMISEICameraIsoSpeedValue(Int b) { m_cameraIsoSpeedValue = b; } + Int getTMISEICameraIsoSpeedValue() { return m_cameraIsoSpeedValue; } + Void setTMISEIExposureCompensationValueSignFlag(Int b) { m_exposureCompensationValueSignFlag = b; } + Int getTMISEIExposureCompensationValueSignFlag() { return m_exposureCompensationValueSignFlag; } + Void setTMISEIExposureCompensationValueNumerator(Int b) { m_exposureCompensationValueNumerator = b; } + Int getTMISEIExposureCompensationValueNumerator() { return m_exposureCompensationValueNumerator; } + Void setTMISEIExposureCompensationValueDenomIdc(Int b) { m_exposureCompensationValueDenomIdc =b; } + Int getTMISEIExposureCompensationValueDenomIdc() { return m_exposureCompensationValueDenomIdc; } + Void setTMISEIRefScreenLuminanceWhite(Int b) { m_refScreenLuminanceWhite = b; } + Int getTMISEIRefScreenLuminanceWhite() { return m_refScreenLuminanceWhite; } + Void setTMISEIExtendedRangeWhiteLevel(Int b) { m_extendedRangeWhiteLevel = b; } + Int getTMISEIExtendedRangeWhiteLevel() { return m_extendedRangeWhiteLevel; } + Void setTMISEINominalBlackLevelLumaCodeValue(Int b) { m_nominalBlackLevelLumaCodeValue = b; } + Int getTMISEINominalBlackLevelLumaCodeValue() { return m_nominalBlackLevelLumaCodeValue; } + Void setTMISEINominalWhiteLevelLumaCodeValue(Int b) { m_nominalWhiteLevelLumaCodeValue = b; } + Int getTMISEINominalWhiteLevelLumaCodeValue() { return m_nominalWhiteLevelLumaCodeValue; } + Void setTMISEIExtendedWhiteLevelLumaCodeValue(Int b) { m_extendedWhiteLevelLumaCodeValue =b; } + Int getTMISEIExtendedWhiteLevelLumaCodeValue() { return m_extendedWhiteLevelLumaCodeValue; } +#endif Void setFramePackingArrangementSEIEnabled(Int b) { m_framePackingSEIEnabled = b; } Int getFramePackingArrangementSEIEnabled() { return m_framePackingSEIEnabled; } @@ -587,4 +687,12 @@ Void setDecodingUnitInfoSEIEnabled(Int b) { m_decodingUnitInfoSEIEnabled = b; } Int getDecodingUnitInfoSEIEnabled() { return m_decodingUnitInfoSEIEnabled; } +#if L0208_SOP_DESCRIPTION_SEI + Void setSOPDescriptionSEIEnabled(Int b) { m_SOPDescriptionSEIEnabled = b; } + Int getSOPDescriptionSEIEnabled() { return m_SOPDescriptionSEIEnabled; } +#endif +#if K0180_SCALABLE_NESTING_SEI + Void setScalableNestingSEIEnabled(Int b) { m_scalableNestingSEIEnabled = b; } + Int getScalableNestingSEIEnabled() { return m_scalableNestingSEIEnabled; } +#endif Void setUseWP ( Bool b ) { m_useWeightedPred = b; } Void setWPBiPred ( Bool b ) { m_useWeightedBiPred = b; } Index: /trunk/source/Lib/TLibEncoder/TEncGOP.cpp =================================================================== --- /trunk/source/Lib/TLibEncoder/TEncGOP.cpp (revision 188) +++ /trunk/source/Lib/TLibEncoder/TEncGOP.cpp (revision 189) @@ -96,4 +96,7 @@ #if L0045_NON_NESTED_SEI_RESTRICTIONS xResetNonNestedSEIPresentFlags(); +#if K0180_SCALABLE_NESTING_SEI + xResetNestedSEIPresentFlags(); +#endif #endif #if SVC_UPSAMPLING @@ -134,4 +137,5 @@ m_pcSliceEncoder = pcTEncTop->getSliceEncoder(); m_pcListPic = pcTEncTop->getListPic(); + m_pcEntropyCoder = pcTEncTop->getEntropyCoder(); m_pcCavlcCoder = pcTEncTop->getCavlcCoder(); @@ -210,7 +214,94 @@ } +#if J0149_TONE_MAPPING_SEI +SEIToneMappingInfo* TEncGOP::xCreateSEIToneMappingInfo() +{ + SEIToneMappingInfo *seiToneMappingInfo = new SEIToneMappingInfo(); + seiToneMappingInfo->m_toneMapId = m_pcCfg->getTMISEIToneMapId(); + seiToneMappingInfo->m_toneMapCancelFlag = m_pcCfg->getTMISEIToneMapCancelFlag(); + seiToneMappingInfo->m_toneMapPersistenceFlag = m_pcCfg->getTMISEIToneMapPersistenceFlag(); + + seiToneMappingInfo->m_codedDataBitDepth = m_pcCfg->getTMISEICodedDataBitDepth(); + assert(seiToneMappingInfo->m_codedDataBitDepth >= 8 && seiToneMappingInfo->m_codedDataBitDepth <= 14); + seiToneMappingInfo->m_targetBitDepth = m_pcCfg->getTMISEITargetBitDepth(); + assert( (seiToneMappingInfo->m_targetBitDepth >= 1 && seiToneMappingInfo->m_targetBitDepth <= 17) || (seiToneMappingInfo->m_targetBitDepth == 255) ); + seiToneMappingInfo->m_modelId = m_pcCfg->getTMISEIModelID(); + assert(seiToneMappingInfo->m_modelId >=0 &&seiToneMappingInfo->m_modelId<=4); + + switch( seiToneMappingInfo->m_modelId) + { + case 0: + { + seiToneMappingInfo->m_minValue = m_pcCfg->getTMISEIMinValue(); + seiToneMappingInfo->m_maxValue = m_pcCfg->getTMISEIMaxValue(); + break; + } + case 1: + { + seiToneMappingInfo->m_sigmoidMidpoint = m_pcCfg->getTMISEISigmoidMidpoint(); + seiToneMappingInfo->m_sigmoidWidth = m_pcCfg->getTMISEISigmoidWidth(); + break; + } + case 2: + { + UInt num = 1u<<(seiToneMappingInfo->m_targetBitDepth); + seiToneMappingInfo->m_startOfCodedInterval.resize(num); + Int* ptmp = m_pcCfg->getTMISEIStartOfCodedInterva(); + if(ptmp) + { + for(int i=0; im_startOfCodedInterval[i] = ptmp[i]; + } + } + break; + } + case 3: + { + seiToneMappingInfo->m_numPivots = m_pcCfg->getTMISEINumPivots(); + seiToneMappingInfo->m_codedPivotValue.resize(seiToneMappingInfo->m_numPivots); + seiToneMappingInfo->m_targetPivotValue.resize(seiToneMappingInfo->m_numPivots); + Int* ptmpcoded = m_pcCfg->getTMISEICodedPivotValue(); + Int* ptmptarget = m_pcCfg->getTMISEITargetPivotValue(); + if(ptmpcoded&&ptmptarget) + { + for(int i=0; i<(seiToneMappingInfo->m_numPivots);i++) + { + seiToneMappingInfo->m_codedPivotValue[i]=ptmpcoded[i]; + seiToneMappingInfo->m_targetPivotValue[i]=ptmptarget[i]; + } + } + break; + } + case 4: + { + seiToneMappingInfo->m_cameraIsoSpeedIdc = m_pcCfg->getTMISEICameraIsoSpeedIdc(); + seiToneMappingInfo->m_cameraIsoSpeedValue = m_pcCfg->getTMISEICameraIsoSpeedValue(); + assert( seiToneMappingInfo->m_cameraIsoSpeedValue !=0 ); + seiToneMappingInfo->m_exposureCompensationValueSignFlag = m_pcCfg->getTMISEIExposureCompensationValueSignFlag(); + seiToneMappingInfo->m_exposureCompensationValueNumerator = m_pcCfg->getTMISEIExposureCompensationValueNumerator(); + seiToneMappingInfo->m_exposureCompensationValueDenomIdc = m_pcCfg->getTMISEIExposureCompensationValueDenomIdc(); + seiToneMappingInfo->m_refScreenLuminanceWhite = m_pcCfg->getTMISEIRefScreenLuminanceWhite(); + seiToneMappingInfo->m_extendedRangeWhiteLevel = m_pcCfg->getTMISEIExtendedRangeWhiteLevel(); + assert( seiToneMappingInfo->m_extendedRangeWhiteLevel >= 100 ); + seiToneMappingInfo->m_nominalBlackLevelLumaCodeValue = m_pcCfg->getTMISEINominalBlackLevelLumaCodeValue(); + seiToneMappingInfo->m_nominalWhiteLevelLumaCodeValue = m_pcCfg->getTMISEINominalWhiteLevelLumaCodeValue(); + assert( seiToneMappingInfo->m_nominalWhiteLevelLumaCodeValue > seiToneMappingInfo->m_nominalBlackLevelLumaCodeValue ); + seiToneMappingInfo->m_extendedWhiteLevelLumaCodeValue = m_pcCfg->getTMISEIExtendedWhiteLevelLumaCodeValue(); + assert( seiToneMappingInfo->m_extendedWhiteLevelLumaCodeValue >= seiToneMappingInfo->m_nominalWhiteLevelLumaCodeValue ); + break; + } + default: + { + assert(!"Undefined SEIToneMapModelId"); + break; + } + } + return seiToneMappingInfo; +} +#endif Void TEncGOP::xCreateLeadingSEIMessages (/*SEIMessages seiMessages,*/ AccessUnit &accessUnit, TComSPS *sps) { - OutputNALUnit nalu(NAL_UNIT_SEI); + OutputNALUnit nalu(NAL_UNIT_PREFIX_SEI); if(m_pcCfg->getActiveParameterSetsSEIEnabled()) @@ -233,5 +324,5 @@ SEIFramePacking *sei = xCreateSEIFramePacking (); - nalu = NALUnit(NAL_UNIT_SEI); + nalu = NALUnit(NAL_UNIT_PREFIX_SEI); m_pcEntropyCoder->setBitstream(&nalu.m_Bitstream); m_seiWriter.writeSEImessage(nalu.m_Bitstream, *sei, sps); @@ -244,5 +335,5 @@ SEIDisplayOrientation *sei = xCreateSEIDisplayOrientation(); - nalu = NALUnit(NAL_UNIT_SEI); + nalu = NALUnit(NAL_UNIT_PREFIX_SEI); m_pcEntropyCoder->setBitstream(&nalu.m_Bitstream); m_seiWriter.writeSEImessage(nalu.m_Bitstream, *sei, sps); @@ -251,4 +342,17 @@ delete sei; } +#if J0149_TONE_MAPPING_SEI + if(m_pcCfg->getToneMappingInfoSEIEnabled()) + { + SEIToneMappingInfo *sei = xCreateSEIToneMappingInfo (); + + nalu = NALUnit(NAL_UNIT_PREFIX_SEI); + m_pcEntropyCoder->setBitstream(&nalu.m_Bitstream); + m_seiWriter.writeSEImessage(nalu.m_Bitstream, *sei, sps); + writeRBSPTrailingBits(nalu.m_Bitstream); + accessUnit.push_back(new NALUnitEBSP(nalu)); + delete sei; + } +#endif } @@ -276,4 +380,19 @@ m_iNumPicCoded = 0; SEIPictureTiming pictureTimingSEI; +#if L0208_SOP_DESCRIPTION_SEI + Bool writeSOP = m_pcCfg->getSOPDescriptionSEIEnabled(); +#endif +#if K0180_SCALABLE_NESTING_SEI + // Initialize Scalable Nesting SEI with single layer values + SEIScalableNesting scalableNestingSEI; + scalableNestingSEI.m_bitStreamSubsetFlag = 1; // If the nested SEI messages are picture buffereing SEI mesages, picure timing SEI messages or sub-picture timing SEI messages, bitstream_subset_flag shall be equal to 1 + scalableNestingSEI.m_nestingOpFlag = 0; + scalableNestingSEI.m_nestingNumOpsMinus1 = 0; //nesting_num_ops_minus1 + scalableNestingSEI.m_allLayersFlag = 0; + scalableNestingSEI.m_nestingNoOpMaxTemporalIdPlus1 = 6 + 1; //nesting_no_op_max_temporal_id_plus1 + scalableNestingSEI.m_nestingNumLayersMinus1 = 1 - 1; //nesting_num_layers_minus1 + scalableNestingSEI.m_nestingLayerId[0] = 0; + scalableNestingSEI.m_callerOwnsSEIs = true; +#endif #if L0044_DU_DPB_OUTPUT_DELAY_HRD Int picSptDpbOutputDuDelay = 0; @@ -348,5 +467,5 @@ } - if( getNalUnitType(pocCurr) == NAL_UNIT_CODED_SLICE_IDR || getNalUnitType(pocCurr) == NAL_UNIT_CODED_SLICE_IDR_N_LP ) + if( getNalUnitType(pocCurr, m_iLastIDR) == NAL_UNIT_CODED_SLICE_IDR_W_RADL || getNalUnitType(pocCurr, m_iLastIDR) == NAL_UNIT_CODED_SLICE_IDR_N_LP ) { m_iLastIDR = pocCurr; @@ -364,7 +483,8 @@ #if SVC_EXTENSION pcPic->setLayerId( m_layerId ); -#endif - + m_pcSliceEncoder->initEncSlice ( pcPic, iPOCLast, pocCurr, iNumPicRcvd, iGOPid, pcSlice, m_pcEncTop->getSPS(), m_pcEncTop->getPPS(), m_pcEncTop->getVPS() ); +#else m_pcSliceEncoder->initEncSlice ( pcPic, iPOCLast, pocCurr, iNumPicRcvd, iGOPid, pcSlice, m_pcEncTop->getSPS(), m_pcEncTop->getPPS() ); +#endif pcSlice->setLastIDR(m_iLastIDR); pcSlice->setSliceIdx(0); @@ -411,9 +531,13 @@ } // Set the nal unit type - pcSlice->setNalUnitType(getNalUnitType(pocCurr)); + pcSlice->setNalUnitType(getNalUnitType(pocCurr, m_iLastIDR)); #if IDR_ALIGNMENT if (m_layerId > 0) { +#if VPS_EXTN_DIRECT_REF_LAYERS_CONTINUE + TComList *cListPic = m_ppcTEncTop[m_layerId]->getRefLayerEnc(m_layerId)->getListPic(); +#else TComList *cListPic = m_ppcTEncTop[m_layerId-1]->getListPic(); +#endif pcSlice->setBaseColPic (*cListPic, m_layerId ); } @@ -424,7 +548,7 @@ { #if IDR_ALIGNMENT - if( pcSlice->getBaseColPic()->getSlice(0)->getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR ) - { - pcSlice->setNalUnitType(NAL_UNIT_CODED_SLICE_IDR); + if( pcSlice->getBaseColPic()->getSlice(0)->getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR_W_RADL || pcSlice->getBaseColPic()->getSlice(0)->getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR_N_LP ) + { + pcSlice->setNalUnitType(pcSlice->getBaseColPic()->getSlice(0)->getNalUnitType()); } else @@ -432,7 +556,14 @@ pcSlice->setNalUnitType(NAL_UNIT_CODED_SLICE_CRA); } +#if ZERO_NUM_DIRECT_LAYERS + if( m_layerId > 0 && pcSlice->getActiveNumILRRefIdx() == 0 && pcSlice->getNalUnitType() >= NAL_UNIT_CODED_SLICE_BLA_W_LP && pcSlice->getNalUnitType() <= NAL_UNIT_CODED_SLICE_CRA ) + { + pcSlice->setSliceType(I_SLICE); + } + else +#endif if( m_layerId > 0 && !m_pcEncTop->getElRapSliceTypeB() ) { - if( (pcSlice->getNalUnitType() >= NAL_UNIT_CODED_SLICE_BLA) && + if( (pcSlice->getNalUnitType() >= NAL_UNIT_CODED_SLICE_BLA_W_LP) && (pcSlice->getNalUnitType() <= NAL_UNIT_CODED_SLICE_CRA) && pcSlice->getSliceType() == B_SLICE ) @@ -442,9 +573,17 @@ } #endif - if(pcSlice->getNalUnitType()==NAL_UNIT_CODED_SLICE_TRAIL_R) - { - if(pcSlice->getTemporalLayerNonReferenceFlag()) + if(pcSlice->getTemporalLayerNonReferenceFlag()) + { + if(pcSlice->getNalUnitType()==NAL_UNIT_CODED_SLICE_TRAIL_R) { pcSlice->setNalUnitType(NAL_UNIT_CODED_SLICE_TRAIL_N); + } + if(pcSlice->getNalUnitType()==NAL_UNIT_CODED_SLICE_RADL_R) + { + pcSlice->setNalUnitType(NAL_UNIT_CODED_SLICE_RADL_N); + } + if(pcSlice->getNalUnitType()==NAL_UNIT_CODED_SLICE_RASL_R) + { + pcSlice->setNalUnitType(NAL_UNIT_CODED_SLICE_RASL_N); } } @@ -471,5 +610,5 @@ else { - pcSlice->setNalUnitType(NAL_UNIT_CODED_SLICE_TLA); + pcSlice->setNalUnitType(NAL_UNIT_CODED_SLICE_TLA_R); } } @@ -524,8 +663,24 @@ pcSlice->setNumRefIdx(REF_PIC_LIST_1,min(m_pcCfg->getGOPEntry(iGOPid).m_numRefPicsActive,pcSlice->getRPS()->getNumberOfPictures())); -#if REF_LIST_BUGFIX +#if REF_IDX_FRAMEWORK +#if ZERO_NUM_DIRECT_LAYERS + if( m_layerId > 0 && pcSlice->getActiveNumILRRefIdx() ) +#else if(m_layerId > 0) - { - if( pcSlice->getNalUnitType() >= NAL_UNIT_CODED_SLICE_BLA && pcSlice->getNalUnitType() <= NAL_UNIT_CODED_SLICE_CRA ) +#endif + { +#if JCTVC_M0458_INTERLAYER_RPS_SIG + if( pcSlice->getNalUnitType() >= NAL_UNIT_CODED_SLICE_BLA_W_LP && pcSlice->getNalUnitType() <= NAL_UNIT_CODED_SLICE_CRA ) + { + pcSlice->setNumRefIdx(REF_PIC_LIST_0, pcSlice->getActiveNumILRRefIdx()); + pcSlice->setNumRefIdx(REF_PIC_LIST_1, pcSlice->getActiveNumILRRefIdx()); + } + else + { + pcSlice->setNumRefIdx(REF_PIC_LIST_0, pcSlice->getNumRefIdx(REF_PIC_LIST_0)+pcSlice->getActiveNumILRRefIdx()); + pcSlice->setNumRefIdx(REF_PIC_LIST_1, pcSlice->getNumRefIdx(REF_PIC_LIST_1)+pcSlice->getActiveNumILRRefIdx()); + } +#else + if( pcSlice->getNalUnitType() >= NAL_UNIT_CODED_SLICE_BLA_W_LP && pcSlice->getNalUnitType() <= NAL_UNIT_CODED_SLICE_CRA ) { pcSlice->setNumRefIdx(REF_PIC_LIST_0, pcSlice->getNumILRRefIdx()); @@ -537,4 +692,5 @@ pcSlice->setNumRefIdx(REF_PIC_LIST_1, pcSlice->getNumRefIdx(REF_PIC_LIST_1)+pcSlice->getNumILRRefIdx()); } +#endif } #endif @@ -545,5 +701,9 @@ #if SVC_EXTENSION +#if ZERO_NUM_DIRECT_LAYERS + if( m_layerId > 0 && pcSlice->getActiveNumILRRefIdx() ) +#else if(m_layerId > 0) +#endif { #if !IDR_ALIGNMENT @@ -553,6 +713,10 @@ #if SVC_UPSAMPLING if ( pcPic->isSpatialEnhLayer()) - { + { +#if SCALED_REF_LAYER_OFFSETS + m_pcPredSearch->upsampleBasePic( pcPic->getFullPelBaseRec(), pcSlice->getBaseColPic()->getPicYuvRec(), pcPic->getPicYuvRec(), pcSlice->getSPS()->getScaledRefLayerWindow() ); +#else m_pcPredSearch->upsampleBasePic( pcPic->getFullPelBaseRec(), pcSlice->getBaseColPic()->getPicYuvRec(), pcPic->getPicYuvRec() ); +#endif } else @@ -573,6 +737,10 @@ // Set reference list -#if REF_LIST_BUGFIX +#if REF_IDX_FRAMEWORK +#if ZERO_NUM_DIRECT_LAYERS + if(m_layerId == 0 || ( m_layerId > 0 && pcSlice->getActiveNumILRRefIdx() == 0 ) ) +#else if(m_layerId == 0) +#endif { pcSlice->setRefPicList( rcListPic); @@ -582,5 +750,9 @@ #endif #if REF_IDX_FRAMEWORK +#if ZERO_NUM_DIRECT_LAYERS + if( m_layerId > 0 && pcSlice->getActiveNumILRRefIdx() ) +#else if(m_layerId > 0) +#endif { m_pcEncTop->setILRPic(pcPic); @@ -592,10 +764,6 @@ } #endif -#if REF_LIST_BUGFIX pcSlice->setRefPicListModificationSvc(); - pcSlice->setRefPicListSvc( rcListPic, m_pcEncTop->getIlpList() ); -#else - pcSlice->addRefPicList ( m_pcEncTop->getIlpList(), 1); -#endif + pcSlice->setRefPicList( rcListPic, false, m_pcEncTop->getIlpList()); #if REF_IDX_MFM @@ -607,5 +775,5 @@ for(Int colIdx = 0; colIdx < pcSlice->getNumRefIdx( RefPicList(1 - ColFromL0Flag) ); colIdx++) { - if( pcSlice->getRefPic( RefPicList(1 - ColFromL0Flag), colIdx)->isILR() ) + if( pcSlice->getRefPic( RefPicList(1 - ColFromL0Flag), colIdx)->isILR(m_layerId) ) { ColRefIdx = colIdx; @@ -620,5 +788,5 @@ for(Int colIdx = 0; colIdx < pcSlice->getNumRefIdx( RefPicList(1 - ColFromL0Flag) ); colIdx++) { - if( pcSlice->getRefPic( RefPicList(1 - ColFromL0Flag), colIdx)->isILR() ) + if( pcSlice->getRefPic( RefPicList(1 - ColFromL0Flag), colIdx)->isILR(m_layerId) ) { ColRefIdx = colIdx; @@ -644,5 +812,5 @@ pcSlice->setSliceType ( P_SLICE ); } - +#if !L0034_COMBINED_LIST_CLEANUP if (pcSlice->getSliceType() != B_SLICE || !pcSlice->getSPS()->getUseLComb()) { @@ -656,4 +824,5 @@ pcSlice->setNumRefIdx(REF_PIC_LIST_C, pcSlice->getNumRefIdx(REF_PIC_LIST_0)); } +#endif if (pcSlice->getSliceType() == B_SLICE) @@ -683,4 +852,8 @@ pcSlice->setCheckLDC(bLowDelay); } + else + { + pcSlice->setCheckLDC(true); + } uiColDir = 1-uiColDir; @@ -689,4 +862,7 @@ pcSlice->setRefPOCList(); +#if L0034_COMBINED_LIST_CLEANUP + pcSlice->setList1IdxToList0Idx(); +#else pcSlice->setNoBackPredFlag( false ); if ( pcSlice->getSliceType() == B_SLICE && !pcSlice->getRefPicListCombinationFlag()) @@ -712,4 +888,5 @@ } pcSlice->generateCombinedList(); +#endif if (m_pcEncTop->getTMVPModeId() == 2) @@ -831,4 +1008,33 @@ UInt uiNumSlices = 1; +#if SIMPLIFIED_MV_POS_SCALING + if (m_layerId > 0) + { +#if SCALED_REF_LAYER_OFFSETS + const Window &scalEL = m_pcEncTop->getScaledRefLayerWindow(); + + Int widthBL = pcSlice->getBaseColPic()->getPicYuvRec()->getWidth(); + Int heightBL = pcSlice->getBaseColPic()->getPicYuvRec()->getHeight(); + + Int widthEL = pcPic->getPicYuvRec()->getWidth() - scalEL.getWindowLeftOffset() - scalEL.getWindowRightOffset(); + Int heightEL = pcPic->getPicYuvRec()->getHeight() - scalEL.getWindowTopOffset() - scalEL.getWindowBottomOffset(); +#else + const Window &confBL = pcSlice->getBaseColPic()->getPicYuvRec()->getConformanceWindow(); + const Window &confEL = pcPic->getPicYuvRec()->getConformanceWindow(); + + Int widthBL = pcSlice->getBaseColPic()->getPicYuvRec()->getWidth () - confBL.getWindowLeftOffset() - confBL.getWindowRightOffset(); + Int heightBL = pcSlice->getBaseColPic()->getPicYuvRec()->getHeight() - confBL.getWindowTopOffset() - confBL.getWindowBottomOffset(); + + Int widthEL = pcPic->getPicYuvRec()->getWidth() - confEL.getWindowLeftOffset() - confEL.getWindowRightOffset(); + Int heightEL = pcPic->getPicYuvRec()->getHeight() - confEL.getWindowTopOffset() - confEL.getWindowBottomOffset(); +#endif + g_mvScalingFactor[m_layerId][0] = Clip3(-4096, 4095, ((widthEL << 8) + (widthBL >> 1)) / widthBL); + g_mvScalingFactor[m_layerId][1] = Clip3(-4096, 4095, ((heightEL << 8) + (heightBL >> 1)) / heightBL); + + g_posScalingFactor[m_layerId][0] = ((widthBL << 16) + (widthEL >> 1)) / widthEL; + g_posScalingFactor[m_layerId][1] = ((heightBL << 16) + (heightEL >> 1)) / heightEL; + } +#endif + UInt uiInternalAddress = pcPic->getNumPartInCU()-4; UInt uiExternalAddress = pcPic->getPicSym()->getNumberOfCUsInFrame()-1; @@ -949,5 +1155,5 @@ startCUAddrSliceSegmentIdx++; #if AVC_BASE - if( m_layerId == 0 ) + if( m_layerId == 0 && m_pcEncTop->getVPS()->getAvcBaseLayerFlag() ) { pcPic->getPicYuvOrg()->copyToPic( pcPic->getPicYuvRec() ); @@ -1027,4 +1233,10 @@ Bool bLFCrossTileBoundary = pcSlice->getPPS()->getLoopFilterAcrossTilesEnabledFlag(); m_pcLoopFilter->setCfg(bLFCrossTileBoundary); +#if L0386_DB_METRIC + if ( m_pcCfg->getDeblockingFilterMetric() ) + { + dblMetric(pcPic, uiNumSlices); + } +#endif m_pcLoopFilter->loopFilterPic( pcPic ); @@ -1059,5 +1271,5 @@ OutputNALUnit nalu(NAL_UNIT_VPS, 0, m_layerId); #if AVC_BASE - if( m_layerId == 1 ) + if( ( m_layerId == 1 && m_pcEncTop->getVPS()->getAvcBaseLayerFlag() ) || ( m_layerId == 0 && !m_pcEncTop->getVPS()->getAvcBaseLayerFlag() ) ) #else if( m_layerId == 0 ) @@ -1133,4 +1345,44 @@ } +#if L0208_SOP_DESCRIPTION_SEI + if (writeSOP) // write SOP description SEI (if enabled) at the beginning of GOP + { + Int SOPcurrPOC = pocCurr; + + OutputNALUnit nalu(NAL_UNIT_PREFIX_SEI); + m_pcEntropyCoder->setEntropyCoder(m_pcCavlcCoder, pcSlice); + m_pcEntropyCoder->setBitstream(&nalu.m_Bitstream); + + SEISOPDescription SOPDescriptionSEI; + SOPDescriptionSEI.m_sopSeqParameterSetId = pcSlice->getSPS()->getSPSId(); + + UInt i = 0; + UInt prevEntryId = iGOPid; + for (j = iGOPid; j < m_iGopSize; j++) + { + Int deltaPOC = m_pcCfg->getGOPEntry(j).m_POC - m_pcCfg->getGOPEntry(prevEntryId).m_POC; + if ((SOPcurrPOC + deltaPOC) < m_pcCfg->getFramesToBeEncoded()) + { + SOPcurrPOC += deltaPOC; + SOPDescriptionSEI.m_sopDescVclNaluType[i] = getNalUnitType(SOPcurrPOC, m_iLastIDR); + SOPDescriptionSEI.m_sopDescTemporalId[i] = m_pcCfg->getGOPEntry(j).m_temporalId; + SOPDescriptionSEI.m_sopDescStRpsIdx[i] = m_pcEncTop->getReferencePictureSetIdxForSOP(pcSlice, SOPcurrPOC, j); + SOPDescriptionSEI.m_sopDescPocDelta[i] = deltaPOC; + + prevEntryId = j; + i++; + } + } + + SOPDescriptionSEI.m_numPicsInSopMinus1 = i - 1; + + m_seiWriter.writeSEImessage( nalu.m_Bitstream, SOPDescriptionSEI, pcSlice->getSPS()); + writeRBSPTrailingBits(nalu.m_Bitstream); + accessUnit.push_back(new NALUnitEBSP(nalu)); + + writeSOP = false; + } +#endif + if( ( m_pcCfg->getPictureTimingSEIEnabled() || m_pcCfg->getDecodingUnitInfoSEIEnabled() ) && ( pcSlice->getSPS()->getVuiParametersPresentFlag() ) && @@ -1178,5 +1430,5 @@ || ( pcSlice->getSPS()->getVuiParameters()->getHrdParameters()->getVclHrdParametersPresentFlag() ) ) ) { - OutputNALUnit nalu(NAL_UNIT_SEI); + OutputNALUnit nalu(NAL_UNIT_PREFIX_SEI); m_pcEntropyCoder->setEntropyCoder(m_pcCavlcCoder, pcSlice); m_pcEntropyCoder->setBitstream(&nalu.m_Bitstream); @@ -1219,4 +1471,5 @@ writeRBSPTrailingBits(nalu.m_Bitstream); #if L0045_NON_NESTED_SEI_RESTRICTIONS + { UInt seiPositionInAu = xGetFirstSeiLocation(accessUnit); UInt offsetPosition = m_activeParameterSetSEIPresentInAU; // Insert BP SEI after APS SEI @@ -1228,6 +1481,33 @@ accessUnit.insert(it, new NALUnitEBSP(nalu)); m_bufferingPeriodSEIPresentInAU = true; + } #else accessUnit.push_back(new NALUnitEBSP(nalu)); +#endif + +#if K0180_SCALABLE_NESTING_SEI + if (m_pcCfg->getScalableNestingSEIEnabled()) + { + OutputNALUnit naluTmp(NAL_UNIT_PREFIX_SEI); + m_pcEntropyCoder->setEntropyCoder(m_pcCavlcCoder, pcSlice); + m_pcEntropyCoder->setBitstream(&naluTmp.m_Bitstream); + scalableNestingSEI.m_nestedSEIs.clear(); + scalableNestingSEI.m_nestedSEIs.push_back(&sei_buffering_period); + m_seiWriter.writeSEImessage( naluTmp.m_Bitstream, scalableNestingSEI, pcSlice->getSPS()); + writeRBSPTrailingBits(naluTmp.m_Bitstream); +#if L0045_NON_NESTED_SEI_RESTRICTIONS + UInt seiPositionInAu = xGetFirstSeiLocation(accessUnit); + UInt offsetPosition = m_activeParameterSetSEIPresentInAU + m_bufferingPeriodSEIPresentInAU + m_pictureTimingSEIPresentInAU; // Insert BP SEI after non-nested APS, BP and PT SEIs + AccessUnit::iterator it; + for(j = 0, it = accessUnit.begin(); j < seiPositionInAu + offsetPosition; j++) + { + it++; + } + accessUnit.insert(it, new NALUnitEBSP(naluTmp)); + m_nestedBufferingPeriodSEIPresentInAU = true; +#else + accessUnit.push_back(new NALUnitEBSP(naluTmp)); +#endif + } #endif @@ -1241,5 +1521,5 @@ { // Gradual decoding refresh SEI - OutputNALUnit nalu(NAL_UNIT_SEI); + OutputNALUnit nalu(NAL_UNIT_PREFIX_SEI); m_pcEntropyCoder->setEntropyCoder(m_pcCavlcCoder, pcSlice); m_pcEntropyCoder->setBitstream(&nalu.m_Bitstream); @@ -1253,5 +1533,5 @@ } // Recovery point SEI - OutputNALUnit nalu(NAL_UNIT_SEI); + OutputNALUnit nalu(NAL_UNIT_PREFIX_SEI); m_pcEntropyCoder->setEntropyCoder(m_pcCavlcCoder, pcSlice); m_pcEntropyCoder->setBitstream(&nalu.m_Bitstream); @@ -1444,13 +1724,6 @@ pcSlice->setTileOffstForMultES( uiOneBitstreamPerSliceLength ); - if (!sliceSegment) - { pcSlice->setTileLocationCount ( 0 ); - m_pcSliceEncoder->encodeSlice(pcPic, pcBitstreamRedirect, pcSubstreamsOut); // redirect is only used for CAVLC tile position info. - } - else - { - m_pcSliceEncoder->encodeSlice(pcPic, &nalu.m_Bitstream, pcSubstreamsOut); // nalu.m_Bitstream is only used for CAVLC tile position info. - } + m_pcSliceEncoder->encodeSlice(pcPic, pcSubstreamsOut); { @@ -1484,5 +1757,5 @@ if (ui+1 < pcSlice->getPPS()->getNumSubstreams()) { - puiSubstreamSizes[ui] = pcSubstreamsOut[ui].getNumberOfWrittenBits(); + puiSubstreamSizes[ui] = pcSubstreamsOut[ui].getNumberOfWrittenBits() + (pcSubstreamsOut[ui].countStartCodeEmulations()<<3); } } @@ -1516,5 +1789,5 @@ // If current NALU is the last NALU of slice and a NALU was buffered, then (a) Write current NALU (b) Update an write buffered NALU at approproate location in NALU list. Bool bNALUAlignedWrittenToList = false; // used to ensure current NALU is not written more than once to the NALU list. - xWriteTileLocationToSliceHeader(nalu, pcBitstreamRedirect, pcSlice); + xAttachSliceDataToNalUnit(nalu, pcBitstreamRedirect); accessUnit.push_back(new NALUnitEBSP(nalu)); #if RATE_CONTROL_LAMBDA_DOMAIN @@ -1544,5 +1817,5 @@ { UInt numRBSPBytes_nal = UInt((*it)->m_nalUnitData.str().size()); - if ((*it)->m_nalUnitType != NAL_UNIT_SEI && (*it)->m_nalUnitType != NAL_UNIT_SEI_SUFFIX) + if ((*it)->m_nalUnitType != NAL_UNIT_PREFIX_SEI && (*it)->m_nalUnitType != NAL_UNIT_SUFFIX_SEI) { numRBSPBytes += numRBSPBytes_nal; @@ -1640,7 +1913,7 @@ } #if SVC_EXTENSION - OutputNALUnit nalu(NAL_UNIT_SEI_SUFFIX, pcSlice->getTLayer(), m_layerId); -#else - OutputNALUnit nalu(NAL_UNIT_SEI_SUFFIX, pcSlice->getTLayer()); + OutputNALUnit nalu(NAL_UNIT_SUFFIX_SEI, pcSlice->getTLayer(), m_layerId); +#else + OutputNALUnit nalu(NAL_UNIT_SUFFIX_SEI, pcSlice->getTLayer()); #endif @@ -1667,5 +1940,5 @@ sei_temporal_level0_index.rapIdx = m_rapIdx; - OutputNALUnit nalu(NAL_UNIT_SEI); + OutputNALUnit nalu(NAL_UNIT_PREFIX_SEI); /* write the SEI messages */ @@ -1807,5 +2080,6 @@ if( m_pcCfg->getPictureTimingSEIEnabled() ) { - OutputNALUnit nalu(NAL_UNIT_SEI, pcSlice->getTLayer()); + { + OutputNALUnit nalu(NAL_UNIT_PREFIX_SEI, pcSlice->getTLayer()); m_pcEntropyCoder->setEntropyCoder(m_pcCavlcCoder, pcSlice); m_seiWriter.writeSEImessage(nalu.m_Bitstream, pictureTimingSEI, pcSlice->getSPS()); @@ -1827,4 +2101,32 @@ #endif } +#if K0180_SCALABLE_NESTING_SEI + if ( m_pcCfg->getScalableNestingSEIEnabled() ) // put picture timing SEI into scalable nesting SEI + { + OutputNALUnit nalu(NAL_UNIT_PREFIX_SEI, pcSlice->getTLayer()); + m_pcEntropyCoder->setEntropyCoder(m_pcCavlcCoder, pcSlice); + scalableNestingSEI.m_nestedSEIs.clear(); + scalableNestingSEI.m_nestedSEIs.push_back(&pictureTimingSEI); + m_seiWriter.writeSEImessage(nalu.m_Bitstream, scalableNestingSEI, pcSlice->getSPS()); + writeRBSPTrailingBits(nalu.m_Bitstream); +#if L0045_NON_NESTED_SEI_RESTRICTIONS + UInt seiPositionInAu = xGetFirstSeiLocation(accessUnit); + UInt offsetPosition = m_activeParameterSetSEIPresentInAU + + m_bufferingPeriodSEIPresentInAU + m_pictureTimingSEIPresentInAU + m_nestedBufferingPeriodSEIPresentInAU; // Insert PT SEI after APS and BP SEI + AccessUnit::iterator it; + for(j = 0, it = accessUnit.begin(); j < seiPositionInAu + offsetPosition; j++) + { + it++; + } + accessUnit.insert(it, new NALUnitEBSP(nalu)); + m_nestedPictureTimingSEIPresentInAU = true; +#else + AccessUnit::iterator it = find_if(accessUnit.begin(), accessUnit.end(), mem_fun(&NALUnit::isSlice)); + accessUnit.insert(it, new NALUnitEBSP(nalu)); +#endif + } +#endif + + } if( m_pcCfg->getDecodingUnitInfoSEIEnabled() && hrd->getSubPicCpbParamsPresentFlag() ) { @@ -1832,5 +2134,5 @@ for( Int i = 0; i < ( pictureTimingSEI.m_numDecodingUnitsMinus1 + 1 ); i ++ ) { - OutputNALUnit nalu(NAL_UNIT_SEI, pcSlice->getTLayer()); + OutputNALUnit nalu(NAL_UNIT_PREFIX_SEI, pcSlice->getTLayer()); SEIDecodingUnitInfo tempSEI; @@ -1880,5 +2182,5 @@ break; } - if ((*it)->m_nalUnitType != NAL_UNIT_SEI && (*it)->m_nalUnitType != NAL_UNIT_SEI_SUFFIX) + if ((*it)->m_nalUnitType != NAL_UNIT_PREFIX_SEI && (*it)->m_nalUnitType != NAL_UNIT_SUFFIX_SEI) { ctr++; @@ -1891,4 +2193,7 @@ #if L0045_NON_NESTED_SEI_RESTRICTIONS xResetNonNestedSEIPresentFlags(); +#if K0180_SCALABLE_NESTING_SEI + xResetNestedSEIPresentFlags(); +#endif #endif pcPic->getPicYuvRec()->copyToPic(pcPicYuvRecOut); @@ -2113,16 +2418,16 @@ case NAL_UNIT_CODED_SLICE_TRAIL_R: return "TRAIL_R"; case NAL_UNIT_CODED_SLICE_TRAIL_N: return "TRAIL_N"; - case NAL_UNIT_CODED_SLICE_TLA: return "TLA"; + case NAL_UNIT_CODED_SLICE_TLA_R: return "TLA_R"; case NAL_UNIT_CODED_SLICE_TSA_N: return "TSA_N"; case NAL_UNIT_CODED_SLICE_STSA_R: return "STSA_R"; case NAL_UNIT_CODED_SLICE_STSA_N: return "STSA_N"; - case NAL_UNIT_CODED_SLICE_BLA: return "BLA"; - case NAL_UNIT_CODED_SLICE_BLANT: return "BLANT"; + case NAL_UNIT_CODED_SLICE_BLA_W_LP: return "BLA_W_LP"; + case NAL_UNIT_CODED_SLICE_BLA_W_RADL: return "BLA_W_RADL"; case NAL_UNIT_CODED_SLICE_BLA_N_LP: return "BLA_N_LP"; - case NAL_UNIT_CODED_SLICE_IDR: return "IDR"; + case NAL_UNIT_CODED_SLICE_IDR_W_RADL: return "IDR_W_RADL"; case NAL_UNIT_CODED_SLICE_IDR_N_LP: return "IDR_N_LP"; case NAL_UNIT_CODED_SLICE_CRA: return "CRA"; - case NAL_UNIT_CODED_SLICE_DLP: return "DLP"; - case NAL_UNIT_CODED_SLICE_TFD: return "TFD"; + case NAL_UNIT_CODED_SLICE_RADL_R: return "RADL_R"; + case NAL_UNIT_CODED_SLICE_RASL_R: return "RASL_R"; case NAL_UNIT_VPS: return "VPS"; case NAL_UNIT_SPS: return "SPS"; @@ -2132,5 +2437,6 @@ case NAL_UNIT_EOB: return "EOB"; case NAL_UNIT_FILLER_DATA: return "FILLER"; - case NAL_UNIT_SEI: return "SEI"; + case NAL_UNIT_PREFIX_SEI: return "SEI"; + case NAL_UNIT_SUFFIX_SEI: return "SEI"; default: return "UNK"; } @@ -2223,5 +2529,5 @@ printf("*** %6s numBytesInNALunit: %u\n", nalUnitTypeToString((*it)->m_nalUnitType), numRBSPBytes_nal); #endif - if ((*it)->m_nalUnitType != NAL_UNIT_SEI && (*it)->m_nalUnitType != NAL_UNIT_SEI_SUFFIX) + if ((*it)->m_nalUnitType != NAL_UNIT_PREFIX_SEI && (*it)->m_nalUnitType != NAL_UNIT_SUFFIX_SEI) { numRBSPBytes += numRBSPBytes_nal; @@ -2314,4 +2620,11 @@ for (Int iRefIndex = 0; iRefIndex < pcSlice->getNumRefIdx(RefPicList(iRefList)); iRefIndex++) { +#if REF_IDX_FRAMEWORK && VPS_EXTN_DIRECT_REF_LAYERS_CONTINUE + if( pcSlice->getRefPic(RefPicList(iRefList), iRefIndex)->isILR(m_layerId) ) + { + printf( "%d(%d) ", pcSlice->getRefPOC(RefPicList(iRefList), iRefIndex)-pcSlice->getLastIDR(), pcSlice->getRefPic(RefPicList(iRefList), iRefIndex)->getLayerId() ); + } + else +#endif printf ("%d ", pcSlice->getRefPOC(RefPicList(iRefList), iRefIndex)-pcSlice->getLastIDR()); } @@ -2325,9 +2638,9 @@ * This function checks the configuration and returns the appropriate nal_unit_type for the picture. */ -NalUnitType TEncGOP::getNalUnitType(Int pocCurr) +NalUnitType TEncGOP::getNalUnitType(Int pocCurr, Int lastIDR) { if (pocCurr == 0) { - return NAL_UNIT_CODED_SLICE_IDR; + return NAL_UNIT_CODED_SLICE_IDR_W_RADL; } if (pocCurr % m_pcCfg->getIntraPeriod() == 0) @@ -2339,5 +2652,5 @@ else if (m_pcCfg->getDecodingRefreshType() == 2) { - return NAL_UNIT_CODED_SLICE_IDR; + return NAL_UNIT_CODED_SLICE_IDR_W_RADL; } } @@ -2351,5 +2664,12 @@ // controlling the reference pictures used for encoding that leading picture. Such a leading // picture need not be marked as a TFD picture. - return NAL_UNIT_CODED_SLICE_TFD; + return NAL_UNIT_CODED_SLICE_RASL_R; + } + } + if (lastIDR>0) + { + if (pocCurr < lastIDR) + { + return NAL_UNIT_CODED_SLICE_RADL_R; } } @@ -2402,9 +2722,10 @@ } -/** Determine the difference between consecutive tile sizes (in bytes) and writes it to bistream rNalu [slice header] - * \param rpcBitstreamRedirect contains the bitstream to be concatenated to rNalu. rpcBitstreamRedirect contains slice payload. rpcSlice contains tile location information. - * \returns Updates rNalu to contain concatenated bitstream. rpcBitstreamRedirect is cleared at the end of this function call. +/** Attaches the input bitstream to the stream in the output NAL unit + Updates rNalu to contain concatenated bitstream. rpcBitstreamRedirect is cleared at the end of this function call. + * \param codedSliceData contains the coded slice data (bitstream) to be concatenated to rNalu + * \param rNalu target NAL unit */ -Void TEncGOP::xWriteTileLocationToSliceHeader (OutputNALUnit& rNalu, TComOutputBitstream*& rpcBitstreamRedirect, TComSlice*& rpcSlice) +Void TEncGOP::xAttachSliceDataToNalUnit (OutputNALUnit& rNalu, TComOutputBitstream*& codedSliceData) { // Byte-align @@ -2412,30 +2733,12 @@ // Perform bitstream concatenation - if (rpcBitstreamRedirect->getNumberOfWrittenBits() > 0) - { - UInt uiBitCount = rpcBitstreamRedirect->getNumberOfWrittenBits(); - if (rpcBitstreamRedirect->getByteStreamLength()>0) - { - UChar *pucStart = reinterpret_cast(rpcBitstreamRedirect->getByteStream()); - UInt uiWriteByteCount = 0; - while (uiWriteByteCount < (uiBitCount >> 3) ) - { - UInt uiBits = (*pucStart); - rNalu.m_Bitstream.write(uiBits, 8); - pucStart++; - uiWriteByteCount++; - } - } - UInt uiBitsHeld = (uiBitCount & 0x07); - for (UInt uiIdx=0; uiIdx < uiBitsHeld; uiIdx++) - { - rNalu.m_Bitstream.write((rpcBitstreamRedirect->getHeldBits() & (1 << (7-uiIdx))) >> (7-uiIdx), 1); - } + if (codedSliceData->getNumberOfWrittenBits() > 0) + { + rNalu.m_Bitstream.addSubstream(codedSliceData); } m_pcEntropyCoder->setBitstream(&rNalu.m_Bitstream); - delete rpcBitstreamRedirect; - rpcBitstreamRedirect = new TComOutputBitstream; + codedSliceData->clear(); } @@ -2562,7 +2865,131 @@ } } - assert(it != accessUnit.end()); +// assert(it != accessUnit.end()); // Triggers with some legit configurations return seiStartPos; } #endif + +#if L0386_DB_METRIC +Void TEncGOP::dblMetric( TComPic* pcPic, UInt uiNumSlices ) +{ + TComPicYuv* pcPicYuvRec = pcPic->getPicYuvRec(); + Pel* Rec = pcPicYuvRec->getLumaAddr( 0 ); + Pel* tempRec = Rec; + Int stride = pcPicYuvRec->getStride(); + UInt log2maxTB = pcPic->getSlice(0)->getSPS()->getQuadtreeTULog2MaxSize(); + UInt maxTBsize = (1<getWidth(); + const UInt picHeight = pcPicYuvRec->getHeight(); + const UInt noCol = (picWidth>>log2maxTB); + const UInt noRows = (picHeight>>log2maxTB); + UInt64 *colSAD = (UInt64*)malloc(noCol*sizeof(UInt64)); + UInt64 *rowSAD = (UInt64*)malloc(noRows*sizeof(UInt64)); + UInt colIdx = 0; + UInt rowIdx = 0; + Pel p0, p1, p2, q0, q1, q2; + + Int qp = pcPic->getSlice(0)->getSliceQp(); + Int bitdepthScale = 1 << (g_bitDepthY-8); + Int beta = TComLoopFilter::getBeta( qp ) * bitdepthScale; + const Int thr2 = (beta>>2); + const Int thr1 = 2*bitdepthScale; + UInt a = 0; + + memset(colSAD, 0, noCol*sizeof(UInt64)); + memset(rowSAD, 0, noRows*sizeof(UInt64)); + + if (maxTBsize > minBlockArtSize) + { + // Analyze vertical artifact edges + for(Int c = maxTBsize; c < picWidth; c += maxTBsize) + { + for(Int r = 0; r < picHeight; r++) + { + p2 = Rec[c-3]; + p1 = Rec[c-2]; + p0 = Rec[c-1]; + q0 = Rec[c]; + q1 = Rec[c+1]; + q2 = Rec[c+2]; + a = ((abs(p2-(p1<<1)+p0)+abs(q0-(q1<<1)+q2))<<1); + if ( thr1 < a && a < thr2) + { + colSAD[colIdx] += abs(p0 - q0); + } + Rec += stride; + } + colIdx++; + Rec = tempRec; + } + + // Analyze horizontal artifact edges + for(Int r = maxTBsize; r < picHeight; r += maxTBsize) + { + for(Int c = 0; c < picWidth; c++) + { + p2 = Rec[c + (r-3)*stride]; + p1 = Rec[c + (r-2)*stride]; + p0 = Rec[c + (r-1)*stride]; + q0 = Rec[c + r*stride]; + q1 = Rec[c + (r+1)*stride]; + q2 = Rec[c + (r+2)*stride]; + a = ((abs(p2-(p1<<1)+p0)+abs(q0-(q1<<1)+q2))<<1); + if (thr1 < a && a < thr2) + { + rowSAD[rowIdx] += abs(p0 - q0); + } + } + rowIdx++; + } + } + + UInt64 colSADsum = 0; + UInt64 rowSADsum = 0; + for(Int c = 0; c < noCol-1; c++) + { + colSADsum += colSAD[c]; + } + for(Int r = 0; r < noRows-1; r++) + { + rowSADsum += rowSAD[r]; + } + + colSADsum <<= 10; + rowSADsum <<= 10; + colSADsum /= (noCol-1); + colSADsum /= picHeight; + rowSADsum /= (noRows-1); + rowSADsum /= picWidth; + + UInt64 avgSAD = ((colSADsum + rowSADsum)>>1); + avgSAD >>= (g_bitDepthY-8); + + if ( avgSAD > 2048 ) + { + avgSAD >>= 9; + Int offset = Clip3(2,6,(Int)avgSAD); + for (Int i=0; igetSlice(i)->setDeblockingFilterOverrideFlag(true); + pcPic->getSlice(i)->setDeblockingFilterDisable(false); + pcPic->getSlice(i)->setDeblockingFilterBetaOffsetDiv2( offset ); + pcPic->getSlice(i)->setDeblockingFilterTcOffsetDiv2( offset ); + } + } + else + { + for (Int i=0; igetSlice(i)->setDeblockingFilterOverrideFlag(false); + pcPic->getSlice(i)->setDeblockingFilterDisable( pcPic->getSlice(i)->getPPS()->getPicDisableDeblockingFilterFlag() ); + pcPic->getSlice(i)->setDeblockingFilterBetaOffsetDiv2( pcPic->getSlice(i)->getPPS()->getDeblockingFilterBetaOffsetDiv2() ); + pcPic->getSlice(i)->setDeblockingFilterTcOffsetDiv2( pcPic->getSlice(i)->getPPS()->getDeblockingFilterTcOffsetDiv2() ); + } + } + + free(colSAD); + free(rowSAD); +} +#endif //! \} Index: /trunk/source/Lib/TLibEncoder/TEncGOP.h =================================================================== --- /trunk/source/Lib/TLibEncoder/TEncGOP.h (revision 188) +++ /trunk/source/Lib/TLibEncoder/TEncGOP.h (revision 189) @@ -131,4 +131,8 @@ Bool m_bufferingPeriodSEIPresentInAU; Bool m_pictureTimingSEIPresentInAU; +#if K0180_SCALABLE_NESTING_SEI + Bool m_nestedBufferingPeriodSEIPresentInAU; + Bool m_nestedPictureTimingSEIPresentInAU; +#endif #endif public: @@ -149,5 +153,5 @@ Void compressGOP ( Int iPOCLast, Int iNumPicRcvd, TComList& rcListPic, TComList& rcListPicYuvRec, std::list& accessUnitsInGOP ); #endif - Void xWriteTileLocationToSliceHeader (OutputNALUnit& rNalu, TComOutputBitstream*& rpcBitstreamRedirect, TComSlice*& rpcSlice); + Void xAttachSliceDataToNalUnit (OutputNALUnit& rNalu, TComOutputBitstream*& rpcBitstreamRedirect); @@ -160,5 +164,5 @@ TEncSlice* getSliceEncoder() { return m_pcSliceEncoder; } - NalUnitType getNalUnitType( Int pocCurr ); + NalUnitType getNalUnitType( Int pocCurr, Int lastIdr ); Void arrangeLongtermPicturesInRPS(TComSlice *, TComList& ); protected: @@ -178,4 +182,8 @@ SEIFramePacking* xCreateSEIFramePacking(); SEIDisplayOrientation* xCreateSEIDisplayOrientation(); + +#if J0149_TONE_MAPPING_SEI + SEIToneMappingInfo* xCreateSEIToneMappingInfo(); +#endif Void xCreateLeadingSEIMessages (/*SEIMessages seiMessages,*/ AccessUnit &accessUnit, TComSPS *sps); @@ -188,4 +196,14 @@ m_pictureTimingSEIPresentInAU = false; } +#if K0180_SCALABLE_NESTING_SEI + Void xResetNestedSEIPresentFlags() + { + m_nestedBufferingPeriodSEIPresentInAU = false; + m_nestedPictureTimingSEIPresentInAU = false; + } +#endif +#endif +#if L0386_DB_METRIC + Void dblMetric( TComPic* pcPic, UInt uiNumSlices ); #endif };// END CLASS DEFINITION TEncGOP Index: /trunk/source/Lib/TLibEncoder/TEncSampleAdaptiveOffset.cpp =================================================================== --- /trunk/source/Lib/TLibEncoder/TEncSampleAdaptiveOffset.cpp (revision 188) +++ /trunk/source/Lib/TLibEncoder/TEncSampleAdaptiveOffset.cpp (revision 189) @@ -1677,12 +1677,4 @@ #endif { -#if SAO_CHROMA_LAMBDA - m_dLambdaLuma = dLambdaLuma; - m_dLambdaChroma = dLambdaChroma; -#else - m_dLambdaLuma = dLambda; - m_dLambdaChroma = dLambda; -#endif - if(m_bUseNIF) { Index: /trunk/source/Lib/TLibEncoder/TEncSampleAdaptiveOffset.h =================================================================== --- /trunk/source/Lib/TLibEncoder/TEncSampleAdaptiveOffset.h (revision 188) +++ /trunk/source/Lib/TLibEncoder/TEncSampleAdaptiveOffset.h (revision 189) @@ -57,7 +57,4 @@ { private: - Double m_dLambdaLuma; - Double m_dLambdaChroma; - TEncEntropy* m_pcEntropyCoder; TEncSbac*** m_pppcRDSbacCoder; ///< for CABAC Index: /trunk/source/Lib/TLibEncoder/TEncSbac.h =================================================================== --- /trunk/source/Lib/TLibEncoder/TEncSbac.h (revision 188) +++ /trunk/source/Lib/TLibEncoder/TEncSbac.h (revision 189) @@ -109,5 +109,4 @@ Void xWriteEpExGolomb ( UInt uiSymbol, UInt uiCount ); Void xWriteCoefRemainExGolomb ( UInt symbol, UInt &rParam ); - Void xWriteTerminatingBit ( UInt uiBit ); Void xCopyFrom ( TEncSbac* pSrc ); Index: /trunk/source/Lib/TLibEncoder/TEncSearch.cpp =================================================================== --- /trunk/source/Lib/TLibEncoder/TEncSearch.cpp (revision 188) +++ /trunk/source/Lib/TLibEncoder/TEncSearch.cpp (revision 189) @@ -3249,4 +3249,11 @@ UInt uiBitsTempL0[MAX_NUM_REF]; +#if L0034_COMBINED_LIST_CLEANUP + TComMv mvValidList1; + Int refIdxValidList1 = 0; + UInt bitsValidList1 = MAX_UINT; + UInt costValidList1 = MAX_UINT; +#endif + #if (ENCODER_FAST_MODE) Bool testILR; @@ -3289,5 +3296,5 @@ #if (ENCODER_FAST_MODE) TComPic* pcPic = pcCU->getSlice()->getRefPic( eRefPicList, iRefIdxTemp ); - if( !testILR && pcPic->isILR() && (ePartSize == SIZE_2Nx2N) ) + if( !testILR && pcPic->isILR(pcCU->getLayerId()) && (ePartSize == SIZE_2Nx2N) ) { continue; @@ -3326,6 +3333,10 @@ uiBitsTemp += m_auiMVPIdxCost[aaiMvpIdx[iRefList][iRefIdxTemp]][AMVP_MAX_NUM_CANDS]; #if ZERO_MVD_EST +#if L0034_COMBINED_LIST_CLEANUP + if ( iRefList == 0 || pcCU->getSlice()->getList1IdxToList0Idx( iRefIdxTemp ) < 0 ) +#else if ((iRefList != 1 || !pcCU->getSlice()->getNoBackPredFlag()) && (pcCU->getSlice()->getNumRefIdx(REF_PIC_LIST_C) <= 0 || pcCU->getSlice()->getRefIdxOfLC(eRefPicList, iRefIdxTemp)>=0)) +#endif { uiZeroMvdBitsTemp = uiBitsTemp; @@ -3347,4 +3358,29 @@ #if GPB_SIMPLE_UNI +#if L0034_COMBINED_LIST_CLEANUP + if ( iRefList == 1 ) // list 1 + { + if ( pcCU->getSlice()->getList1IdxToList0Idx( iRefIdxTemp ) >= 0 ) + { + cMvTemp[1][iRefIdxTemp] = cMvTemp[0][pcCU->getSlice()->getList1IdxToList0Idx( iRefIdxTemp )]; + uiCostTemp = uiCostTempL0[pcCU->getSlice()->getList1IdxToList0Idx( iRefIdxTemp )]; + /*first subtract the bit-rate part of the cost of the other list*/ + uiCostTemp -= m_pcRdCost->getCost( uiBitsTempL0[pcCU->getSlice()->getList1IdxToList0Idx( iRefIdxTemp )] ); + /*correct the bit-rate part of the current ref*/ + m_pcRdCost->setPredictor ( cMvPred[iRefList][iRefIdxTemp] ); + uiBitsTemp += m_pcRdCost->getBits( cMvTemp[1][iRefIdxTemp].getHor(), cMvTemp[1][iRefIdxTemp].getVer() ); + /*calculate the correct cost*/ + uiCostTemp += m_pcRdCost->getCost( uiBitsTemp ); + } + else + { + xMotionEstimation ( pcCU, pcOrgYuv, iPartIdx, eRefPicList, &cMvPred[iRefList][iRefIdxTemp], iRefIdxTemp, cMvTemp[iRefList][iRefIdxTemp], uiBitsTemp, uiCostTemp ); + } + } + else + { + xMotionEstimation ( pcCU, pcOrgYuv, iPartIdx, eRefPicList, &cMvPred[iRefList][iRefIdxTemp], iRefIdxTemp, cMvTemp[iRefList][iRefIdxTemp], uiBitsTemp, uiCostTemp ); + } +#else if ( pcCU->getSlice()->getNumRefIdx(REF_PIC_LIST_C) > 0) { @@ -3388,4 +3424,5 @@ } } +#endif #else xMotionEstimation ( pcCU, pcOrgYuv, iPartIdx, eRefPicList, &cMvPred[iRefList][iRefIdxTemp], iRefIdxTemp, cMvTemp[iRefList][iRefIdxTemp], uiBitsTemp, uiCostTemp ); @@ -3394,4 +3431,30 @@ xCheckBestMVP(pcCU, eRefPicList, cMvTemp[iRefList][iRefIdxTemp], cMvPred[iRefList][iRefIdxTemp], aaiMvpIdx[iRefList][iRefIdxTemp], uiBitsTemp, uiCostTemp); +#if L0034_COMBINED_LIST_CLEANUP + if ( iRefList == 0 ) + { + uiCostTempL0[iRefIdxTemp] = uiCostTemp; + uiBitsTempL0[iRefIdxTemp] = uiBitsTemp; + } + if ( uiCostTemp < uiCost[iRefList] ) + { + uiCost[iRefList] = uiCostTemp; + uiBits[iRefList] = uiBitsTemp; // storing for bi-prediction + + // set motion + cMv[iRefList] = cMvTemp[iRefList][iRefIdxTemp]; + iRefIdx[iRefList] = iRefIdxTemp; + } + + if ( iRefList == 1 && uiCostTemp < costValidList1 && pcCU->getSlice()->getList1IdxToList0Idx( iRefIdxTemp ) < 0 ) + { + costValidList1 = uiCostTemp; + bitsValidList1 = uiBitsTemp; + + // set motion + mvValidList1 = cMvTemp[iRefList][iRefIdxTemp]; + refIdxValidList1 = iRefIdxTemp; + } +#else if(pcCU->getSlice()->getNumRefIdx(REF_PIC_LIST_C) > 0 && !pcCU->getSlice()->getNoBackPredFlag()) { @@ -3449,4 +3512,5 @@ } } +#endif } } @@ -3516,8 +3580,33 @@ Int iRefList = iIter % 2; +#if L0034_COMBINED_LIST_CLEANUP + if ( m_pcEncCfg->getUseFastEnc() ) + { + if( uiCost[0] <= uiCost[1] ) + { + iRefList = 1; + } + else + { + iRefList = 0; + } + } + else if ( iIter == 0 ) + { + iRefList = 0; + } + if ( iIter == 0 && !pcCU->getSlice()->getMvdL1ZeroFlag()) + { + pcCU->getCUMvField(RefPicList(1-iRefList))->setAllMv( cMv[1-iRefList], ePartSize, uiPartAddr, 0, iPartIdx ); + pcCU->getCUMvField(RefPicList(1-iRefList))->setAllRefIdx( iRefIdx[1-iRefList], ePartSize, uiPartAddr, 0, iPartIdx ); + TComYuv* pcYuvPred = &m_acYuvPred[1-iRefList]; + motionCompensation ( pcCU, pcYuvPred, RefPicList(1-iRefList), iPartIdx ); + } +#else if ( m_pcEncCfg->getUseFastEnc() && (pcCU->getSlice()->getNoBackPredFlag() || (pcCU->getSlice()->getNumRefIdx(REF_PIC_LIST_C) > 0 && pcCU->getSlice()->getRefIdxOfL0FromRefIdxOfL1(0)==0 )) ) { iRefList = 1; } +#endif RefPicList eRefPicList = ( iRefList ? REF_PIC_LIST_1 : REF_PIC_LIST_0 ); @@ -3533,5 +3622,5 @@ Bool testIter = true; TComPic* pcPic = pcCU->getSlice()->getRefPic( RefPicList(1 - iRefList), iRefIdxBi[1 - iRefList] ); - if(pcPic->isILR() && (ePartSize == SIZE_2Nx2N)) + if(pcPic->isILR(pcCU->getLayerId()) && (ePartSize == SIZE_2Nx2N)) { testIter = false; //the fixed part is ILR, skip this iteration @@ -3548,5 +3637,5 @@ Bool testRefIdx = true; pcPic = pcCU->getSlice()->getRefPic( RefPicList(iRefList) , iRefIdxTemp ); - if(pcPic->isILR() && (ePartSize == SIZE_2Nx2N)) + if(pcPic->isILR(pcCU->getLayerId()) && (ePartSize == SIZE_2Nx2N)) { testRefIdx = false; //the refined part is ILR, skip this reference pic @@ -3680,8 +3769,15 @@ UInt uiMEBits = 0; // Set Motion Field_ +#if L0034_COMBINED_LIST_CLEANUP + cMv[1] = mvValidList1; + iRefIdx[1] = refIdxValidList1; + uiBits[1] = bitsValidList1; + uiCost[1] = costValidList1; +#else if ( pcCU->getSlice()->getNoBackPredFlag() || (pcCU->getSlice()->getNumRefIdx(REF_PIC_LIST_C) > 0 && pcCU->getSlice()->getRefIdxOfL0FromRefIdxOfL1(0)==0 ) ) { uiCost[1] = MAX_UINT; } +#endif #if AMP_MRG if (bTestNormalMC) @@ -4212,5 +4308,5 @@ // Do integer search #if REF_IDX_ME_ZEROMV - if( pcCU->getSlice()->getRefPic( eRefPicList, iRefIdxPred )->isILR()) //ILR reference pic + if( pcCU->getSlice()->getRefPic( eRefPicList, iRefIdxPred )->isILR(pcCU->getLayerId())) //ILR reference pic { rcMv.setZero(); //use Mv(0, 0) for integer ME @@ -4245,5 +4341,5 @@ { #if REF_IDX_ME_ZEROMV - if( pcCU->getSlice()->getRefPic( eRefPicList, iRefIdxPred )->isILR()) //ILR reference pic + if( pcCU->getSlice()->getRefPic( eRefPicList, iRefIdxPred )->isILR(pcCU->getLayerId())) //ILR reference pic { xPatternSearchFracDIFMv0( pcCU, pcPatternKey, piRefY, iRefStride, &rcMv, cMvHalf, cMvQter, ruiCost, bBi ); @@ -4663,5 +4759,5 @@ while( pcCU->getWidth(0) > (pcCU->getSlice()->getSPS()->getMaxTrSize()<getSlice()->getSPS()->getMaxTrDepth() + uiTrLevel; + UInt uiMaxTrMode = 1 + uiTrLevel; while((uiWidth>>uiMaxTrMode) < (g_uiMaxCUWidth>>g_uiMaxCUDepth)) uiMaxTrMode--; @@ -6219,5 +6315,5 @@ for( Int refIdx = 0; refIdx < pcCU->getSlice()->getNumRefIdx(eRefPicList); refIdx++ ) { - if( pcCU->getSlice()->getRefPic(eRefPicList, refIdx)->isILR() ) + if( pcCU->getSlice()->getRefPic(eRefPicList, refIdx)->isILR(pcCU->getLayerId()) ) { iRefIdxTemp = refIdx; Index: /trunk/source/Lib/TLibEncoder/TEncSlice.cpp =================================================================== --- /trunk/source/Lib/TLibEncoder/TEncSlice.cpp (revision 188) +++ /trunk/source/Lib/TLibEncoder/TEncSlice.cpp (revision 189) @@ -178,5 +178,10 @@ \param pPPS PPS associated with the slice */ +#if SVC_EXTENSION +//\param vps VPS associated with the slice +Void TEncSlice::initEncSlice( TComPic* pcPic, Int pocLast, Int pocCurr, Int iNumPicRcvd, Int iGOPid, TComSlice*& rpcSlice, TComSPS* pSPS, TComPPS *pPPS, TComVPS *vps ) +#else Void TEncSlice::initEncSlice( TComPic* pcPic, Int pocLast, Int pocCurr, Int iNumPicRcvd, Int iGOPid, TComSlice*& rpcSlice, TComSPS* pSPS, TComPPS *pPPS ) +#endif { Double dQP; @@ -189,5 +194,7 @@ rpcSlice->setPic( pcPic ); #if SVC_EXTENSION - rpcSlice->initSlice( pcPic->getLayerId() ); + UInt layerId = pcPic->getLayerId(); + rpcSlice->setVPS( vps ); + rpcSlice->initSlice( layerId ); #else rpcSlice->initSlice(); @@ -337,4 +344,15 @@ } +#if JCTVC_M0259_LAMBDAREFINEMENT + if( rpcSlice->getLayerId() > 0 && depth >= 3 && m_pcCfg->getGOPSize() == ( 1 << depth ) ) + { + Int nCurLayer = rpcSlice->getLayerId(); + Double gamma = xCalEnhLambdaFactor( m_ppcTEncTop[nCurLayer-1]->getQP() - m_ppcTEncTop[nCurLayer]->getQP() , + 1.0 * m_ppcTEncTop[nCurLayer]->getSourceWidth() * m_ppcTEncTop[nCurLayer]->getSourceHeight() + / m_ppcTEncTop[nCurLayer-1]->getSourceWidth() / m_ppcTEncTop[nCurLayer-1]->getSourceHeight() ); + dLambda *= gamma; + } +#endif + // store lambda m_pcRdCost ->setLambda( dLambda ); @@ -354,4 +372,11 @@ qpc = Clip3( 0, 57, iQP + chromaQPOffset); weight = pow( 2.0, (iQP-g_aucChromaScale[qpc])/3.0 ); // takes into account of the chroma qp mapping and chroma qp Offset +#if JCTVC_M0259_LAMBDAREFINEMENT + if( rpcSlice->getLayerId() > 0 && m_pcCfg->getGOPSize() >= 8 && rpcSlice->isIntra() == false && depth == 0 ) + { + dLambda *= 1.1; + weight *= 1.15; + } +#endif m_pcRdCost->setCrDistortionWeight(weight); #endif @@ -400,4 +425,13 @@ rpcSlice->setNumRefIdx(REF_PIC_LIST_1,m_pcCfg->getGOPEntry(iGOPid).m_numRefPicsActive); +#if L0386_DB_METRIC + if ( m_pcCfg->getDeblockingFilterMetric() ) + { + rpcSlice->setDeblockingFilterOverrideFlag(true); + rpcSlice->setDeblockingFilterDisable(false); + rpcSlice->setDeblockingFilterBetaOffsetDiv2( 0 ); + rpcSlice->setDeblockingFilterTcOffsetDiv2( 0 ); + } else +#endif if (rpcSlice->getPPS()->getDeblockingFilterControlPresentFlag()) { @@ -452,4 +486,22 @@ rpcSlice->setMaxNumMergeCand ( m_pcCfg->getMaxNumMergeCand() ); xStoreWPparam( pPPS->getUseWP(), pPPS->getWPBiPred() ); + +#if SVC_EXTENSION && REF_IDX_FRAMEWORK + if( layerId > 0 ) + { +#if JCTVC_M0458_INTERLAYER_RPS_SIG + // currently only one reference layer is supported in software and no decision logic to select yet. + // hence num of active inter layer references is set to one always + if( rpcSlice->getNumILRRefIdx() > 0 ) + { + rpcSlice->setActiveNumILRRefIdx(1); + rpcSlice->setInterLayerPredEnabledFlag(1); + } +#else + rpcSlice->setNumILRRefIdx( rpcSlice->getVPS()->getNumDirectRefLayers( layerId ) ); +#endif + } + +#endif } @@ -1182,5 +1234,5 @@ \retval rpcBitstream bitstream class */ -Void TEncSlice::encodeSlice ( TComPic*& rpcPic, TComOutputBitstream* pcBitstream, TComOutputBitstream* pcSubstreams ) +Void TEncSlice::encodeSlice ( TComPic*& rpcPic, TComOutputBitstream* pcSubstreams ) { UInt uiCUAddr; @@ -1362,37 +1414,5 @@ } { - UInt uiCounter = 0; - vector& rbsp = pcSubstreams[uiSubStrm].getFIFO(); - for (vector::iterator it = rbsp.begin(); it != rbsp.end();) - { - /* 1) find the next emulated 00 00 {00,01,02,03} - * 2a) if not found, write all remaining bytes out, stop. - * 2b) otherwise, write all non-emulated bytes out - * 3) insert emulation_prevention_three_byte - */ - vector::iterator found = it; - do - { - /* NB, end()-1, prevents finding a trailing two byte sequence */ - found = search_n(found, rbsp.end()-1, 2, 0); - found++; - /* if not found, found == end, otherwise found = second zero byte */ - if (found == rbsp.end()) - { - break; - } - if (*(++found) <= 3) - { - break; - } - } while (true); - it = found; - if (found != rbsp.end()) - { - it++; - uiCounter++; - } - } - + UInt numStartCodeEmulations = pcSubstreams[uiSubStrm].countStartCodeEmulations(); UInt uiAccumulatedSubstreamLength = 0; for (Int iSubstrmIdx=0; iSubstrmIdx < iNumSubstreams; iSubstrmIdx++) @@ -1402,5 +1422,5 @@ // add bits coded in previous dependent slices + bits coded so far // add number of emulation prevention byte count in the tile - pcSlice->addTileLocation( ((pcSlice->getTileOffstForMultES() + uiAccumulatedSubstreamLength - uiBitsOriginallyInSubstreams) >> 3) + uiCounter ); + pcSlice->addTileLocation( ((pcSlice->getTileOffstForMultES() + uiAccumulatedSubstreamLength - uiBitsOriginallyInSubstreams) >> 3) + numStartCodeEmulations ); } } @@ -1875,3 +1895,11 @@ } +#if JCTVC_M0259_LAMBDAREFINEMENT +Double TEncSlice::xCalEnhLambdaFactor( Double deltaQP , Double beta ) +{ + double tmp = beta * pow( 2.0 , deltaQP / 6 ); + double gamma = tmp / ( tmp + 1 ); + return( gamma ); +} +#endif //! \} Index: /trunk/source/Lib/TLibEncoder/TEncSlice.h =================================================================== --- /trunk/source/Lib/TLibEncoder/TEncSlice.h (revision 188) +++ /trunk/source/Lib/TLibEncoder/TEncSlice.h (revision 189) @@ -116,6 +116,12 @@ /// preparation of slice encoding (reference marking, QP and lambda) +#if SVC_EXTENSION + Void initEncSlice ( TComPic* pcPic, Int pocLast, Int pocCurr, Int iNumPicRcvd, + Int iGOPid, TComSlice*& rpcSlice, TComSPS* pSPS, TComPPS *pPPS, TComVPS *vps ); +#else Void initEncSlice ( TComPic* pcPic, Int pocLast, Int pocCurr, Int iNumPicRcvd, Int iGOPid, TComSlice*& rpcSlice, TComSPS* pSPS, TComPPS *pPPS ); +#endif + #if RATE_CONTROL_LAMBDA_DOMAIN Void resetQP ( TComPic* pic, Int sliceQP, Double lambda ); @@ -126,5 +132,5 @@ Void precompressSlice ( TComPic*& rpcPic ); ///< precompress slice for multi-loop opt. Void compressSlice ( TComPic*& rpcPic ); ///< analysis stage of slice - Void encodeSlice ( TComPic*& rpcPic, TComOutputBitstream* rpcBitstream, TComOutputBitstream* pcSubstreams ); + Void encodeSlice ( TComPic*& rpcPic, TComOutputBitstream* pcSubstreams ); // misc. functions @@ -141,4 +147,9 @@ private: Double xGetQPValueAccordingToLambda ( Double lambda ); + +#if JCTVC_M0259_LAMBDAREFINEMENT +private: + Double xCalEnhLambdaFactor( Double deltaQP , Double beta ); +#endif }; Index: /trunk/source/Lib/TLibEncoder/TEncTop.cpp =================================================================== --- /trunk/source/Lib/TLibEncoder/TEncTop.cpp (revision 188) +++ /trunk/source/Lib/TLibEncoder/TEncTop.cpp (revision 189) @@ -294,5 +294,4 @@ if(m_cIlpPic[i]) { - //m_cIlpPic[i]->setPicYuvRec(NULL); m_cIlpPic[i]->destroy(); delete m_cIlpPic[i]; @@ -500,8 +499,13 @@ { TEncPic* pcEPic = new TEncPic; + #if SVC_EXTENSION //Temporal solution, should be modified if(m_layerId > 0) { +#if VPS_EXTN_DIRECT_REF_LAYERS_CONTINUE + TEncTop *pcEncTopBase = (TEncTop *)getRefLayerEnc( m_layerId ); +#else TEncTop *pcEncTopBase = (TEncTop *)getLayerEnc( m_layerId-1 ); +#endif if(m_iSourceWidth != pcEncTopBase->getSourceWidth() || m_iSourceHeight != pcEncTopBase->getSourceHeight() ) { @@ -527,5 +531,9 @@ if(m_layerId > 0) { +#if VPS_EXTN_DIRECT_REF_LAYERS_CONTINUE + TEncTop *pcEncTopBase = (TEncTop *)getRefLayerEnc( m_layerId ); +#else TEncTop *pcEncTopBase = (TEncTop *)getLayerEnc( m_layerId-1 ); +#endif if(m_iSourceWidth != pcEncTopBase->getSourceWidth() || m_iSourceHeight != pcEncTopBase->getSourceHeight() ) { @@ -543,4 +551,5 @@ #endif } + if (getUseSAO()) { @@ -566,4 +575,7 @@ #if REF_IDX_MFM m_cSPS.setMFMEnabledFlag(m_bMFMEnabledFlag); +#endif +#if SCALED_REF_LAYER_OFFSETS + m_cSPS.getScaledRefLayerWindow() = m_scaledRefLayerWindow; #endif ProfileTierLevel& profileTierLevel = *m_cSPS.getPTL()->getGeneralPTL(); @@ -599,6 +611,15 @@ m_cSPS.setMaxCUHeight ( g_uiMaxCUHeight ); m_cSPS.setMaxCUDepth ( g_uiMaxCUDepth ); - m_cSPS.setMinTrDepth ( 0 ); - m_cSPS.setMaxTrDepth ( 1 ); + + Int minCUSize = m_cSPS.getMaxCUWidth() >> ( m_cSPS.getMaxCUDepth()-g_uiAddCUDepth ); + Int log2MinCUSize = 0; + while(minCUSize > 1) + { + minCUSize >>= 1; + log2MinCUSize++; + } + + m_cSPS.setLog2MinCodingBlockSize(log2MinCUSize); + m_cSPS.setLog2DiffMaxMinCodingBlockSize(m_cSPS.getMaxCUDepth()-g_uiAddCUDepth); #if SVC_EXTENSION m_cSPS.setSPSId ( m_iSPSIdCnt ); @@ -618,6 +639,7 @@ m_cSPS.setMaxTrSize ( 1 << m_uiQuadtreeTULog2MaxSize ); - +#if !L0034_COMBINED_LIST_CLEANUP m_cSPS.setUseLComb ( m_bUseLComb ); +#endif Int i; @@ -763,5 +785,20 @@ m_cPPS.setOutputFlagPresentFlag( false ); m_cPPS.setSignHideFlag(getSignHideFlag()); +#if L0386_DB_METRIC + if ( getDeblockingFilterMetric() ) + { + m_cPPS.setDeblockingFilterControlPresentFlag (true); + m_cPPS.setDeblockingFilterOverrideEnabledFlag(true); + m_cPPS.setPicDisableDeblockingFilterFlag(false); + m_cPPS.setDeblockingFilterBetaOffsetDiv2(0); + m_cPPS.setDeblockingFilterTcOffsetDiv2(0); + } + else + { m_cPPS.setDeblockingFilterControlPresentFlag (m_DeblockingFilterControlPresent ); + } +#else + m_cPPS.setDeblockingFilterControlPresentFlag (m_DeblockingFilterControlPresent ); +#endif m_cPPS.setLog2ParallelMergeLevelMinus2 (m_log2ParallelMergeLevelMinus2 ); m_cPPS.setCabacInitPresentFlag(CABAC_INIT_PRESENT_FLAG); @@ -810,5 +847,5 @@ } } -#if REF_LIST_BUGFIX +#if REF_IDX_FRAMEWORK if (!m_layerId) { @@ -1036,4 +1073,36 @@ } +#if L0208_SOP_DESCRIPTION_SEI +Int TEncTop::getReferencePictureSetIdxForSOP(TComSlice* slice, Int POCCurr, Int GOPid ) +{ + int rpsIdx = GOPid; + + for(Int extraNum=m_iGOPSize; extraNum 0 && getDecodingRefreshType() > 0) + { + Int POCIndex = POCCurr%m_uiIntraPeriod; + if(POCIndex == 0) + { + POCIndex = m_uiIntraPeriod; + } + if(POCIndex == m_GOPList[extraNum].m_POC) + { + rpsIdx = extraNum; + } + } + else + { + if(POCCurr==m_GOPList[extraNum].m_POC) + { + rpsIdx = extraNum; + } + } + } + + return rpsIdx; +} +#endif + Void TEncTop::xInitPPSforTiles() { @@ -1118,4 +1187,24 @@ } +#if SVC_EXTENSION +#if VPS_EXTN_DIRECT_REF_LAYERS_CONTINUE +TEncTop* TEncTop::getRefLayerEnc( UInt layerId ) +{ + if( m_ppcTEncTop[m_layerId]->getNumDirectRefLayers() <= 0 ) + { +#if ZERO_NUM_DIRECT_LAYERS + return (TEncTop *)getLayerEnc( 0 ); +#else + return NULL; +#endif + } + + // currently only one reference layer is supported + assert( m_ppcTEncTop[m_layerId]->getNumDirectRefLayers() == 1 ); + + return (TEncTop *)getLayerEnc( getVPS()->getRefLayerId( m_layerId, 0 ) ); +} +#endif + #if REF_IDX_FRAMEWORK Void TEncTop::xInitILRP() @@ -1123,4 +1212,11 @@ if(m_layerId>0) { + g_bitDepthY = m_cSPS.getBitDepthY(); + g_bitDepthC = m_cSPS.getBitDepthC(); + g_uiMaxCUWidth = m_cSPS.getMaxCUWidth(); + g_uiMaxCUHeight = m_cSPS.getMaxCUHeight(); + g_uiMaxCUDepth = m_cSPS.getMaxCUDepth(); + g_uiAddCUDepth = max (0, m_cSPS.getLog2MinCodingBlockSize() - (Int)m_cSPS.getQuadtreeTULog2MinSize() ); + Int numReorderPics[MAX_TLAYER]; Window &conformanceWindow = m_cSPS.getConformanceWindow(); @@ -1132,5 +1228,4 @@ { m_cIlpPic[j] = new TComPic; - //m_cIlpPic[j]->createWithOutYuv(m_iSourceWidth, m_iSourceHeight, g_uiMaxCUWidth, g_uiMaxCUHeight, g_uiMaxCUDepth, &m_cSPS, true); #if SVC_UPSAMPLING m_cIlpPic[j]->create(m_iSourceWidth, m_iSourceHeight, g_uiMaxCUWidth, g_uiMaxCUHeight, g_uiMaxCUDepth, conformanceWindow, defaultDisplayWindow, numReorderPics, &m_cSPS, true); @@ -1151,8 +1246,7 @@ if(m_cIlpPic[0]) { - //m_cIlpPic[0]->setPicYuvRec(pcPic->getFullPelBaseRec()); m_cIlpPic[0]->copyUpsampledPictureYuv(pcPic->getFullPelBaseRec(), m_cIlpPic[0]->getPicYuvRec()); m_cIlpPic[0]->getSlice(0)->setPOC(pcPic->getPOC()); - m_cIlpPic[0]->setLayerId(0); //set reference layerId + m_cIlpPic[0]->setLayerId(pcPic->getSlice(0)->getBaseColPic()->getLayerId()); //set reference layerId m_cIlpPic[0]->getPicYuvRec()->setBorderExtension(false); m_cIlpPic[0]->getPicYuvRec()->extendPicBorder(); @@ -1160,3 +1254,4 @@ } #endif +#endif //! \} Index: /trunk/source/Lib/TLibEncoder/TEncTop.h =================================================================== --- /trunk/source/Lib/TLibEncoder/TEncTop.h (revision 188) +++ /trunk/source/Lib/TLibEncoder/TEncTop.h (revision 189) @@ -139,4 +139,7 @@ Bool m_bMFMEnabledFlag; #endif +#if SCALED_REF_LAYER_OFFSETS + Window m_scaledRefLayerWindow; +#endif protected: Void xGetNewPicBuffer ( TComPic*& rpcPic ); ///< get picture buffer which will be processed @@ -192,4 +195,7 @@ TComPPS* getPPS () { return &m_cPPS; } Void selectReferencePictureSet(TComSlice* slice, Int POCCurr, Int GOPid ); +#if L0208_SOP_DESCRIPTION_SEI + Int getReferencePictureSetIdxForSOP(TComSlice* slice, Int POCCurr, Int GOPid ); +#endif TComScalingList* getScalingList () { return &m_scalingList; } #if SVC_EXTENSION @@ -200,4 +206,7 @@ Void setNumPicRcvd ( Int num ) { m_iNumPicRcvd = num; } #endif +#if SCALED_REF_LAYER_OFFSETS + Window& getScaledRefLayerWindow() { return m_scaledRefLayerWindow; } +#endif // ------------------------------------------------------------------------------------------------------------------- @@ -209,9 +218,9 @@ #if REF_IDX_FRAMEWORK TComPic** getIlpList() { return m_cIlpPic; } - Void setILRPic(TComPic *pcPic); + Void setILRPic(TComPic *pcPic); #endif #if REF_IDX_MFM - Void setMFMEnabledFlag (Bool flag) {m_bMFMEnabledFlag = flag;} - Bool getMFMEnabledFlag() {return m_bMFMEnabledFlag;} + Void setMFMEnabledFlag (Bool flag) {m_bMFMEnabledFlag = flag;} + Bool getMFMEnabledFlag() {return m_bMFMEnabledFlag;} #endif #if AVC_SYNTAX @@ -219,7 +228,9 @@ fstream* getBLSyntaxFile() { return m_pBLSyntaxFile; } #endif - Void encode( TComPicYuv* pcPicYuvOrg, TComList& rcListPicYuvRecOut, - std::list& accessUnitsOut, Int iPicIdInGOP ); - Void encodePrep( TComPicYuv* pcPicYuvOrg ); + Void encode( TComPicYuv* pcPicYuvOrg, TComList& rcListPicYuvRecOut, std::list& accessUnitsOut, Int iPicIdInGOP ); + Void encodePrep( TComPicYuv* pcPicYuvOrg ); +#if VPS_EXTN_DIRECT_REF_LAYERS_CONTINUE + TEncTop* getRefLayerEnc(UInt layerId); +#endif #else Void encode( Bool bEos, TComPicYuv* pcPicYuvOrg, TComList& rcListPicYuvRecOut, Index: /trunk/source/Lib/TLibEncoder/WeightPredAnalysis.cpp =================================================================== --- /trunk/source/Lib/TLibEncoder/WeightPredAnalysis.cpp (revision 188) +++ /trunk/source/Lib/TLibEncoder/WeightPredAnalysis.cpp (revision 189) @@ -235,11 +235,15 @@ Int offset = (Int)( ((currDC<> realLog2Denom ); - // Chroma offset range limination + // Chroma offset range limitation if(comp) { - Int shift = 1 << (g_bitDepthC - 1); - Int pred = ( shift - ( ( shift*weight)>>(log2Denom) ) ); + Int pred = ( 128 - ( ( 128*weight)>>(log2Denom) ) ); Int deltaOffset = Clip3( -512, 511, (offset - pred) ); // signed 10bit offset = Clip3( -128, 127, (deltaOffset + pred) ); // signed 8bit + } + // Luma offset range limitation + else + { + offset = Clip3( -128, 127, offset); }