func (this *TDecGop) DumpMotionField(rpcPic *TLibCommon.TComPic) {
	pPicSym := rpcPic.GetPicSym()
	if !rpcPic.GetSlice(0).IsIntra() {
		fmt.Printf("L0 MV:\n")
		for uiCUAddr := uint(0); uiCUAddr < pPicSym.GetFrameHeightInCU()*pPicSym.GetFrameWidthInCU(); uiCUAddr++ {
			fmt.Printf("LCU %d\n", uiCUAddr)
			pcCU := pPicSym.GetCU(uiCUAddr)
			for uiPartIdx := uint(0); uiPartIdx < pcCU.GetTotalNumPart(); uiPartIdx++ {
				cMv := pcCU.GetCUMvField(TLibCommon.REF_PIC_LIST_0).GetMv(int(uiPartIdx))

				fmt.Printf("(%d,%d) ", cMv.GetHor(), cMv.GetVer())
			}
			fmt.Printf("\n")
		}
		fmt.Printf("\n")
	}

	if rpcPic.GetSlice(0).IsInterB() {
		fmt.Printf("L1 MV:\n")
		for uiCUAddr := uint(0); uiCUAddr < pPicSym.GetFrameHeightInCU()*pPicSym.GetFrameWidthInCU(); uiCUAddr++ {
			fmt.Printf("LCU %d\n", uiCUAddr)
			pcCU := pPicSym.GetCU(uiCUAddr)
			for uiPartIdx := uint(0); uiPartIdx < pcCU.GetTotalNumPart(); uiPartIdx++ {
				cMv := pcCU.GetCUMvField(TLibCommon.REF_PIC_LIST_1).GetMv(int(uiPartIdx))

				fmt.Printf("(%d,%d) ", cMv.GetHor(), cMv.GetVer())
			}
			fmt.Printf("\n")
		}
		fmt.Printf("\n")
	}
}

// -------------------------------------------------------------------------------------------------------------------
// member access functions
// -------------------------------------------------------------------------------------------------------------------
func (this *TEncTop) xGetNewPicBuffer() *TLibCommon.TComPic { ///< get picture buffer which will be processed
	var rpcPic *TLibCommon.TComPic

	TLibCommon.SortPicList(this.m_cListPic)

	if this.m_cListPic.Len() >= (this.GetEncCfg().m_iGOPSize + this.GetEncCfg().GetMaxDecPicBuffering(TLibCommon.MAX_TLAYER-1) + 2) {

		//Int iSize = Int( this.m_cListPic.size() );
		for iterPic := this.m_cListPic.Front(); iterPic != nil; iterPic = iterPic.Next() {
			rpcPic = iterPic.Value.(*TLibCommon.TComPic)

			if rpcPic.GetSlice(0).IsReferenced() == false {
				break
			}
		}
	} else {
		if this.GetEncCfg().GetUseAdaptiveQP() {
			pcEPic := TLibCommon.NewTComPic()
			pcEPic.Create(this.GetEncCfg().m_iSourceWidth, this.GetEncCfg().m_iSourceHeight,
				TLibCommon.G_uiMaxCUWidth, TLibCommon.G_uiMaxCUHeight, TLibCommon.G_uiMaxCUDepth, this.m_cPPS.GetMaxCuDQPDepth()+1,
				this.GetEncCfg().m_conformanceWindow, this.GetEncCfg().m_defaultDisplayWindow, this.GetEncCfg().m_numReorderPics[:], false)
			rpcPic = pcEPic
		} else {
			rpcPic = TLibCommon.NewTComPic()
			rpcPic.Create(this.GetEncCfg().m_iSourceWidth, this.GetEncCfg().m_iSourceHeight,
				TLibCommon.G_uiMaxCUWidth, TLibCommon.G_uiMaxCUHeight, TLibCommon.G_uiMaxCUDepth, 0,
				this.GetEncCfg().m_conformanceWindow, this.GetEncCfg().m_defaultDisplayWindow, this.GetEncCfg().m_numReorderPics[:], false)
		}
		if this.GetEncCfg().GetUseSAO() {
			fmt.Printf("not support SAO\n")
			//rpcPic.GetPicSym().AllocSaoParam(this.m_cEncSAO);
		}
		this.m_cListPic.PushBack(rpcPic)
	}
	rpcPic.SetReconMark(false)

	this.m_iPOCLast++
	this.m_iNumPicRcvd++

	rpcPic.GetSlice(0).SetPOC(this.m_iPOCLast)
	// mark it should be extended
	rpcPic.GetPicYuvRec().SetBorderExtension(false)

	return rpcPic
}

func (this *TDecSlice) DecompressSlice(ppcSubstreams []*TLibCommon.TComInputBitstream, rpcPic *TLibCommon.TComPic, pcSbacDecoder *TDecSbac, pcSbacDecoders []*TDecSbac) {
	//var pcCU *TLibCommon.TComDataCU;
	uiIsLast := uint(0)
	var iStartCUEncOrder uint
	if rpcPic.GetSlice(rpcPic.GetCurrSliceIdx()).GetSliceCurStartCUAddr()/rpcPic.GetNumPartInCU() > rpcPic.GetSlice(rpcPic.GetCurrSliceIdx()).GetSliceSegmentCurStartCUAddr()/rpcPic.GetNumPartInCU() {
		iStartCUEncOrder = rpcPic.GetSlice(rpcPic.GetCurrSliceIdx()).GetSliceCurStartCUAddr() / rpcPic.GetNumPartInCU()
	} else {
		iStartCUEncOrder = rpcPic.GetSlice(rpcPic.GetCurrSliceIdx()).GetSliceSegmentCurStartCUAddr() / rpcPic.GetNumPartInCU()
	}
	iStartCUAddr := int(rpcPic.GetPicSym().GetCUOrderMap(int(iStartCUEncOrder)))

	// decoder don't need prediction & residual frame buffer
	rpcPic.SetPicYuvPred(nil)
	rpcPic.SetPicYuvResi(nil)

	//#if ENC_DEC_TRACE
	//  g_bJustDoIt = g_bEncDecTraceEnable;
	//#endif
	//  DTRACE_CABAC_VL( g_nSymbolCounter++ );
	//  DTRACE_CABAC_T( "\tPOC: " );
	//  DTRACE_CABAC_V( rpcPic.GetPOC() );
	//  DTRACE_CABAC_T( "\n" );
	//#if ENC_DEC_TRACE
	//  g_bJustDoIt = g_bEncDecTraceDisable;
	//#endif

	uiTilesAcross := rpcPic.GetPicSym().GetNumColumnsMinus1() + 1
	pcSlice := rpcPic.GetSlice(rpcPic.GetCurrSliceIdx())
	iNumSubstreams := pcSlice.GetPPS().GetNumSubstreams()

	// delete decoders if already allocated in previous slice
	/*if (m_pcBufferSbacDecoders)
	  {
	    delete [] m_pcBufferSbacDecoders;
	  }
	  if (m_pcBufferBinCABACs)
	  {
	    delete [] m_pcBufferBinCABACs;
	  }*/
	// allocate new decoders based on tile numbaer
	this.m_pcBufferSbacDecoders = make([]*TDecSbac, uiTilesAcross)
	this.m_pcBufferBinCABACs = make([]*TDecBinCabac, uiTilesAcross)
	for ui := 0; ui < uiTilesAcross; ui++ {
		this.m_pcBufferBinCABACs[ui] = NewTDecBinCabac()
		this.m_pcBufferSbacDecoders[ui] = NewTDecSbac()
		this.m_pcBufferSbacDecoders[ui].Init(this.m_pcBufferBinCABACs[ui])
	}
	//save init. state
	for ui := 0; ui < uiTilesAcross; ui++ {
		this.m_pcBufferSbacDecoders[ui].Load(pcSbacDecoder)
	}

	// free memory if already allocated in previous call
	/*if (this.m_pcBufferLowLatSbacDecoders)
	  {
	    delete [] this.m_pcBufferLowLatSbacDecoders;
	  }
	  if (this.m_pcBufferLowLatBinCABACs)
	  {
	    delete [] this.m_pcBufferLowLatBinCABACs;
	  }*/
	this.m_pcBufferLowLatSbacDecoders = make([]*TDecSbac, uiTilesAcross)
	this.m_pcBufferLowLatBinCABACs = make([]*TDecBinCabac, uiTilesAcross)
	for ui := 0; ui < uiTilesAcross; ui++ {
		this.m_pcBufferLowLatBinCABACs[ui] = NewTDecBinCabac()
		this.m_pcBufferLowLatSbacDecoders[ui] = NewTDecSbac()
		this.m_pcBufferLowLatSbacDecoders[ui].Init(this.m_pcBufferLowLatBinCABACs[ui])
	}
	//save init. state
	for ui := 0; ui < uiTilesAcross; ui++ {
		this.m_pcBufferLowLatSbacDecoders[ui].Load(pcSbacDecoder)
	}

	uiWidthInLCUs := rpcPic.GetPicSym().GetFrameWidthInCU()
	//UInt uiHeightInLCUs = rpcPic.GetPicSym().GetFrameHeightInCU();
	uiCol := uint(0)
	uiLin := uint(0)
	uiSubStrm := uint(0)

	var uiTileCol, uiTileStartLCU, uiTileLCUX uint
	iNumSubstreamsPerTile := 1 // if independent.
	depSliceSegmentsEnabled := rpcPic.GetSlice(rpcPic.GetCurrSliceIdx()).GetPPS().GetDependentSliceSegmentsEnabledFlag()
	uiTileStartLCU = rpcPic.GetPicSym().GetTComTile(rpcPic.GetPicSym().GetTileIdxMap(iStartCUAddr)).GetFirstCUAddr()
	if depSliceSegmentsEnabled {
		if (!rpcPic.GetSlice(rpcPic.GetCurrSliceIdx()).IsNextSlice()) && iStartCUAddr != int(rpcPic.GetPicSym().GetTComTile(rpcPic.GetPicSym().GetTileIdxMap(iStartCUAddr)).GetFirstCUAddr()) {
			if pcSlice.GetPPS().GetEntropyCodingSyncEnabledFlag() {
				uiTileCol = rpcPic.GetPicSym().GetTileIdxMap(iStartCUAddr) % uint(rpcPic.GetPicSym().GetNumColumnsMinus1()+1)
				this.m_pcBufferSbacDecoders[uiTileCol].LoadContexts(this.CTXMem[1]) //2.LCU
				if (uint(iStartCUAddr)%uiWidthInLCUs + 1) >= uiWidthInLCUs {
					uiTileLCUX = uiTileStartLCU % uiWidthInLCUs
					uiCol = uint(iStartCUAddr) % uiWidthInLCUs
					if uiCol == uiTileLCUX {
						this.CTXMem[0].LoadContexts(pcSbacDecoder)
					}
				}
			}
			pcSbacDecoder.LoadContexts(this.CTXMem[0]) //end of depSlice-1
			pcSbacDecoders[uiSubStrm].LoadContexts(pcSbacDecoder)
		} else {
			if pcSlice.GetPPS().GetEntropyCodingSyncEnabledFlag() {
//.........这里部分代码省略.........

func (this *TDecGop) DecompressSlice(pcBitstream *TLibCommon.TComInputBitstream, rpcPic *TLibCommon.TComPic, pTraceFile io.Writer) {
	pcSlice := rpcPic.GetSlice(rpcPic.GetCurrSliceIdx())
	// Table of extracted substreams.
	// These must be deallocated AND their internal fifos, too.
	//TComInputBitstream **ppcSubstreams = NULL;

	//-- For time output for each slice
	iBeforeTime := time.Now()

	uiStartCUAddr := pcSlice.GetSliceSegmentCurStartCUAddr()

	uiSliceStartCuAddr := pcSlice.GetSliceCurStartCUAddr()
	if uiSliceStartCuAddr == uiStartCUAddr {
		l := len(this.m_sliceStartCUAddress)
		this.m_sliceStartCUAddress[l] = int(uiSliceStartCuAddr)
		//this.m_sliceStartCUAddress.PushBack(uiSliceStartCuAddr);
	}

	this.m_pcSbacDecoder.Init(this.m_pcBinCABAC) //(TDecBinIf*)
	this.m_pcEntropyDecoder.SetEntropyDecoder(this.m_pcSbacDecoder)
	this.m_pcEntropyDecoder.SetTraceFile(pTraceFile)

	var uiNumSubstreams uint

	if pcSlice.GetPPS().GetEntropyCodingSyncEnabledFlag() {
		uiNumSubstreams = uint(pcSlice.GetNumEntryPointOffsets() + 1)
	} else {
		uiNumSubstreams = uint(pcSlice.GetPPS().GetNumSubstreams())
	}

	// init each couple {EntropyDecoder, Substream}
	puiSubstreamSizes := pcSlice.GetSubstreamSizes()
	ppcSubstreams := make([]*TLibCommon.TComInputBitstream, uiNumSubstreams)
	this.m_pcSbacDecoders = make([]*TDecSbac, uiNumSubstreams)
	this.m_pcBinCABACs = make([]*TDecBinCabac, uiNumSubstreams)
	for ui := uint(0); ui < uiNumSubstreams; ui++ {
		this.m_pcSbacDecoders[ui] = NewTDecSbac()
		this.m_pcBinCABACs[ui] = NewTDecBinCabac()
		this.m_pcSbacDecoders[ui].Init(this.m_pcBinCABACs[ui])
		if ui+1 < uiNumSubstreams {
			ppcSubstreams[ui] = pcBitstream.ExtractSubstream(puiSubstreamSizes[ui])
		} else {
			ppcSubstreams[ui] = pcBitstream.ExtractSubstream(pcBitstream.GetNumBitsLeft())
		}
	}

	for ui := uint(0); ui+1 < uiNumSubstreams; ui++ {
		this.m_pcEntropyDecoder.SetEntropyDecoder(this.m_pcSbacDecoders[uiNumSubstreams-1-ui])
		this.m_pcEntropyDecoder.SetTraceFile(pTraceFile)
		this.m_pcEntropyDecoder.SetBitstream(ppcSubstreams[uiNumSubstreams-1-ui])
		this.m_pcEntropyDecoder.ResetEntropy(pcSlice)
	}

	this.m_pcEntropyDecoder.SetEntropyDecoder(this.m_pcSbacDecoder)
	this.m_pcEntropyDecoder.SetTraceFile(pTraceFile)
	this.m_pcEntropyDecoder.SetBitstream(ppcSubstreams[0])
	this.m_pcEntropyDecoder.ResetEntropy(pcSlice)

	if uiSliceStartCuAddr == uiStartCUAddr {
		l := len(this.m_LFCrossSliceBoundaryFlag)
		this.m_LFCrossSliceBoundaryFlag[l] = pcSlice.GetLFCrossSliceBoundaryFlag()
		//this.m_LFCrossSliceBoundaryFlag.PushBack( pcSlice.GetLFCrossSliceBoundaryFlag());
	}
	this.m_pcSbacDecoders[0].Load(this.m_pcSbacDecoder)
	this.m_pcSliceDecoder.DecompressSlice(ppcSubstreams, rpcPic, this.m_pcSbacDecoder, this.m_pcSbacDecoders)
	this.m_pcEntropyDecoder.SetBitstream(ppcSubstreams[uiNumSubstreams-1])
	// deallocate all created substreams, including internal buffers.
	/*for ui := uint(0); ui < uiNumSubstreams; ui++ {
	    ppcSubstreams[ui]->deleteFifo();
	    delete ppcSubstreams[ui];
	  }
	  delete[] ppcSubstreams;
	  delete[] m_pcSbacDecoders;
	  delete[] m_pcBinCABACs;
	*/
	this.m_pcSbacDecoders = nil
	this.m_pcBinCABACs = nil

	lAfterTime := time.Now()
	this.m_dDecTime += lAfterTime.Sub(iBeforeTime)
}

func (this *TDecGop) FilterPicture(rpcPic *TLibCommon.TComPic) {
	pcSlice := rpcPic.GetSlice(rpcPic.GetCurrSliceIdx())

	//-- For time output for each slice
	iBeforeTime := time.Now()

	// deblocking filter
	bLFCrossTileBoundary := pcSlice.GetPPS().GetLoopFilterAcrossTilesEnabledFlag()
	this.m_pcLoopFilter.SetCfg(bLFCrossTileBoundary)
	this.m_pcLoopFilter.LoopFilterPic(rpcPic)

	if pcSlice.GetSPS().GetUseSAO() {
		l := len(this.m_sliceStartCUAddress)
		this.m_sliceStartCUAddress[l] = int(rpcPic.GetNumCUsInFrame() * rpcPic.GetNumPartInCU())
		///this.m_sliceStartCUAddress.PushBack(rpcPic.GetNumCUsInFrame()* rpcPic.GetNumPartInCU());
		rpcPic.CreateNonDBFilterInfo(this.m_sliceStartCUAddress, 0, this.m_LFCrossSliceBoundaryFlag, rpcPic.GetPicSym().GetNumTiles(), bLFCrossTileBoundary)
	}

	if pcSlice.GetSPS().GetUseSAO() {
		saoParam := rpcPic.GetPicSym().GetSaoParam()
		saoParam.SaoFlag[0] = pcSlice.GetSaoEnabledFlag()
		saoParam.SaoFlag[1] = pcSlice.GetSaoEnabledFlagChroma()
		this.m_pcSAO.SetSaoLcuBasedOptimization(true)
		this.m_pcSAO.CreatePicSaoInfo(rpcPic) //, len(this.m_sliceStartCUAddress)-1)
		this.m_pcSAO.SAOProcess(saoParam)
		this.m_pcSAO.PCMLFDisableProcess(rpcPic)
		this.m_pcSAO.DestroyPicSaoInfo()
	}

	if pcSlice.GetSPS().GetUseSAO() {
		rpcPic.DestroyNonDBFilterInfo()
	}

	rpcPic.CompressMotion()

	//this.DumpMotionField(rpcPic);

	var c string

	if pcSlice.IsIntra() {
		c = "I"
	} else if pcSlice.IsInterP() {
		if pcSlice.IsReferenced() {
			c = "P"
		} else {
			c = "p"
		}
	} else {
		if pcSlice.IsReferenced() {
			c = "B"
		} else {
			c = "b"
		}
	}

	//-- For time output for each slice
	fmt.Printf("\nPOC %4d TId: %1d ( %s-SLICE, QP%3d ) ", pcSlice.GetPOC(), pcSlice.GetTLayer(), c, pcSlice.GetSliceQp())

	this.m_dDecTime += time.Now().Sub(iBeforeTime)
	fmt.Printf("[DT %10v] ", this.m_dDecTime)
	this.m_dDecTime = 0

	for iRefList := 0; iRefList < 2; iRefList++ {
		fmt.Printf("[L%d ", iRefList)
		for iRefIndex := 0; iRefIndex < pcSlice.GetNumRefIdx(TLibCommon.RefPicList(iRefList)); iRefIndex++ {
			fmt.Printf("%d ", pcSlice.GetRefPOC(TLibCommon.RefPicList(iRefList), iRefIndex))
		}
		fmt.Printf("] ")
	}
	if this.m_decodedPictureHashSEIEnabled > 0 {
		this.CalcAndPrintHashStatus(rpcPic.GetPicYuvRec(), rpcPic.GetSEIs())
	}

	rpcPic.SetOutputMark(true)
	rpcPic.SetReconMark(true)

	//this.m_sliceStartCUAddress.Init();
	//this.m_LFCrossSliceBoundaryFlag.Init();
	slicesize := len(this.m_sliceStartCUAddress)

	for i := 0; i < slicesize; i++ {
		delete(this.m_sliceStartCUAddress, i)
	}
	if len(this.m_sliceStartCUAddress) != 0 {
		fmt.Printf("clear this.m_sliceStartCUAddress error\n")
	}

	lfsize := len(this.m_LFCrossSliceBoundaryFlag)

	for i := 0; i < lfsize; i++ {
		delete(this.m_LFCrossSliceBoundaryFlag, i)
	}
	if len(this.m_LFCrossSliceBoundaryFlag) != 0 {
		fmt.Printf("clear this.m_LFCrossSliceBoundaryFlag error\n")
	}
}