Context navigation

source: SHVCSoftware/branches/SHM-dev/source/Lib/TLibEncoder/TEncTop.h @ 1114

Visit:

Last change on this file since 1114 was 1093, checked in by seregin, 9 years ago
cleanup macros: POC_RESET_RPS, PREVTID0_POC_RESET, POC_RESET_FLAG
Property svn:eol-style set to `native`
File size: 16.5 KB

Line
1	/* The copyright in this software is being made available under the BSD
2	* License, included below. This software may be subject to other third party
3	* and contributor rights, including patent rights, and no such rights are
4	* granted under this license.
5	*
6	* Copyright (c) 2010-2014, ITU/ISO/IEC
7	* All rights reserved.
8	*
9	* Redistribution and use in source and binary forms, with or without
10	* modification, are permitted provided that the following conditions are met:
11	*
12	* * Redistributions of source code must retain the above copyright notice,
13	* this list of conditions and the following disclaimer.
14	* * Redistributions in binary form must reproduce the above copyright notice,
15	* this list of conditions and the following disclaimer in the documentation
16	* and/or other materials provided with the distribution.
17	* * Neither the name of the ITU/ISO/IEC nor the names of its contributors may
18	* be used to endorse or promote products derived from this software without
19	* specific prior written permission.
20	*
21	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
22	* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24	* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS
25	* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
26	* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
27	* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
28	* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
29	* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
30	* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
31	* THE POSSIBILITY OF SUCH DAMAGE.
32	*/
33
34	/** \file TEncTop.h
35	\brief encoder class (header)
36	*/
37
38	#ifndef __TENCTOP__
39	#define __TENCTOP__
40
41	// Include files
42	#include "TLibCommon/TComList.h"
43	#include "TLibCommon/TComPrediction.h"
44	#include "TLibCommon/TComTrQuant.h"
45	#include "TLibCommon/TComLoopFilter.h"
46	#include "TLibCommon/AccessUnit.h"
47
48	#include "TLibVideoIO/TVideoIOYuv.h"
49
50	#include "TEncCfg.h"
51	#include "TEncGOP.h"
52	#include "TEncSlice.h"
53	#include "TEncEntropy.h"
54	#include "TEncCavlc.h"
55	#include "TEncSbac.h"
56	#include "TEncSearch.h"
57	#include "TEncSampleAdaptiveOffset.h"
58	#include "TEncPreanalyzer.h"
59	#include "TEncRateCtrl.h"
60	//! \ingroup TLibEncoder
61	//! \{
62
63	// ====================================================================================================================
64	// Class definition
65	// ====================================================================================================================
66
67	/// encoder class
68	class TEncTop : public TEncCfg
69	{
70	private:
71	// picture
72	Int m_iPOCLast; ///< time index (POC)
73	Int m_iNumPicRcvd; ///< number of received pictures
74	UInt m_uiNumAllPicCoded; ///< number of coded pictures
75	TComList<TComPic*> m_cListPic; ///< dynamic list of pictures
76
77	// encoder search
78	TEncSearch m_cSearch; ///< encoder search class
79	//TEncEntropy* m_pcEntropyCoder; ///< entropy encoder
80	TEncCavlc* m_pcCavlcCoder; ///< CAVLC encoder
81	// coding tool
82	TComTrQuant m_cTrQuant; ///< transform & quantization class
83	TComLoopFilter m_cLoopFilter; ///< deblocking filter class
84	TEncSampleAdaptiveOffset m_cEncSAO; ///< sample adaptive offset class
85	TEncEntropy m_cEntropyCoder; ///< entropy encoder
86	TEncCavlc m_cCavlcCoder; ///< CAVLC encoder
87	TEncSbac m_cSbacCoder; ///< SBAC encoder
88	TEncBinCABAC m_cBinCoderCABAC; ///< bin coder CABAC
89
90	// processing unit
91	TEncGOP m_cGOPEncoder; ///< GOP encoder
92	TEncSlice m_cSliceEncoder; ///< slice encoder
93	TEncCu m_cCuEncoder; ///< CU encoder
94	// SPS
95	TComSPS m_cSPS; ///< SPS
96	TComPPS m_cPPS; ///< PPS
97	// RD cost computation
98	TComRdCost m_cRdCost; ///< RD cost computation class
99	TEncSbac*** m_pppcRDSbacCoder; ///< temporal storage for RD computation
100	TEncSbac m_cRDGoOnSbacCoder; ///< going on SBAC model for RD stage
101	#if FAST_BIT_EST
102	TEncBinCABACCounter*** m_pppcBinCoderCABAC; ///< temporal CABAC state storage for RD computation
103	TEncBinCABACCounter m_cRDGoOnBinCoderCABAC; ///< going on bin coder CABAC for RD stage
104	#else
105	TEncBinCABAC*** m_pppcBinCoderCABAC; ///< temporal CABAC state storage for RD computation
106	TEncBinCABAC m_cRDGoOnBinCoderCABAC; ///< going on bin coder CABAC for RD stage
107	#endif
108
109	// quality control
110	TEncPreanalyzer m_cPreanalyzer; ///< image characteristics analyzer for TM5-step3-like adaptive QP
111
112	TComScalingList m_scalingList; ///< quantization matrix information
113	TEncRateCtrl m_cRateCtrl; ///< Rate control class
114
115	#if SVC_EXTENSION
116	static Int m_iSPSIdCnt; ///< next Id number for SPS
117	static Int m_iPPSIdCnt; ///< next Id number for PPS
118	TEncTop** m_ppcTEncTop;
119	TEncTop* getLayerEnc(UInt layerIdx) { return m_ppcTEncTop[layerIdx]; }
120	TComPic* m_cIlpPic[MAX_NUM_REF]; ///< Inter layer Prediction picture = upsampled picture
121	#if REF_IDX_MFM
122	Bool m_bMFMEnabledFlag;
123	#endif
124	UInt m_numRefLayerLocationOffsets;
125	#if O0098_SCALED_REF_LAYER_ID
126	UInt m_refLocationOffsetLayerId[MAX_LAYERS];
127	#endif
128	Window m_scaledRefLayerWindow[MAX_LAYERS];
129	UInt m_numRefLayerOffsets;
130	UInt m_refLayerId[MAX_LAYERS];
131	Window m_refLayerWindow[MAX_LAYERS];
132	Bool m_scaledRefLayerOffsetPresentFlag[MAX_LAYERS];
133	Bool m_refRegionOffsetPresentFlag[MAX_LAYERS];
134	Int m_phaseHorLuma [MAX_LAYERS];
135	Int m_phaseVerLuma [MAX_LAYERS];
136	Int m_phaseHorChroma[MAX_LAYERS];
137	Int m_phaseVerChroma[MAX_LAYERS];
138	Int m_resamplePhaseSetPresentFlag[MAX_LAYERS];
139	#if POC_RESET_IDC_ENCODER
140	Int m_pocAdjustmentValue;
141	#endif
142	#if NO_CLRAS_OUTPUT_FLAG
143	Bool m_noClrasOutputFlag;
144	Bool m_layerInitializedFlag;
145	Bool m_firstPicInLayerDecodedFlag;
146	Bool m_noOutputOfPriorPicsFlags;
147	#endif
148	#if O0194_WEIGHTED_PREDICTION_CGS
149	Bool m_interLayerWeightedPredFlag;
150	#endif
151	#if Q0078_ADD_LAYER_SETS
152	int m_numAddLayerSets;
153	#endif
154	#if P0297_VPS_POC_LSB_ALIGNED_FLAG
155	Bool m_pocDecrementedInDPBFlag;
156	Int m_currPocMsb;
157	#endif
158	#if R0071_IRAP_EOS_CROSS_LAYER_IMPACTS
159	Bool m_prevPicHasEos;
160	#endif
161	#endif //SVC_EXTENSION
162	protected:
163	Void xGetNewPicBuffer ( TComPic*& rpcPic ); ///< get picture buffer which will be processed
164	Void xInitSPS (); ///< initialize SPS from encoder options
165	Void xInitPPS (); ///< initialize PPS from encoder options
166
167	Void xInitPPSforTiles ();
168	Void xInitRPS (Bool isFieldCoding); ///< initialize PPS from encoder options
169	#if SVC_EXTENSION
170	Void xInitILRP();
171	#endif
172	public:
173	TEncTop();
174	virtual ~TEncTop();
175
176	Void create ();
177	Void destroy ();
178	Void init (Bool isFieldCoding);
179	Void deletePicBuffer ();
180
181	// -------------------------------------------------------------------------------------------------------------------
182	// member access functions
183	// -------------------------------------------------------------------------------------------------------------------
184
185	TComList<TComPic> getListPic () { return &m_cListPic; }
186	TEncSearch* getPredSearch () { return &m_cSearch; }
187
188	TComTrQuant* getTrQuant () { return &m_cTrQuant; }
189	TComLoopFilter* getLoopFilter () { return &m_cLoopFilter; }
190	TEncSampleAdaptiveOffset* getSAO () { return &m_cEncSAO; }
191	TEncGOP* getGOPEncoder () { return &m_cGOPEncoder; }
192	TEncSlice* getSliceEncoder () { return &m_cSliceEncoder; }
193	TEncCu* getCuEncoder () { return &m_cCuEncoder; }
194	TEncEntropy* getEntropyCoder () { return &m_cEntropyCoder; }
195	TEncCavlc* getCavlcCoder () { return &m_cCavlcCoder; }
196	TEncSbac* getSbacCoder () { return &m_cSbacCoder; }
197	TEncBinCABAC* getBinCABAC () { return &m_cBinCoderCABAC; }
198
199	TComRdCost* getRdCost () { return &m_cRdCost; }
200	TEncSbac*** getRDSbacCoder () { return m_pppcRDSbacCoder; }
201	TEncSbac* getRDGoOnSbacCoder () { return &m_cRDGoOnSbacCoder; }
202	TEncRateCtrl* getRateCtrl () { return &m_cRateCtrl; }
203	TComSPS* getSPS () { return &m_cSPS; }
204	TComPPS* getPPS () { return &m_cPPS; }
205	Void selectReferencePictureSet(TComSlice* slice, Int POCCurr, Int GOPid );
206	Int getReferencePictureSetIdxForSOP(TComSlice* slice, Int POCCurr, Int GOPid );
207	TComScalingList* getScalingList () { return &m_scalingList; }
208	// -------------------------------------------------------------------------------------------------------------------
209	// encoder function
210	// -------------------------------------------------------------------------------------------------------------------
211
212	/// encode several number of pictures until end-of-sequence
213	#if SVC_EXTENSION
214	Void setLayerEnc(TEncTop** p) { m_ppcTEncTop = p; }
215	TEncTop** getLayerEnc() { return m_ppcTEncTop; }
216	Int getPOCLast () { return m_iPOCLast; }
217	Int getNumPicRcvd () { return m_iNumPicRcvd; }
218	Void setNumPicRcvd ( Int num ) { m_iNumPicRcvd = num; }
219	Void setNumRefLayerLocationOffsets(Int x) { m_numRefLayerLocationOffsets = x; }
220	UInt getNumRefLayerLocationOffsets() { return m_numRefLayerLocationOffsets; }
221	#if O0098_SCALED_REF_LAYER_ID
222	Void setRefLocationOffsetLayerId(Int x, UInt id) { m_refLocationOffsetLayerId[x] = id; }
223	UInt getRefLocationOffsetLayerId(Int x) { return m_refLocationOffsetLayerId[x]; }
224	Window& getScaledRefLayerWindowForLayer(Int layerId);
225	#endif
226	Window& getScaledRefLayerWindow(Int x) { return m_scaledRefLayerWindow[x]; }
227	Void setNumRefLayerOffsets(Int x) { m_numRefLayerOffsets = x; }
228	UInt getNumRefLayerOffsets() { return m_numRefLayerOffsets; }
229	Void setRefLayerId(Int layerIdx, UInt layerId) { m_refLayerId[layerIdx] = layerId; }
230	UInt getRefLayerId(Int layerIdx) { return m_refLayerId[layerIdx]; }
231	Window& getRefLayerWindowForLayer(Int layerId);
232	Window& getRefLayerWindow(Int x) { return m_refLayerWindow[x]; }
233	Bool getScaledRefLayerOffsetPresentFlag(Int x) { return m_scaledRefLayerOffsetPresentFlag[x]; }
234	Void setScaledRefLayerOffsetPresentFlag(Int x, Bool b) { m_scaledRefLayerOffsetPresentFlag[x] = b; }
235	Bool getRefRegionOffsetPresentFlag(Int x) { return m_refRegionOffsetPresentFlag[x]; }
236	Void setRefRegionOffsetPresentFlag(Int x, Bool b) { m_refRegionOffsetPresentFlag[x] = b; }
237	Int getPhaseHorLuma(Int x) { return m_phaseHorLuma[x]; }
238	Int getPhaseVerLuma(Int x) { return m_phaseVerLuma[x]; }
239	Int getPhaseHorChroma(Int x) { return m_phaseHorChroma[x]; }
240	Int getPhaseVerChroma(Int x) { return m_phaseVerChroma[x]; }
241	Void setPhaseHorLuma(Int x, Int val) { m_phaseHorLuma[x] = val; }
242	Void setPhaseVerLuma(Int x, Int val) { m_phaseVerLuma[x] = val; }
243	Void setPhaseHorChroma(Int x, Int val) { m_phaseHorChroma[x] = val; }
244	Void setPhaseVerChroma(Int x, Int val) { m_phaseVerChroma[x] = val; }
245	Bool getResamplePhaseSetPresentFlag(Int x) { return m_resamplePhaseSetPresentFlag[x]; }
246	Void setResamplePhaseSetPresentFlag(Int x, Bool b) { m_resamplePhaseSetPresentFlag[x] = b; }
247
248	TComPic** getIlpList() { return m_cIlpPic; }
249	#if REF_IDX_MFM
250	Void setMFMEnabledFlag (Bool flag) { m_bMFMEnabledFlag = flag; }
251	Bool getMFMEnabledFlag() { return m_bMFMEnabledFlag; }
252	#endif
253	#if O0194_WEIGHTED_PREDICTION_CGS
254	Void setInterLayerWeightedPredFlag(Bool flag) { m_interLayerWeightedPredFlag = flag; }
255	Bool getInterLayerWeightedPredFlag() { return m_interLayerWeightedPredFlag; }
256	#endif
257	Void encode ( TComPicYuv* pcPicYuvOrg, const InputColourSpaceConversion snrCSC, TComList<TComPicYuv*>& rcListPicYuvRecOut, std::list<AccessUnit>& accessUnitsOut, Int iPicIdInGOP );
258	Void encodePrep( TComPicYuv* pcPicYuvOrg, TComPicYuv* pcPicYuvTrueOrg );
259	Void encode ( TComPicYuv* pcPicYuvOrg, const InputColourSpaceConversion snrCSC, TComList<TComPicYuv*>& rcListPicYuvRecOut, std::list<AccessUnit>& accessUnitsOut, Int iPicIdInGOP, Bool isTff );
260	Void encodePrep( TComPicYuv* pcPicYuvOrg, TComPicYuv* pcPicYuvTrueOrg, Bool isTff );
261	#if VPS_EXTN_DIRECT_REF_LAYERS
262	TEncTop* getRefLayerEnc(UInt refLayerIdx);
263	#endif
264	#if POC_RESET_IDC_ENCODER
265	Int getPocAdjustmentValue() { return m_pocAdjustmentValue;}
266	Void setPocAdjustmentValue(Int x) { m_pocAdjustmentValue = x; }
267	#endif
268	#if NO_CLRAS_OUTPUT_FLAG
269	Int getNoClrasOutputFlag() { return m_noClrasOutputFlag;}
270	Void setNoClrasOutputFlag(Bool x) { m_noClrasOutputFlag = x; }
271	Int getLayerInitializedFlag() { return m_layerInitializedFlag;}
272	Void setLayerInitializedFlag(Bool x) { m_layerInitializedFlag = x; }
273	Int getFirstPicInLayerDecodedFlag() { return m_firstPicInLayerDecodedFlag;}
274	Void setFirstPicInLayerDecodedFlag(Bool x) { m_firstPicInLayerDecodedFlag = x; }
275	Int getNoOutputOfPriorPicsFlags() { return m_noOutputOfPriorPicsFlags;}
276	Void setNoOutputOfPriorPicsFlags(Bool x) { m_noOutputOfPriorPicsFlags = x; }
277	#endif
278	#if Q0078_ADD_LAYER_SETS
279	Void setNumAddLayerSets(Int x) { m_numAddLayerSets = x; }
280	Int getNumAddLayerSets() { return m_numAddLayerSets; }
281	#endif
282	#if P0297_VPS_POC_LSB_ALIGNED_FLAG
283	Void setPocDecrementedInDPBFlag(Bool x) { m_pocDecrementedInDPBFlag = x; }
284	Bool getPocDecrementedInDPBFlag() { return m_pocDecrementedInDPBFlag; }
285	Void setCurrPocMsb(Int poc) { m_currPocMsb = poc; }
286	Int getCurrPocMsb() { return m_currPocMsb; }
287	#endif
288	#else //SVC_EXTENSION
289	Void encode( Bool bEos,
290	TComPicYuv* pcPicYuvOrg,
291	TComPicYuv* pcPicYuvTrueOrg, const InputColourSpaceConversion snrCSC, // used for SNR calculations. Picture in original colour space.
292	TComList<TComPicYuv*>& rcListPicYuvRecOut,
293	std::list<AccessUnit>& accessUnitsOut, Int& iNumEncoded );
294
295	/// encode several number of pictures until end-of-sequence
296	Void encode( Bool bEos, TComPicYuv* pcPicYuvOrg,
297	TComPicYuv* pcPicYuvTrueOrg, const InputColourSpaceConversion snrCSC, // used for SNR calculations. Picture in original colour space.
298	TComList<TComPicYuv*>& rcListPicYuvRecOut,
299	std::list<AccessUnit>& accessUnitsOut, Int& iNumEncoded, Bool isTff);
300
301	Void printSummary(Bool isField) { m_cGOPEncoder.printOutSummary (m_uiNumAllPicCoded, isField, m_printMSEBasedSequencePSNR, m_printSequenceMSE); }
302	#endif //#if SVC_EXTENSION
303	};
304
305	//! \}
306
307	#endif // __TENCTOP__
308

Note: See TracBrowser for help on using the repository browser.

Download in other formats: