Context navigation

TEncCavlc.cpp @ 1204

Visit:

Last change on this file since 1204 was 1200, checked in by tech, 10 years ago

Update to HM-16.5.
Starting point for further re-activation of 3D-tools.

Includes:

active:

MV-HEVC
3D-HLS (apart from DLT)
VSO

inactive:

remaining 3D-HEVC tools.

Property svn:eol-style set to native

File size: 112.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-2015, 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 TEncCavlc.cpp
35	\brief CAVLC encoder class
36	*/
37
38	#include "../TLibCommon/CommonDef.h"
39	#include "TEncCavlc.h"
40	#include "SEIwrite.h"
41
42	#if NH_3D
43	#include "TEncTop.h"
44	#endif
45
46	//! \ingroup TLibEncoder
47	//! \{
48
49	#if ENC_DEC_TRACE
50
51	#if !H_MV_ENC_DEC_TRAC
52	Void xTraceVPSHeader ()
53	{
54	fprintf( g_hTrace, "=========== Video Parameter Set ===========\n" );
55
56	Void xTraceSPSHeader ()
57	{
58	fprintf( g_hTrace, "=========== Sequence Parameter Set ===========\n" );
59	}
60
61	Void xTracePPSHeader ()
62	{
63	fprintf( g_hTrace, "=========== Picture Parameter Set ===========\n");
64	}
65
66	Void xTraceSliceHeader ( )
67	{
68	fprintf( g_hTrace, "=========== Slice ===========\n");
69	}
70	#endif
71	#endif
72	// ====================================================================================================================
73	// Constructor / destructor / create / destroy
74	// ====================================================================================================================
75
76	TEncCavlc::TEncCavlc()
77	{
78	m_pcBitIf = NULL;
79	}
80
81	TEncCavlc::~TEncCavlc()
82	{
83	}
84
85
86	// ====================================================================================================================
87	// Public member functions
88	// ====================================================================================================================
89
90	Void TEncCavlc::resetEntropy(const TComSlice* /pSlice/)
91	{
92	}
93
94
95	Void TEncCavlc::codeShortTermRefPicSet( const TComReferencePictureSet* rps, Bool calledFromSliceHeader, Int idx)
96	{
97	#if PRINT_RPS_INFO
98	Int lastBits = getNumberOfWrittenBits();
99	#endif
100	if (idx > 0)
101	{
102	WRITE_FLAG( rps->getInterRPSPrediction(), "inter_ref_pic_set_prediction_flag" ); // inter_RPS_prediction_flag
103	}
104	if (rps->getInterRPSPrediction())
105	{
106	Int deltaRPS = rps->getDeltaRPS();
107	if(calledFromSliceHeader)
108	{
109	WRITE_UVLC( rps->getDeltaRIdxMinus1(), "delta_idx_minus1" ); // delta index of the Reference Picture Set used for prediction minus 1
110	}
111
112	WRITE_CODE( (deltaRPS >=0 ? 0: 1), 1, "delta_rps_sign" ); //delta_rps_sign
113	WRITE_UVLC( abs(deltaRPS) - 1, "abs_delta_rps_minus1"); // absolute delta RPS minus 1
114
115	for(Int j=0; j < rps->getNumRefIdc(); j++)
116	{
117	Int refIdc = rps->getRefIdc(j);
118	WRITE_CODE( (refIdc==1? 1: 0), 1, "used_by_curr_pic_flag" ); //first bit is "1" if Idc is 1
119	if (refIdc != 1)
120	{
121	WRITE_CODE( refIdc>>1, 1, "use_delta_flag" ); //second bit is "1" if Idc is 2, "0" otherwise.
122	}
123	}
124	}
125	else
126	{
127	WRITE_UVLC( rps->getNumberOfNegativePictures(), "num_negative_pics" );
128	WRITE_UVLC( rps->getNumberOfPositivePictures(), "num_positive_pics" );
129	Int prev = 0;
130	for(Int j=0 ; j < rps->getNumberOfNegativePictures(); j++)
131	{
132	WRITE_UVLC( prev-rps->getDeltaPOC(j)-1, "delta_poc_s0_minus1" );
133	prev = rps->getDeltaPOC(j);
134	WRITE_FLAG( rps->getUsed(j), "used_by_curr_pic_s0_flag");
135	}
136	prev = 0;
137	for(Int j=rps->getNumberOfNegativePictures(); j < rps->getNumberOfNegativePictures()+rps->getNumberOfPositivePictures(); j++)
138	{
139	WRITE_UVLC( rps->getDeltaPOC(j)-prev-1, "delta_poc_s1_minus1" );
140	prev = rps->getDeltaPOC(j);
141	WRITE_FLAG( rps->getUsed(j), "used_by_curr_pic_s1_flag" );
142	}
143	}
144
145	#if PRINT_RPS_INFO
146	printf("irps=%d (%2d bits) ", rps->getInterRPSPrediction(), getNumberOfWrittenBits() - lastBits);
147	rps->printDeltaPOC();
148	#endif
149	}
150
151
152	Void TEncCavlc::codePPS( const TComPPS* pcPPS )
153	{
154	#if ENC_DEC_TRACE
155	#if H_MV_ENC_DEC_TRAC
156	tracePSHeader( "PPS", pcPPS->getLayerId() );
157	#else
158	xTracePPSHeader ();
159	#endif
160	#endif
161	WRITE_UVLC( pcPPS->getPPSId(), "pps_pic_parameter_set_id" );
162	WRITE_UVLC( pcPPS->getSPSId(), "pps_seq_parameter_set_id" );
163	WRITE_FLAG( pcPPS->getDependentSliceSegmentsEnabledFlag() ? 1 : 0, "dependent_slice_segments_enabled_flag" );
164	WRITE_FLAG( pcPPS->getOutputFlagPresentFlag() ? 1 : 0, "output_flag_present_flag" );
165	WRITE_CODE( pcPPS->getNumExtraSliceHeaderBits(), 3, "num_extra_slice_header_bits");
166	WRITE_FLAG( pcPPS->getSignHideFlag(), "sign_data_hiding_flag" );
167	WRITE_FLAG( pcPPS->getCabacInitPresentFlag() ? 1 : 0, "cabac_init_present_flag" );
168	#if PPS_FIX_DEPTH
169	if( pcPPS->getSPS()->getVPS()->getDepthId(pcPPS->getSPS()->getLayerId()) )
170	{
171	WRITE_UVLC( pcPPS->getNumRefIdxL0DefaultActive(), "num_ref_idx_l0_default_active_minus1");
172	WRITE_UVLC( pcPPS->getNumRefIdxL1DefaultActive(), "num_ref_idx_l1_default_active_minus1");
173	}
174	else
175	{
176	#endif
177	WRITE_UVLC( pcPPS->getNumRefIdxL0DefaultActive()-1, "num_ref_idx_l0_default_active_minus1");
178	WRITE_UVLC( pcPPS->getNumRefIdxL1DefaultActive()-1, "num_ref_idx_l1_default_active_minus1");
179	#if PPS_FIX_DEPTH
180	}
181	#endif
182	WRITE_SVLC( pcPPS->getPicInitQPMinus26(), "init_qp_minus26");
183	WRITE_FLAG( pcPPS->getConstrainedIntraPred() ? 1 : 0, "constrained_intra_pred_flag" );
184	WRITE_FLAG( pcPPS->getUseTransformSkip() ? 1 : 0, "transform_skip_enabled_flag" );
185	WRITE_FLAG( pcPPS->getUseDQP() ? 1 : 0, "cu_qp_delta_enabled_flag" );
186	if ( pcPPS->getUseDQP() )
187	{
188	WRITE_UVLC( pcPPS->getMaxCuDQPDepth(), "diff_cu_qp_delta_depth" );
189	}
190
191	WRITE_SVLC( pcPPS->getQpOffset(COMPONENT_Cb), "pps_cb_qp_offset" );
192	WRITE_SVLC( pcPPS->getQpOffset(COMPONENT_Cr), "pps_cr_qp_offset" );
193
194	WRITE_FLAG( pcPPS->getSliceChromaQpFlag() ? 1 : 0, "pps_slice_chroma_qp_offsets_present_flag" );
195
196	WRITE_FLAG( pcPPS->getUseWP() ? 1 : 0, "weighted_pred_flag" ); // Use of Weighting Prediction (P_SLICE)
197	WRITE_FLAG( pcPPS->getWPBiPred() ? 1 : 0, "weighted_bipred_flag" ); // Use of Weighting Bi-Prediction (B_SLICE)
198	WRITE_FLAG( pcPPS->getTransquantBypassEnableFlag() ? 1 : 0, "transquant_bypass_enable_flag" );
199	WRITE_FLAG( pcPPS->getTilesEnabledFlag() ? 1 : 0, "tiles_enabled_flag" );
200	WRITE_FLAG( pcPPS->getEntropyCodingSyncEnabledFlag() ? 1 : 0, "entropy_coding_sync_enabled_flag" );
201	if( pcPPS->getTilesEnabledFlag() )
202	{
203	WRITE_UVLC( pcPPS->getNumTileColumnsMinus1(), "num_tile_columns_minus1" );
204	WRITE_UVLC( pcPPS->getNumTileRowsMinus1(), "num_tile_rows_minus1" );
205	WRITE_FLAG( pcPPS->getTileUniformSpacingFlag(), "uniform_spacing_flag" );
206	if( !pcPPS->getTileUniformSpacingFlag() )
207	{
208	for(UInt i=0; i<pcPPS->getNumTileColumnsMinus1(); i++)
209	{
210	WRITE_UVLC( pcPPS->getTileColumnWidth(i)-1, "column_width_minus1" );
211	}
212	for(UInt i=0; i<pcPPS->getNumTileRowsMinus1(); i++)
213	{
214	WRITE_UVLC( pcPPS->getTileRowHeight(i)-1, "row_height_minus1" );
215	}
216	}
217	if(pcPPS->getNumTileColumnsMinus1() !=0 \|\| pcPPS->getNumTileRowsMinus1() !=0)
218	{
219	WRITE_FLAG( pcPPS->getLoopFilterAcrossTilesEnabledFlag()?1 : 0, "loop_filter_across_tiles_enabled_flag");
220	}
221	}
222	WRITE_FLAG( pcPPS->getLoopFilterAcrossSlicesEnabledFlag()?1 : 0, "pps_loop_filter_across_slices_enabled_flag");
223	WRITE_FLAG( pcPPS->getDeblockingFilterControlPresentFlag()?1 : 0, "deblocking_filter_control_present_flag");
224	if(pcPPS->getDeblockingFilterControlPresentFlag())
225	{
226	WRITE_FLAG( pcPPS->getDeblockingFilterOverrideEnabledFlag() ? 1 : 0, "deblocking_filter_override_enabled_flag" );
227	WRITE_FLAG( pcPPS->getPicDisableDeblockingFilterFlag() ? 1 : 0, "pps_disable_deblocking_filter_flag" );
228	if(!pcPPS->getPicDisableDeblockingFilterFlag())
229	{
230	WRITE_SVLC( pcPPS->getDeblockingFilterBetaOffsetDiv2(), "pps_beta_offset_div2" );
231	WRITE_SVLC( pcPPS->getDeblockingFilterTcOffsetDiv2(), "pps_tc_offset_div2" );
232	}
233	}
234	WRITE_FLAG( pcPPS->getScalingListPresentFlag() ? 1 : 0, "pps_scaling_list_data_present_flag" );
235	if( pcPPS->getScalingListPresentFlag() )
236	{
237	codeScalingList( pcPPS->getScalingList() );
238	}
239	#if PPS_FIX_DEPTH
240	if( pcPPS->getSPS()->getVPS()->getDepthId(pcPPS->getSPS()->getLayerId()) )
241	{
242	WRITE_FLAG( 1, "lists_modification_present_flag" );
243	}
244	else
245	#endif
246	WRITE_FLAG( pcPPS->getListsModificationPresentFlag(), "lists_modification_present_flag");
247	WRITE_UVLC( pcPPS->getLog2ParallelMergeLevelMinus2(), "log2_parallel_merge_level_minus2");
248	WRITE_FLAG( pcPPS->getSliceHeaderExtensionPresentFlag() ? 1 : 0, "slice_segment_header_extension_present_flag");
249	#if !NH_MV
250	Bool pps_extension_present_flag=false;
251	Bool pps_extension_flags[NUM_PPS_EXTENSION_FLAGS]={false};
252
253	pps_extension_flags[PPS_EXT__REXT] = pcPPS->getPpsRangeExtension().settingsDifferFromDefaults(pcPPS->getUseTransformSkip());
254
255	// Other PPS extension flags checked here.
256
257	for(Int i=0; i<NUM_PPS_EXTENSION_FLAGS; i++)
258	{
259	pps_extension_present_flag\|=pps_extension_flags[i];
260	}
261
262	WRITE_FLAG( (pps_extension_present_flag?1:0), "pps_extension_present_flag" );
263
264	if (pps_extension_present_flag)
265	{
266	#if ENC_DEC_TRACE \|\| RExt__DECODER_DEBUG_BIT_STATISTICS
267	static const char *syntaxStrings[]={ "pps_range_extension_flag",
268	"pps_multilayer_extension_flag",
269	"pps_extension_6bits[0]",
270	"pps_extension_6bits[1]",
271	"pps_extension_6bits[2]",
272	"pps_extension_6bits[3]",
273	"pps_extension_6bits[4]",
274	"pps_extension_6bits[5]" };
275	#endif
276
277	for(Int i=0; i<NUM_PPS_EXTENSION_FLAGS; i++)
278	{
279	WRITE_FLAG( pps_extension_flags[i]?1:0, syntaxStrings[i] );
280	}
281
282	for(Int i=0; i<NUM_PPS_EXTENSION_FLAGS; i++) // loop used so that the order is determined by the enum.
283	{
284	if (pps_extension_flags[i])
285	{
286	switch (PPSExtensionFlagIndex(i))
287	{
288	case PPS_EXT__REXT:
289	{
290	const TComPPSRExt &ppsRangeExtension = pcPPS->getPpsRangeExtension();
291	if (pcPPS->getUseTransformSkip())
292	{
293	WRITE_UVLC( ppsRangeExtension.getLog2MaxTransformSkipBlockSize()-2, "log2_max_transform_skip_block_size_minus2");
294	}
295
296	WRITE_FLAG((ppsRangeExtension.getCrossComponentPredictionEnabledFlag() ? 1 : 0), "cross_component_prediction_enabled_flag" );
297
298	WRITE_FLAG(UInt(ppsRangeExtension.getChromaQpOffsetListEnabledFlag()), "chroma_qp_offset_list_enabled_flag" );
299	if (ppsRangeExtension.getChromaQpOffsetListEnabledFlag())
300	{
301	WRITE_UVLC(ppsRangeExtension.getDiffCuChromaQpOffsetDepth(), "diff_cu_chroma_qp_offset_depth");
302	WRITE_UVLC(ppsRangeExtension.getChromaQpOffsetListLen() - 1, "chroma_qp_offset_list_len_minus1");
303	/* skip zero index */
304	for (Int cuChromaQpOffsetIdx = 0; cuChromaQpOffsetIdx < ppsRangeExtension.getChromaQpOffsetListLen(); cuChromaQpOffsetIdx++)
305	{
306	WRITE_SVLC(ppsRangeExtension.getChromaQpOffsetListEntry(cuChromaQpOffsetIdx+1).u.comp.CbOffset, "cb_qp_offset_list[i]");
307	WRITE_SVLC(ppsRangeExtension.getChromaQpOffsetListEntry(cuChromaQpOffsetIdx+1).u.comp.CrOffset, "cr_qp_offset_list[i]");
308	}
309	}
310
311	WRITE_UVLC( ppsRangeExtension.getLog2SaoOffsetScale(CHANNEL_TYPE_LUMA), "log2_sao_offset_scale_luma" );
312	WRITE_UVLC( ppsRangeExtension.getLog2SaoOffsetScale(CHANNEL_TYPE_CHROMA), "log2_sao_offset_scale_chroma" );
313	}
314	break;
315	default:
316	assert(pps_extension_flags[i]==false); // Should never get here with an active PPS extension flag.
317	break;
318	} // switch
319	} // if flag present
320	} // loop over PPS flags
321	} // pps_extension_present_flag is non-zero
322	#else
323	WRITE_FLAG( 1, "pps_extension_present_flag" );
324
325	WRITE_FLAG( pcPPS->getPpsRangeExtensionsFlag( ) ? 1 : 0 , "pps_range_extensions_flag" );
326	WRITE_FLAG( pcPPS->getPpsMultilayerExtensionFlag( ) ? 1 : 0 , "pps_multilayer_extension_flag" );
327	WRITE_FLAG( pcPPS->getPps3dExtensionFlag( ) ? 1 : 0 , "pps_3d_extension_flag" );
328	WRITE_CODE( pcPPS->getPpsExtension5bits( ), 5, "pps_extension_5bits" );
329	if ( pcPPS->getPpsRangeExtensionsFlag() )
330	{
331	const TComPPSRExt &ppsRangeExtension = pcPPS->getPpsRangeExtension();
332	if (pcPPS->getUseTransformSkip())
333	{
334	WRITE_UVLC( ppsRangeExtension.getLog2MaxTransformSkipBlockSize()-2, "log2_max_transform_skip_block_size_minus2");
335	}
336
337	WRITE_FLAG((ppsRangeExtension.getCrossComponentPredictionEnabledFlag() ? 1 : 0), "cross_component_prediction_enabled_flag" );
338
339	WRITE_FLAG(UInt(ppsRangeExtension.getChromaQpOffsetListEnabledFlag()), "chroma_qp_offset_list_enabled_flag" );
340	if (ppsRangeExtension.getChromaQpOffsetListEnabledFlag())
341	{
342	WRITE_UVLC(ppsRangeExtension.getDiffCuChromaQpOffsetDepth(), "diff_cu_chroma_qp_offset_depth");
343	WRITE_UVLC(ppsRangeExtension.getChromaQpOffsetListLen() - 1, "chroma_qp_offset_list_len_minus1");
344	/* skip zero index */
345	for (Int cuChromaQpOffsetIdx = 0; cuChromaQpOffsetIdx < ppsRangeExtension.getChromaQpOffsetListLen(); cuChromaQpOffsetIdx++)
346	{
347	WRITE_SVLC(ppsRangeExtension.getChromaQpOffsetListEntry(cuChromaQpOffsetIdx+1).u.comp.CbOffset, "cb_qp_offset_list[i]");
348	WRITE_SVLC(ppsRangeExtension.getChromaQpOffsetListEntry(cuChromaQpOffsetIdx+1).u.comp.CrOffset, "cr_qp_offset_list[i]");
349	}
350	}
351
352	WRITE_UVLC( ppsRangeExtension.getLog2SaoOffsetScale(CHANNEL_TYPE_LUMA), "log2_sao_offset_scale_luma" );
353	WRITE_UVLC( ppsRangeExtension.getLog2SaoOffsetScale(CHANNEL_TYPE_CHROMA), "log2_sao_offset_scale_chroma" );
354	}
355
356	if ( pcPPS->getPpsMultilayerExtensionFlag() )
357	{
358	codePpsMultilayerExtension( pcPPS );
359	}
360
361	#if NH_3D
362	if( pcPPS->getPps3dExtensionFlag( ) ) // This probably needs to be aligned with Rext and SHVC
363	{
364	codePps3dExtension( pcPPS );
365	}
366	#endif
367	#endif
368	xWriteRbspTrailingBits();
369	}
370
371	#if NH_3D
372	Void TEncCavlc::codePps3dExtension ( const TComPPS* pcPPS )
373	{
374	// Assuming that all PPS indirectly refer to the same VPS via different SPS
375	// There is no parsing dependency in decoding DLT in PPS.
376	// The VPS information passed to decodePPS() is used to arrange the decoded DLT tables to their corresponding layers.
377	// This is equivalent to the process of
378	// Step 1) decoding DLT tables based on the number of depth layers, and
379	// Step 2) mapping DLT tables to the depth layers
380	// as described in the 3D-HEVC WD.
381
382	// GT: Please remove dependency from VPS in the encoding as well as in the parsing function, e.g. using the equivalent process.
383	// GT: Moreover this function should only carry out the coding of the DLT and NO rate based decisions.
384	// GT: Please add a function e.g. xSetDLT in e.g. TEncSlice to find the best DLT syntax representation and do ONLY the coding of the DLT here !!
385
386	#if H_3D
387	WRITE_FLAG( pcDLT->getDltPresentFlag() ? 1 : 0, "dlt_present_flag" );
388
389	if ( pcDLT->getDltPresentFlag() )
390	{
391	WRITE_CODE(pcDLT->getNumDepthViews(), 6, "pps_depth_layers_minus1");
392	WRITE_CODE((pcDLT->getDepthViewBitDepth() - 8), 4, "pps_bit_depth_for_depth_views_minus8");
393
394	for( Int i = 0; i <= pcVPS->getMaxLayersMinus1(); i++ )
395	{
396	if ( i != 0 )
397	{
398	if ( pcVPS->getDepthId( i ) == 1 )
399	{
400	WRITE_FLAG( pcDLT->getUseDLTFlag( i ) ? 1 : 0, "dlt_flag[i]" );
401
402	if ( pcDLT->getUseDLTFlag( i ) )
403	{
404	WRITE_FLAG( pcDLT->getInterViewDltPredEnableFlag( i ) ? 1 : 0, "inter_view_dlt_pred_enable_flag[ i ]");
405
406	// ----------------------------- determine whether to use bit-map -----------------------------
407	Bool bDltBitMapRepFlag = false;
408	UInt uiNumBitsNonBitMap = 0;
409	UInt uiNumBitsBitMap = 0;
410
411	UInt uiMaxDiff = 0;
412	UInt uiMinDiff = 0xffffffff;
413	UInt uiLengthMinDiff = 0;
414	UInt uiLengthDltDiffMinusMin = 0;
415
416	UInt* puiDltDiffValues = NULL;
417
418	Int aiIdx2DepthValue_coded[256];
419	UInt uiNumDepthValues_coded = 0;
420
421	uiNumDepthValues_coded = pcDLT->getNumDepthValues(i);
422	for( UInt ui = 0; ui<uiNumDepthValues_coded; ui++ )
423	{
424	aiIdx2DepthValue_coded[ui] = pcDLT->idx2DepthValue(i, ui);
425	}
426
427	if( pcDLT->getInterViewDltPredEnableFlag( i ) )
428	{
429	AOF( pcVPS->getDepthId( 1 ) == 1 );
430	AOF( i > 1 );
431	// assumes ref layer id to be 1
432	Int* piRefDLT = pcDLT->idx2DepthValue( 1 );
433	UInt uiRefNum = pcDLT->getNumDepthValues( 1 );
434	pcDLT->getDeltaDLT(i, piRefDLT, uiRefNum, aiIdx2DepthValue_coded, &uiNumDepthValues_coded);
435	}
436
437	if ( NULL == (puiDltDiffValues = (UInt *)calloc(uiNumDepthValues_coded, sizeof(UInt))) )
438	{
439	// This should be changed to an assertion.
440	exit(-1);
441	}
442
443	for (UInt d = 1; d < uiNumDepthValues_coded; d++)
444	{
445	puiDltDiffValues[d] = aiIdx2DepthValue_coded[d] - aiIdx2DepthValue_coded[d-1];
446
447	if ( uiMaxDiff < puiDltDiffValues[d] )
448	{
449	uiMaxDiff = puiDltDiffValues[d];
450	}
451
452	if ( uiMinDiff > puiDltDiffValues[d] )
453	{
454	uiMinDiff = puiDltDiffValues[d];
455	}
456	}
457
458	// counting bits
459	// diff coding branch
460	uiNumBitsNonBitMap += 8; // u(v) bits for num_depth_values_in_dlt[layerId] (i.e. num_entry[ layerId ])
461
462	if ( uiNumDepthValues_coded > 1 )
463	{
464	uiNumBitsNonBitMap += 8; // u(v) bits for max_diff[ layerId ]
465	}
466
467	if ( uiNumDepthValues_coded > 2 )
468	{
469	uiLengthMinDiff = (UInt) ceil(Log2(uiMaxDiff + 1));
470	uiNumBitsNonBitMap += uiLengthMinDiff; // u(v) bits for min_diff[ layerId ]
471	}
472
473	uiNumBitsNonBitMap += 8; // u(v) bits for dlt_depth_value0[ layerId ]
474
475	if (uiMaxDiff > uiMinDiff)
476	{
477	uiLengthDltDiffMinusMin = (UInt) ceil(Log2(uiMaxDiff - uiMinDiff + 1));
478	uiNumBitsNonBitMap += uiLengthDltDiffMinusMin * (uiNumDepthValues_coded - 1); // u(v) bits for dlt_depth_value_diff_minus_min[ layerId ][ j ]
479	}
480
481	// bit map branch
482	uiNumBitsBitMap = 256; // uiNumBitsBitMap = 1 << pcDLT->getDepthViewBitDepth();
483
484	// determine bDltBitMapFlag
485	bDltBitMapRepFlag = (uiNumBitsBitMap > uiNumBitsNonBitMap) ? false : true;
486
487	// ----------------------------- Actual coding -----------------------------
488	if ( pcDLT->getInterViewDltPredEnableFlag( i ) == false )
489	{
490	WRITE_FLAG( bDltBitMapRepFlag ? 1 : 0, "dlt_bit_map_rep_flag[ layerId ]" );
491	}
492	else
493	{
494	bDltBitMapRepFlag = false;
495	}
496
497	// bit map coding
498	if ( bDltBitMapRepFlag )
499	{
500	UInt uiDltArrayIndex = 0;
501	for (UInt d=0; d < 256; d++)
502	{
503	if ( d == aiIdx2DepthValue_coded[uiDltArrayIndex] )
504	{
505	WRITE_FLAG(1, "dlt_bit_map_flag[ layerId ][ j ]");
506	uiDltArrayIndex++;
507	}
508	else
509	{
510	WRITE_FLAG(0, "dlt_bit_map_flag[ layerId ][ j ]");
511	}
512	}
513	}
514	// Diff Coding
515	else
516	{
517	WRITE_CODE(uiNumDepthValues_coded, 8, "num_depth_values_in_dlt[i]"); // num_entry
518	{
519	// The condition if( uiNumDepthValues_coded > 0 ) is always true since for Single-view Diff Coding, there is at least one depth value in depth component.
520	if ( uiNumDepthValues_coded > 1 )
521	{
522	WRITE_CODE(uiMaxDiff, 8, "max_diff[ layerId ]"); // max_diff
523	}
524
525	if ( uiNumDepthValues_coded > 2 )
526	{
527	WRITE_CODE((uiMinDiff - 1), uiLengthMinDiff, "min_diff_minus1[ layerId ]"); // min_diff_minus1
528	}
529
530	WRITE_CODE(aiIdx2DepthValue_coded[0], 8, "dlt_depth_value0[layerId]"); // entry0
531
532	if (uiMaxDiff > uiMinDiff)
533	{
534	for (UInt d=1; d < uiNumDepthValues_coded; d++)
535	{
536	WRITE_CODE( (puiDltDiffValues[d] - uiMinDiff), uiLengthDltDiffMinusMin, "dlt_depth_value_diff_minus_min[ layerId ][ j ]"); // entry_value_diff_minus_min[ k ]
537	}
538	}
539	}
540	}
541
542	free(puiDltDiffValues);
543	}
544	}
545	}
546	}
547	}
548	#endif
549	}
550	#endif
551
552	Void TEncCavlc::codeVUI( const TComVUI pcVUI, const TComSPS pcSPS )
553	{
554	#if ENC_DEC_TRACE
555	fprintf( g_hTrace, "----------- vui_parameters -----------\n");
556	#endif
557	WRITE_FLAG(pcVUI->getAspectRatioInfoPresentFlag(), "aspect_ratio_info_present_flag");
558	if (pcVUI->getAspectRatioInfoPresentFlag())
559	{
560	WRITE_CODE(pcVUI->getAspectRatioIdc(), 8, "aspect_ratio_idc" );
561	if (pcVUI->getAspectRatioIdc() == 255)
562	{
563	WRITE_CODE(pcVUI->getSarWidth(), 16, "sar_width");
564	WRITE_CODE(pcVUI->getSarHeight(), 16, "sar_height");
565	}
566	}
567	WRITE_FLAG(pcVUI->getOverscanInfoPresentFlag(), "overscan_info_present_flag");
568	if (pcVUI->getOverscanInfoPresentFlag())
569	{
570	WRITE_FLAG(pcVUI->getOverscanAppropriateFlag(), "overscan_appropriate_flag");
571	}
572	WRITE_FLAG(pcVUI->getVideoSignalTypePresentFlag(), "video_signal_type_present_flag");
573	#if NH_MV
574	assert( pcSPS->getLayerId() == 0 \|\| !pcVUI->getVideoSignalTypePresentFlag() );
575	#endif
576	if (pcVUI->getVideoSignalTypePresentFlag())
577	{
578	WRITE_CODE(pcVUI->getVideoFormat(), 3, "video_format");
579	WRITE_FLAG(pcVUI->getVideoFullRangeFlag(), "video_full_range_flag");
580	WRITE_FLAG(pcVUI->getColourDescriptionPresentFlag(), "colour_description_present_flag");
581	if (pcVUI->getColourDescriptionPresentFlag())
582	{
583	WRITE_CODE(pcVUI->getColourPrimaries(), 8, "colour_primaries");
584	WRITE_CODE(pcVUI->getTransferCharacteristics(), 8, "transfer_characteristics");
585	WRITE_CODE(pcVUI->getMatrixCoefficients(), 8, "matrix_coeffs");
586	}
587	}
588
589	WRITE_FLAG(pcVUI->getChromaLocInfoPresentFlag(), "chroma_loc_info_present_flag");
590	if (pcVUI->getChromaLocInfoPresentFlag())
591	{
592	WRITE_UVLC(pcVUI->getChromaSampleLocTypeTopField(), "chroma_sample_loc_type_top_field");
593	WRITE_UVLC(pcVUI->getChromaSampleLocTypeBottomField(), "chroma_sample_loc_type_bottom_field");
594	}
595
596	WRITE_FLAG(pcVUI->getNeutralChromaIndicationFlag(), "neutral_chroma_indication_flag");
597	WRITE_FLAG(pcVUI->getFieldSeqFlag(), "field_seq_flag");
598	WRITE_FLAG(pcVUI->getFrameFieldInfoPresentFlag(), "frame_field_info_present_flag");
599
600	Window defaultDisplayWindow = pcVUI->getDefaultDisplayWindow();
601	WRITE_FLAG(defaultDisplayWindow.getWindowEnabledFlag(), "default_display_window_flag");
602	if( defaultDisplayWindow.getWindowEnabledFlag() )
603	{
604	WRITE_UVLC(defaultDisplayWindow.getWindowLeftOffset() / TComSPS::getWinUnitX(pcSPS->getChromaFormatIdc()), "def_disp_win_left_offset");
605	WRITE_UVLC(defaultDisplayWindow.getWindowRightOffset() / TComSPS::getWinUnitX(pcSPS->getChromaFormatIdc()), "def_disp_win_right_offset");
606	WRITE_UVLC(defaultDisplayWindow.getWindowTopOffset() / TComSPS::getWinUnitY(pcSPS->getChromaFormatIdc()), "def_disp_win_top_offset");
607	WRITE_UVLC(defaultDisplayWindow.getWindowBottomOffset()/ TComSPS::getWinUnitY(pcSPS->getChromaFormatIdc()), "def_disp_win_bottom_offset");
608	}
609	const TimingInfo *timingInfo = pcVUI->getTimingInfo();
610	WRITE_FLAG(timingInfo->getTimingInfoPresentFlag(), "vui_timing_info_present_flag");
611	if(timingInfo->getTimingInfoPresentFlag())
612	{
613	WRITE_CODE(timingInfo->getNumUnitsInTick(), 32, "vui_num_units_in_tick");
614	WRITE_CODE(timingInfo->getTimeScale(), 32, "vui_time_scale");
615	WRITE_FLAG(timingInfo->getPocProportionalToTimingFlag(), "vui_poc_proportional_to_timing_flag");
616	if(timingInfo->getPocProportionalToTimingFlag())
617	{
618	WRITE_UVLC(timingInfo->getNumTicksPocDiffOneMinus1(), "vui_num_ticks_poc_diff_one_minus1");
619	}
620	WRITE_FLAG(pcVUI->getHrdParametersPresentFlag(), "vui_hrd_parameters_present_flag");
621	if( pcVUI->getHrdParametersPresentFlag() )
622	{
623	codeHrdParameters(pcVUI->getHrdParameters(), 1, pcSPS->getMaxTLayers() - 1 );
624	}
625	}
626
627	WRITE_FLAG(pcVUI->getBitstreamRestrictionFlag(), "bitstream_restriction_flag");
628	if (pcVUI->getBitstreamRestrictionFlag())
629	{
630	WRITE_FLAG(pcVUI->getTilesFixedStructureFlag(), "tiles_fixed_structure_flag");
631	WRITE_FLAG(pcVUI->getMotionVectorsOverPicBoundariesFlag(), "motion_vectors_over_pic_boundaries_flag");
632	WRITE_FLAG(pcVUI->getRestrictedRefPicListsFlag(), "restricted_ref_pic_lists_flag");
633	WRITE_UVLC(pcVUI->getMinSpatialSegmentationIdc(), "min_spatial_segmentation_idc");
634	WRITE_UVLC(pcVUI->getMaxBytesPerPicDenom(), "max_bytes_per_pic_denom");
635	WRITE_UVLC(pcVUI->getMaxBitsPerMinCuDenom(), "max_bits_per_min_cu_denom");
636	WRITE_UVLC(pcVUI->getLog2MaxMvLengthHorizontal(), "log2_max_mv_length_horizontal");
637	WRITE_UVLC(pcVUI->getLog2MaxMvLengthVertical(), "log2_max_mv_length_vertical");
638	}
639	}
640
641	Void TEncCavlc::codeHrdParameters( const TComHRD *hrd, Bool commonInfPresentFlag, UInt maxNumSubLayersMinus1 )
642	{
643	if( commonInfPresentFlag )
644	{
645	WRITE_FLAG( hrd->getNalHrdParametersPresentFlag() ? 1 : 0 , "nal_hrd_parameters_present_flag" );
646	WRITE_FLAG( hrd->getVclHrdParametersPresentFlag() ? 1 : 0 , "vcl_hrd_parameters_present_flag" );
647	if( hrd->getNalHrdParametersPresentFlag() \|\| hrd->getVclHrdParametersPresentFlag() )
648	{
649	WRITE_FLAG( hrd->getSubPicCpbParamsPresentFlag() ? 1 : 0, "sub_pic_hrd_params_present_flag" );
650	if( hrd->getSubPicCpbParamsPresentFlag() )
651	{
652	WRITE_CODE( hrd->getTickDivisorMinus2(), 8, "tick_divisor_minus2" );
653	WRITE_CODE( hrd->getDuCpbRemovalDelayLengthMinus1(), 5, "du_cpb_removal_delay_increment_length_minus1" );
654	WRITE_FLAG( hrd->getSubPicCpbParamsInPicTimingSEIFlag() ? 1 : 0, "sub_pic_cpb_params_in_pic_timing_sei_flag" );
655	WRITE_CODE( hrd->getDpbOutputDelayDuLengthMinus1(), 5, "dpb_output_delay_du_length_minus1" );
656	}
657	WRITE_CODE( hrd->getBitRateScale(), 4, "bit_rate_scale" );
658	WRITE_CODE( hrd->getCpbSizeScale(), 4, "cpb_size_scale" );
659	if( hrd->getSubPicCpbParamsPresentFlag() )
660	{
661	WRITE_CODE( hrd->getDuCpbSizeScale(), 4, "du_cpb_size_scale" );
662	}
663	WRITE_CODE( hrd->getInitialCpbRemovalDelayLengthMinus1(), 5, "initial_cpb_removal_delay_length_minus1" );
664	WRITE_CODE( hrd->getCpbRemovalDelayLengthMinus1(), 5, "au_cpb_removal_delay_length_minus1" );
665	WRITE_CODE( hrd->getDpbOutputDelayLengthMinus1(), 5, "dpb_output_delay_length_minus1" );
666	}
667	}
668	Int i, j, nalOrVcl;
669	for( i = 0; i <= maxNumSubLayersMinus1; i ++ )
670	{
671	WRITE_FLAG( hrd->getFixedPicRateFlag( i ) ? 1 : 0, "fixed_pic_rate_general_flag");
672	Bool fixedPixRateWithinCvsFlag = true;
673	if( !hrd->getFixedPicRateFlag( i ) )
674	{
675	fixedPixRateWithinCvsFlag = hrd->getFixedPicRateWithinCvsFlag( i );
676	WRITE_FLAG( hrd->getFixedPicRateWithinCvsFlag( i ) ? 1 : 0, "fixed_pic_rate_within_cvs_flag");
677	}
678	if( fixedPixRateWithinCvsFlag )
679	{
680	WRITE_UVLC( hrd->getPicDurationInTcMinus1( i ), "elemental_duration_in_tc_minus1");
681	}
682	else
683	{
684	WRITE_FLAG( hrd->getLowDelayHrdFlag( i ) ? 1 : 0, "low_delay_hrd_flag");
685	}
686	if (!hrd->getLowDelayHrdFlag( i ))
687	{
688	WRITE_UVLC( hrd->getCpbCntMinus1( i ), "cpb_cnt_minus1");
689	}
690
691	for( nalOrVcl = 0; nalOrVcl < 2; nalOrVcl ++ )
692	{
693	if( ( ( nalOrVcl == 0 ) && ( hrd->getNalHrdParametersPresentFlag() ) ) \|\|
694	( ( nalOrVcl == 1 ) && ( hrd->getVclHrdParametersPresentFlag() ) ) )
695	{
696	for( j = 0; j <= ( hrd->getCpbCntMinus1( i ) ); j ++ )
697	{
698	WRITE_UVLC( hrd->getBitRateValueMinus1( i, j, nalOrVcl ), "bit_rate_value_minus1");
699	WRITE_UVLC( hrd->getCpbSizeValueMinus1( i, j, nalOrVcl ), "cpb_size_value_minus1");
700	if( hrd->getSubPicCpbParamsPresentFlag() )
701	{
702	WRITE_UVLC( hrd->getDuCpbSizeValueMinus1( i, j, nalOrVcl ), "cpb_size_du_value_minus1");
703	WRITE_UVLC( hrd->getDuBitRateValueMinus1( i, j, nalOrVcl ), "bit_rate_du_value_minus1");
704	}
705	WRITE_FLAG( hrd->getCbrFlag( i, j, nalOrVcl ) ? 1 : 0, "cbr_flag");
706	}
707	}
708	}
709	}
710	}
711
712	Void TEncCavlc::codeSPS( const TComSPS* pcSPS )
713	{
714
715	const ChromaFormat format = pcSPS->getChromaFormatIdc();
716	const Bool chromaEnabled = isChromaEnabled(format);
717
718	#if ENC_DEC_TRACE
719	#if H_MV_ENC_DEC_TRAC
720	tracePSHeader( "SPS", pcSPS->getLayerId() );
721	#else
722	xTraceSPSHeader ();
723	#endif
724	#endif
725	WRITE_CODE( pcSPS->getVPSId (), 4, "sps_video_parameter_set_id" );
726	#if NH_MV
727	if ( pcSPS->getLayerId() == 0 )
728	{
729	#endif
730	WRITE_CODE( pcSPS->getMaxTLayers() - 1, 3, "sps_max_sub_layers_minus1" );
731	#if NH_MV
732	}
733	else
734	{
735	WRITE_CODE( pcSPS->getSpsExtOrMaxSubLayersMinus1( ), 3, "sps_ext_or_max_sub_layers_minus1" );
736	}
737	if ( !pcSPS->getMultiLayerExtSpsFlag() )
738	{
739	#endif
740	WRITE_FLAG( pcSPS->getTemporalIdNestingFlag() ? 1 : 0, "sps_temporal_id_nesting_flag" );
741	codePTL(pcSPS->getPTL(), 1, pcSPS->getMaxTLayers() - 1);
742	#if NH_MV
743	}
744	#endif
745	WRITE_UVLC( pcSPS->getSPSId (), "sps_seq_parameter_set_id" );
746	#if NH_MV
747	if ( pcSPS->getMultiLayerExtSpsFlag() )
748	{
749	WRITE_FLAG( pcSPS->getUpdateRepFormatFlag( ) ? 1 : 0 , "update_rep_format_flag" );
750	if ( pcSPS->getUpdateRepFormatFlag() )
751	{
752	WRITE_CODE( pcSPS->getSpsRepFormatIdx( ), 8, "sps_rep_format_idx" );
753	}
754	}
755	else
756	{
757	#endif
758	WRITE_UVLC( Int(pcSPS->getChromaFormatIdc ()), "chroma_format_idc" );
759	if( format == CHROMA_444 )
760	{
761	WRITE_FLAG( 0, "separate_colour_plane_flag");
762	}
763
764	WRITE_UVLC( pcSPS->getPicWidthInLumaSamples (), "pic_width_in_luma_samples" );
765	WRITE_UVLC( pcSPS->getPicHeightInLumaSamples(), "pic_height_in_luma_samples" );
766	Window conf = pcSPS->getConformanceWindow();
767
768	WRITE_FLAG( conf.getWindowEnabledFlag(), "conformance_window_flag" );
769	if (conf.getWindowEnabledFlag())
770	{
771	WRITE_UVLC( conf.getWindowLeftOffset() / TComSPS::getWinUnitX(pcSPS->getChromaFormatIdc() ), "conf_win_left_offset" );
772	WRITE_UVLC( conf.getWindowRightOffset() / TComSPS::getWinUnitX(pcSPS->getChromaFormatIdc() ), "conf_win_right_offset" );
773	WRITE_UVLC( conf.getWindowTopOffset() / TComSPS::getWinUnitY(pcSPS->getChromaFormatIdc() ), "conf_win_top_offset" );
774	WRITE_UVLC( conf.getWindowBottomOffset() / TComSPS::getWinUnitY(pcSPS->getChromaFormatIdc() ), "conf_win_bottom_offset" );
775	}
776	#if NH_MV
777	}
778	#endif
779	#if NH_MV
780	if ( !pcSPS->getMultiLayerExtSpsFlag() )
781	{
782	#endif
783
784	WRITE_UVLC( pcSPS->getBitDepth(CHANNEL_TYPE_LUMA) - 8, "bit_depth_luma_minus8" );
785
786	WRITE_UVLC( chromaEnabled ? (pcSPS->getBitDepth(CHANNEL_TYPE_CHROMA) - 8):0, "bit_depth_chroma_minus8" );
787	#if NH_MV
788	}
789	#endif
790	WRITE_UVLC( pcSPS->getBitsForPOC()-4, "log2_max_pic_order_cnt_lsb_minus4" );
791	#if NH_MV
792	if ( !pcSPS->getMultiLayerExtSpsFlag())
793	{
794	#endif
795
796	const Bool subLayerOrderingInfoPresentFlag = 1;
797	WRITE_FLAG(subLayerOrderingInfoPresentFlag, "sps_sub_layer_ordering_info_present_flag");
798	for(UInt i=0; i <= pcSPS->getMaxTLayers()-1; i++)
799	{
800	WRITE_UVLC( pcSPS->getMaxDecPicBuffering(i) - 1, "sps_max_dec_pic_buffering_minus1[i]" );
801	WRITE_UVLC( pcSPS->getNumReorderPics(i), "sps_max_num_reorder_pics[i]" );
802	WRITE_UVLC( pcSPS->getMaxLatencyIncrease(i), "sps_max_latency_increase_plus1[i]" );
803	if (!subLayerOrderingInfoPresentFlag)
804	{
805	break;
806	}
807	}
808	#if NH_MV
809	}
810	#endif
811
812	assert( pcSPS->getMaxCUWidth() == pcSPS->getMaxCUHeight() );
813	WRITE_UVLC( pcSPS->getLog2MinCodingBlockSize() - 3, "log2_min_luma_coding_block_size_minus3" );
814	WRITE_UVLC( pcSPS->getLog2DiffMaxMinCodingBlockSize(), "log2_diff_max_min_luma_coding_block_size" );
815	WRITE_UVLC( pcSPS->getQuadtreeTULog2MinSize() - 2, "log2_min_luma_transform_block_size_minus2" );
816	WRITE_UVLC( pcSPS->getQuadtreeTULog2MaxSize() - pcSPS->getQuadtreeTULog2MinSize(), "log2_diff_max_min_luma_transform_block_size" );
817	WRITE_UVLC( pcSPS->getQuadtreeTUMaxDepthInter() - 1, "max_transform_hierarchy_depth_inter" );
818	WRITE_UVLC( pcSPS->getQuadtreeTUMaxDepthIntra() - 1, "max_transform_hierarchy_depth_intra" );
819	WRITE_FLAG( pcSPS->getScalingListFlag() ? 1 : 0, "scaling_list_enabled_flag" );
820	if(pcSPS->getScalingListFlag())
821	{
822	#if NH_MV
823	if ( pcSPS->getMultiLayerExtSpsFlag() )
824	{
825	WRITE_FLAG( pcSPS->getSpsInferScalingListFlag( ) ? 1 : 0 , "sps_infer_scaling_list_flag" );
826	}
827
828	if ( pcSPS->getSpsInferScalingListFlag() )
829	{
830	WRITE_CODE( pcSPS->getSpsScalingListRefLayerId( ), 6, "sps_scaling_list_ref_layer_id" );
831	}
832	else
833	{
834	#endif
835
836	WRITE_FLAG( pcSPS->getScalingListPresentFlag() ? 1 : 0, "sps_scaling_list_data_present_flag" );
837	if(pcSPS->getScalingListPresentFlag())
838	{
839	codeScalingList( pcSPS->getScalingList() );
840	}
841	#if NH_MV
842	}
843	#endif
844	}
845	WRITE_FLAG( pcSPS->getUseAMP() ? 1 : 0, "amp_enabled_flag" );
846	WRITE_FLAG( pcSPS->getUseSAO() ? 1 : 0, "sample_adaptive_offset_enabled_flag");
847
848	WRITE_FLAG( pcSPS->getUsePCM() ? 1 : 0, "pcm_enabled_flag");
849	if( pcSPS->getUsePCM() )
850	{
851	WRITE_CODE( pcSPS->getPCMBitDepth(CHANNEL_TYPE_LUMA) - 1, 4, "pcm_sample_bit_depth_luma_minus1" );
852	WRITE_CODE( chromaEnabled ? (pcSPS->getPCMBitDepth(CHANNEL_TYPE_CHROMA) - 1) : 0, 4, "pcm_sample_bit_depth_chroma_minus1" );
853	WRITE_UVLC( pcSPS->getPCMLog2MinSize() - 3, "log2_min_pcm_luma_coding_block_size_minus3" );
854	WRITE_UVLC( pcSPS->getPCMLog2MaxSize() - pcSPS->getPCMLog2MinSize(), "log2_diff_max_min_pcm_luma_coding_block_size" );
855	WRITE_FLAG( pcSPS->getPCMFilterDisableFlag()?1 : 0, "pcm_loop_filter_disable_flag");
856	}
857
858	assert( pcSPS->getMaxTLayers() > 0 );
859
860	const TComRPSList* rpsList = pcSPS->getRPSList();
861
862	WRITE_UVLC(rpsList->getNumberOfReferencePictureSets(), "num_short_term_ref_pic_sets" );
863	for(Int i=0; i < rpsList->getNumberOfReferencePictureSets(); i++)
864	{
865	const TComReferencePictureSet*rps = rpsList->getReferencePictureSet(i);
866	codeShortTermRefPicSet( rps,false, i);
867	}
868	WRITE_FLAG( pcSPS->getLongTermRefsPresent() ? 1 : 0, "long_term_ref_pics_present_flag" );
869	if (pcSPS->getLongTermRefsPresent())
870	{
871	WRITE_UVLC(pcSPS->getNumLongTermRefPicSPS(), "num_long_term_ref_pics_sps" );
872	for (UInt k = 0; k < pcSPS->getNumLongTermRefPicSPS(); k++)
873	{
874	WRITE_CODE( pcSPS->getLtRefPicPocLsbSps(k), pcSPS->getBitsForPOC(), "lt_ref_pic_poc_lsb_sps");
875	WRITE_FLAG( pcSPS->getUsedByCurrPicLtSPSFlag(k), "used_by_curr_pic_lt_sps_flag[i]");
876	}
877	}
878	WRITE_FLAG( pcSPS->getTMVPFlagsPresent() ? 1 : 0, "sps_temporal_mvp_enable_flag" );
879
880	WRITE_FLAG( pcSPS->getUseStrongIntraSmoothing(), "sps_strong_intra_smoothing_enable_flag" );
881
882	WRITE_FLAG( pcSPS->getVuiParametersPresentFlag(), "vui_parameters_present_flag" );
883	if (pcSPS->getVuiParametersPresentFlag())
884	{
885	codeVUI(pcSPS->getVuiParameters(), pcSPS);
886	}
887
888	#if !NH_MV
889	Bool sps_extension_present_flag=false;
890	Bool sps_extension_flags[NUM_SPS_EXTENSION_FLAGS]={false};
891
892	sps_extension_flags[SPS_EXT__REXT] = pcSPS->getSpsRangeExtension().settingsDifferFromDefaults();
893
894	// Other SPS extension flags checked here.
895
896	for(Int i=0; i<NUM_SPS_EXTENSION_FLAGS; i++)
897	{
898	sps_extension_present_flag\|=sps_extension_flags[i];
899	}
900
901	WRITE_FLAG( (sps_extension_present_flag?1:0), "sps_extension_present_flag" );
902
903	if (sps_extension_present_flag)
904	{
905	#if ENC_DEC_TRACE \|\| RExt__DECODER_DEBUG_BIT_STATISTICS
906	static const char *syntaxStrings[]={ "sps_range_extension_flag",
907	"sps_multilayer_extension_flag",
908	"sps_extension_6bits[0]",
909	"sps_extension_6bits[1]",
910	"sps_extension_6bits[2]",
911	"sps_extension_6bits[3]",
912	"sps_extension_6bits[4]",
913	"sps_extension_6bits[5]" };
914	#endif
915
916	for(Int i=0; i<NUM_SPS_EXTENSION_FLAGS; i++)
917	{
918	WRITE_FLAG( sps_extension_flags[i]?1:0, syntaxStrings[i] );
919	}
920
921	for(Int i=0; i<NUM_SPS_EXTENSION_FLAGS; i++) // loop used so that the order is determined by the enum.
922	{
923	if (sps_extension_flags[i])
924	{
925	switch (SPSExtensionFlagIndex(i))
926	{
927	case SPS_EXT__REXT:
928	{
929	const TComSPSRExt &spsRangeExtension=pcSPS->getSpsRangeExtension();
930
931	WRITE_FLAG( (spsRangeExtension.getTransformSkipRotationEnabledFlag() ? 1 : 0), "transform_skip_rotation_enabled_flag");
932	WRITE_FLAG( (spsRangeExtension.getTransformSkipContextEnabledFlag() ? 1 : 0), "transform_skip_context_enabled_flag");
933	WRITE_FLAG( (spsRangeExtension.getRdpcmEnabledFlag(RDPCM_SIGNAL_IMPLICIT) ? 1 : 0), "implicit_rdpcm_enabled_flag" );
934	WRITE_FLAG( (spsRangeExtension.getRdpcmEnabledFlag(RDPCM_SIGNAL_EXPLICIT) ? 1 : 0), "explicit_rdpcm_enabled_flag" );
935	WRITE_FLAG( (spsRangeExtension.getExtendedPrecisionProcessingFlag() ? 1 : 0), "extended_precision_processing_flag" );
936	WRITE_FLAG( (spsRangeExtension.getIntraSmoothingDisabledFlag() ? 1 : 0), "intra_smoothing_disabled_flag" );
937	WRITE_FLAG( (spsRangeExtension.getHighPrecisionOffsetsEnabledFlag() ? 1 : 0), "high_precision_offsets_enabled_flag" );
938	WRITE_FLAG( (spsRangeExtension.getPersistentRiceAdaptationEnabledFlag() ? 1 : 0), "persistent_rice_adaptation_enabled_flag" );
939	WRITE_FLAG( (spsRangeExtension.getCabacBypassAlignmentEnabledFlag() ? 1 : 0), "cabac_bypass_alignment_enabled_flag" );
940	break;
941	}
942	default:
943	assert(sps_extension_flags[i]==false); // Should never get here with an active SPS extension flag.
944	break;
945	}
946	}
947	}
948	}
949	#else
950	WRITE_FLAG( pcSPS->getSpsExtensionPresentFlag(), "sps_extension_present_flag" );
951
952	if ( pcSPS->getSpsExtensionPresentFlag() )
953	{
954	WRITE_FLAG( pcSPS->getSpsRangeExtensionsFlag( ) ? 1 : 0 , "sps_range_extensions_flag" );
955	WRITE_FLAG( pcSPS->getSpsMultilayerExtensionFlag( ) ? 1 : 0 , "sps_multilayer_extension_flag" );
956	WRITE_FLAG( pcSPS->getSps3dExtensionFlag( ) ? 1 : 0 , "sps_3d_extension_flag" );
957	WRITE_CODE( pcSPS->getSpsExtension5bits( ) , 5 , "sps_extension_5bits" );
958	}
959
960	if ( pcSPS->getSpsRangeExtensionsFlag() )
961	{
962	const TComSPSRExt &spsRangeExtension=pcSPS->getSpsRangeExtension();
963
964	WRITE_FLAG( (spsRangeExtension.getTransformSkipRotationEnabledFlag() ? 1 : 0), "transform_skip_rotation_enabled_flag");
965	WRITE_FLAG( (spsRangeExtension.getTransformSkipContextEnabledFlag() ? 1 : 0), "transform_skip_context_enabled_flag");
966	WRITE_FLAG( (spsRangeExtension.getRdpcmEnabledFlag(RDPCM_SIGNAL_IMPLICIT) ? 1 : 0), "implicit_rdpcm_enabled_flag" );
967	WRITE_FLAG( (spsRangeExtension.getRdpcmEnabledFlag(RDPCM_SIGNAL_EXPLICIT) ? 1 : 0), "explicit_rdpcm_enabled_flag" );
968	WRITE_FLAG( (spsRangeExtension.getExtendedPrecisionProcessingFlag() ? 1 : 0), "extended_precision_processing_flag" );
969	WRITE_FLAG( (spsRangeExtension.getIntraSmoothingDisabledFlag() ? 1 : 0), "intra_smoothing_disabled_flag" );
970	WRITE_FLAG( (spsRangeExtension.getHighPrecisionOffsetsEnabledFlag() ? 1 : 0), "high_precision_offsets_enabled_flag" );
971	WRITE_FLAG( (spsRangeExtension.getPersistentRiceAdaptationEnabledFlag() ? 1 : 0), "persistent_rice_adaptation_enabled_flag" );
972	WRITE_FLAG( (spsRangeExtension.getCabacBypassAlignmentEnabledFlag() ? 1 : 0), "cabac_bypass_alignment_enabled_flag" );
973	}
974
975	if ( pcSPS->getSpsMultilayerExtensionFlag() )
976	{
977	codeSPSExtension( pcSPS );
978	}
979
980	#if NH_3D
981	if ( pcSPS->getSps3dExtensionFlag() )
982	{
983	codeSPS3dExtension( pcSPS );
984	}
985
986	#endif
987	#endif
988	xWriteRbspTrailingBits();
989	}
990
991	#if NH_MV
992	Void TEncCavlc::codeSPSExtension( const TComSPS* pcSPS )
993	{
994	WRITE_FLAG( pcSPS->getInterViewMvVertConstraintFlag() ? 1 : 0, "inter_view_mv_vert_constraint_flag" );
995	}
996
997
998	Void TEncCavlc::codePpsMultilayerExtension(const TComPPS* pcPPS)
999	{
1000	WRITE_FLAG( pcPPS->getPocResetInfoPresentFlag( ) ? 1 : 0 , "poc_reset_info_present_flag" );
1001	WRITE_FLAG( pcPPS->getPpsInferScalingListFlag( ) ? 1 : 0 , "pps_infer_scaling_list_flag" );
1002	if (pcPPS->getPpsInferScalingListFlag())
1003	{
1004	WRITE_CODE( pcPPS->getPpsScalingListRefLayerId( ), 6, "pps_scaling_list_ref_layer_id" );
1005	}
1006	WRITE_UVLC( 0, "num_ref_loc_offsets" );
1007	WRITE_FLAG( 0 , "colour_mapping_enabled_flag" );
1008
1009	}
1010
1011	#endif
1012
1013	#if NH_3D
1014	Void TEncCavlc::codeSPS3dExtension( const TComSPS* pcSPS )
1015	{
1016	const TComSps3dExtension* sps3dExt = pcSPS->getSps3dExtension();
1017	for( Int d = 0; d <= 1; d++ )
1018	{
1019	WRITE_FLAG( sps3dExt->getIvMvPredFlag( d ) ? 1 : 0 , "iv_mv_pred_flag" );
1020	WRITE_FLAG( sps3dExt->getIvMvScalingFlag( d ) ? 1 : 0 , "iv_mv_scaling_flag" );
1021	if( d == 0 )
1022	{
1023	WRITE_UVLC( sps3dExt->getLog2SubPbSizeMinus3( d ), "log2_sub_pb_size_minus3" );
1024	WRITE_FLAG( sps3dExt->getIvResPredFlag( d ) ? 1 : 0 , "iv_res_pred_flag" );
1025	WRITE_FLAG( sps3dExt->getDepthRefinementFlag( d ) ? 1 : 0 , "depth_refinement_flag" );
1026	WRITE_FLAG( sps3dExt->getViewSynthesisPredFlag( d ) ? 1 : 0 , "view_synthesis_pred_flag" );
1027	WRITE_FLAG( sps3dExt->getDepthBasedBlkPartFlag( d ) ? 1 : 0 , "depth_based_blk_part_flag" );
1028	}
1029	else
1030	{
1031	WRITE_FLAG( sps3dExt->getMpiFlag( d ) ? 1 : 0 , "mpi_flag" );
1032	WRITE_UVLC( sps3dExt->getLog2MpiSubPbSizeMinus3( d ), "log2_mpi_sub_pb_size_minus3" );
1033	WRITE_FLAG( sps3dExt->getIntraContourFlag( d ) ? 1 : 0 , "intra_contour_flag" );
1034	WRITE_FLAG( sps3dExt->getIntraSdcWedgeFlag( d ) ? 1 : 0 , "intra_sdc_wedge_flag" );
1035	WRITE_FLAG( sps3dExt->getQtPredFlag( d ) ? 1 : 0 , "qt_pred_flag" );
1036	WRITE_FLAG( sps3dExt->getInterSdcFlag( d ) ? 1 : 0 , "inter_sdc_flag" );
1037	WRITE_FLAG( sps3dExt->getDepthIntraSkipFlag( d ) ? 1 : 0 , "intra_skip_flag" );
1038	}
1039	}
1040	}
1041	#endif
1042
1043
1044	Void TEncCavlc::codeVPS( const TComVPS* pcVPS )
1045	{
1046	#if ENC_DEC_TRACE
1047	#if H_MV_ENC_DEC_TRAC
1048	tracePSHeader( "VPS", getEncTop()->getLayerId() );
1049	#else
1050	xTraceVPSHeader();
1051	#endif
1052	#endif
1053	WRITE_CODE( pcVPS->getVPSId(), 4, "vps_video_parameter_set_id" );
1054	#if NH_MV
1055	WRITE_FLAG( pcVPS->getVpsBaseLayerInternalFlag( ) ? 1 : 0 , "vps_base_layer_internal_flag" );
1056	WRITE_FLAG( pcVPS->getVpsBaseLayerAvailableFlag( ) ? 1 : 0 , "vps_base_layer_available_flag" );
1057	#else
1058	WRITE_FLAG( 1, "vps_base_layer_internal_flag" );
1059	WRITE_FLAG( 1, "vps_base_layer_available_flag" );
1060	#endif
1061	#if NH_MV
1062	WRITE_CODE( pcVPS->getMaxLayersMinus1(), 6, "vps_max_layers_minus1" );
1063	#else
1064	WRITE_CODE( 0, 6, "vps_max_layers_minus1" );
1065	#endif
1066	WRITE_CODE( pcVPS->getMaxTLayers() - 1, 3, "vps_max_sub_layers_minus1" );
1067	WRITE_FLAG( pcVPS->getTemporalNestingFlag(), "vps_temporal_id_nesting_flag" );
1068	assert (pcVPS->getMaxTLayers()>1\|\|pcVPS->getTemporalNestingFlag());
1069	WRITE_CODE( 0xffff, 16, "vps_reserved_0xffff_16bits" );
1070	codePTL( pcVPS->getPTL(), true, pcVPS->getMaxTLayers() - 1 );
1071	const Bool subLayerOrderingInfoPresentFlag = 1;
1072	WRITE_FLAG(subLayerOrderingInfoPresentFlag, "vps_sub_layer_ordering_info_present_flag");
1073	for(UInt i=0; i <= pcVPS->getMaxTLayers()-1; i++)
1074	{
1075	WRITE_UVLC( pcVPS->getMaxDecPicBuffering(i) - 1, "vps_max_dec_pic_buffering_minus1[i]" );
1076	WRITE_UVLC( pcVPS->getNumReorderPics(i), "vps_max_num_reorder_pics[i]" );
1077	WRITE_UVLC( pcVPS->getMaxLatencyIncrease(i), "vps_max_latency_increase_plus1[i]" );
1078	if (!subLayerOrderingInfoPresentFlag)
1079	{
1080	break;
1081	}
1082	}
1083
1084	assert( pcVPS->getNumHrdParameters() <= MAX_VPS_NUM_HRD_PARAMETERS );
1085	#if NH_MV
1086	assert( pcVPS->getVpsMaxLayerId() < MAX_VPS_NUH_LAYER_ID_PLUS1 );
1087	WRITE_CODE( pcVPS->getVpsMaxLayerId(), 6, "vps_max_layer_id" );
1088	WRITE_UVLC( pcVPS->getVpsNumLayerSetsMinus1(), "vps_num_layer_sets_minus1" );
1089	for( UInt opsIdx = 1; opsIdx <= pcVPS->getVpsNumLayerSetsMinus1(); opsIdx ++ )
1090	{
1091	// Operation point set
1092	for( UInt i = 0; i <= pcVPS->getVpsMaxLayerId(); i ++ )
1093	{
1094	#else
1095	assert( pcVPS->getMaxNuhReservedZeroLayerId() < MAX_VPS_NUH_RESERVED_ZERO_LAYER_ID_PLUS1 );
1096	WRITE_CODE( pcVPS->getMaxNuhReservedZeroLayerId(), 6, "vps_max_layer_id" );
1097	WRITE_UVLC( pcVPS->getMaxOpSets() - 1, "vps_num_layer_sets_minus1" );
1098	for( UInt opsIdx = 1; opsIdx <= ( pcVPS->getMaxOpSets() - 1 ); opsIdx ++ )
1099	{
1100	// Operation point set
1101	for( UInt i = 0; i <= pcVPS->getMaxNuhReservedZeroLayerId(); i ++ )
1102	{
1103	// Only applicable for version 1
1104	// pcVPS->setLayerIdIncludedFlag( true, opsIdx, i );
1105	#endif
1106	WRITE_FLAG( pcVPS->getLayerIdIncludedFlag( opsIdx, i ) ? 1 : 0, "layer_id_included_flag[opsIdx][i]" );
1107	}
1108	}
1109	const TimingInfo *timingInfo = pcVPS->getTimingInfo();
1110	WRITE_FLAG(timingInfo->getTimingInfoPresentFlag(), "vps_timing_info_present_flag");
1111	if(timingInfo->getTimingInfoPresentFlag())
1112	{
1113	WRITE_CODE(timingInfo->getNumUnitsInTick(), 32, "vps_num_units_in_tick");
1114	WRITE_CODE(timingInfo->getTimeScale(), 32, "vps_time_scale");
1115	WRITE_FLAG(timingInfo->getPocProportionalToTimingFlag(), "vps_poc_proportional_to_timing_flag");
1116	if(timingInfo->getPocProportionalToTimingFlag())
1117	{
1118	WRITE_UVLC(timingInfo->getNumTicksPocDiffOneMinus1(), "vps_num_ticks_poc_diff_one_minus1");
1119	}
1120	WRITE_UVLC( pcVPS->getNumHrdParameters(), "vps_num_hrd_parameters" );
1121
1122	if( pcVPS->getNumHrdParameters() > 0 )
1123	{
1124	for( UInt i = 0; i < pcVPS->getNumHrdParameters(); i ++ )
1125	{
1126	// Only applicable for version 1
1127	WRITE_UVLC( pcVPS->getHrdOpSetIdx( i ), "hrd_layer_set_idx" );
1128	if( i > 0 )
1129	{
1130	WRITE_FLAG( pcVPS->getCprmsPresentFlag( i ) ? 1 : 0, "cprms_present_flag[i]" );
1131	}
1132	codeHrdParameters(pcVPS->getHrdParameters(i), pcVPS->getCprmsPresentFlag( i ), pcVPS->getMaxTLayers() - 1);
1133	}
1134	}
1135	}
1136	#if NH_MV
1137	WRITE_FLAG( pcVPS->getVpsExtensionFlag(), "vps_extension_flag" );
1138	m_pcBitIf->writeAlignOne();
1139	codeVPSExtension( pcVPS );
1140	#if NH_3D
1141	WRITE_FLAG( 1, "vps_extension2_flag" );
1142	WRITE_FLAG( 1, "vps_3d_extension_flag" );
1143	m_pcBitIf->writeAlignOne();
1144	codeVPS3dExtension( pcVPS );
1145	WRITE_FLAG( 0, "vps_extension3_flag" );
1146	#else
1147	WRITE_FLAG( 0, "vps_extension2_flag" );
1148	#endif
1149	#else
1150	WRITE_FLAG( 0, "vps_extension_flag" );
1151	#endif
1152
1153	//future extensions here..
1154	xWriteRbspTrailingBits();
1155	}
1156
1157	#if NH_MV
1158	Void TEncCavlc::codeVPSExtension( const TComVPS *pcVPS )
1159	{
1160	if( pcVPS->getMaxLayersMinus1() > 0 && pcVPS->getVpsBaseLayerInternalFlag() )
1161	{
1162	codePTL( pcVPS->getPTL( 1 ),0, pcVPS->getMaxSubLayersMinus1() );
1163	}
1164
1165	WRITE_FLAG( pcVPS->getSplittingFlag() ? 1 : 0, "splitting_flag" );
1166
1167	for( Int type = 0; type < MAX_NUM_SCALABILITY_TYPES; type++ )
1168	{
1169	WRITE_FLAG( pcVPS->getScalabilityMaskFlag( type ) ? 1 : 0, "scalability_mask_flag[i]" );
1170	}
1171
1172	for( Int sIdx = 0; sIdx < pcVPS->getNumScalabilityTypes( ) - ( pcVPS->getSplittingFlag() ? 1 : 0 ); sIdx++ )
1173	{
1174	WRITE_CODE( pcVPS->getDimensionIdLen( sIdx ) - 1 , 3, "dimension_id_len_minus1[j]");
1175	}
1176
1177	if ( pcVPS->getSplittingFlag() )
1178	{
1179	assert( pcVPS->getDimensionIdLen( pcVPS->getNumScalabilityTypes( ) - 1 ) == pcVPS->inferLastDimsionIdLenMinus1() + 1 );
1180	}
1181
1182	WRITE_FLAG( pcVPS->getVpsNuhLayerIdPresentFlag() ? 1 : 0, "vps_nuh_layer_id_present_flag");
1183
1184	for( Int i = 1; i <= pcVPS->getMaxLayersMinus1(); i++ )
1185	{
1186	if ( pcVPS->getVpsNuhLayerIdPresentFlag() )
1187	{
1188	WRITE_CODE( pcVPS->getLayerIdInNuh( i ), 6, "layer_id_in_nuh[i]");
1189	}
1190	else
1191	{
1192	assert( pcVPS->getLayerIdInNuh( i ) == i );
1193	}
1194
1195	assert( pcVPS->getLayerIdInVps( pcVPS->getLayerIdInNuh( i ) ) == i );
1196
1197	for( Int j = 0; j < pcVPS->getNumScalabilityTypes() ; j++ )
1198	{
1199	if ( !pcVPS->getSplittingFlag() )
1200	{
1201	WRITE_CODE( pcVPS->getDimensionId( i, j ), pcVPS->getDimensionIdLen( j ), "dimension_id[i][j]");
1202	}
1203	else
1204	{
1205	assert( pcVPS->getDimensionId( i, j ) == pcVPS->inferDimensionId( i, j ) );
1206	}
1207	}
1208	}
1209
1210	WRITE_CODE( pcVPS->getViewIdLen( ), 4, "view_id_len" );
1211
1212	if ( pcVPS->getViewIdLen( ) > 0 )
1213	{
1214	for( Int i = 0; i < pcVPS->getNumViews(); i++ )
1215	{
1216	WRITE_CODE( pcVPS->getViewIdVal( i ), pcVPS->getViewIdLen( ), "view_id_val[i]" );
1217	}
1218	}
1219	else
1220	{
1221	for( Int i = 0; i < pcVPS->getNumViews(); i++ )
1222	{
1223	assert( pcVPS->getViewIdVal( i ) == 0 );
1224	}
1225	}
1226
1227
1228	for( Int i = 1; i <= pcVPS->getMaxLayersMinus1(); i++ )
1229	{
1230	for( Int j = 0; j < i; j++ )
1231	{
1232	WRITE_FLAG( pcVPS->getDirectDependencyFlag( i, j ), "direct_dependency_flag[i][j]" );
1233	}
1234	}
1235
1236	if ( pcVPS->getNumIndependentLayers() > 1 )
1237	{
1238	WRITE_UVLC( pcVPS->getNumAddLayerSets( ), "num_add_layer_sets" );
1239	}
1240	for (Int i = 0; i < pcVPS->getNumAddLayerSets(); i++)
1241	{
1242	for (Int j = 1; j < pcVPS->getNumIndependentLayers(); j++)
1243	{
1244	WRITE_CODE( pcVPS->getHighestLayerIdxPlus1( i, j ), pcVPS->getHighestLayerIdxPlus1Len( j ) , "highest_layer_idx_plus1" );
1245	}
1246
1247	}
1248
1249
1250	WRITE_FLAG( pcVPS->getVpsSubLayersMaxMinus1PresentFlag( ) ? 1 : 0 , "vps_sub_layers_max_minus1_present_flag" );
1251	if ( pcVPS->getVpsSubLayersMaxMinus1PresentFlag() )
1252	{
1253	for (Int i = 0; i <= pcVPS->getMaxLayersMinus1(); i++ )
1254	{
1255	WRITE_CODE( pcVPS->getSubLayersVpsMaxMinus1( i ), 3, "sub_layers_vps_max_minus1" );
1256	pcVPS->checkSubLayersVpsMaxMinus1( i );
1257	}
1258	}
1259	else
1260	{
1261	for (Int i = 0; i <= pcVPS->getMaxLayersMinus1(); i++ )
1262	{
1263	assert( pcVPS->getSubLayersVpsMaxMinus1( i ) + 1 == pcVPS->getMaxTLayers( ) );
1264	}
1265	}
1266	WRITE_FLAG( pcVPS->getMaxTidRefPresentFlag( ) ? 1 : 0 , "max_tid_ref_present_flag" );
1267
1268	if ( pcVPS->getMaxTidRefPresentFlag() )
1269	{
1270	for( Int i = 0; i < pcVPS->getMaxLayersMinus1(); i++ )
1271	{
1272	for( Int j = i + 1; j <= pcVPS->getMaxLayersMinus1(); j++ )
1273	{
1274	if ( pcVPS->getDirectDependencyFlag(j,i) )
1275	{
1276	WRITE_CODE( pcVPS->getMaxTidIlRefPicsPlus1( i, j ), 3, "max_tid_il_ref_pics_plus1" );
1277	}
1278	}
1279	}
1280	}
1281
1282	WRITE_FLAG( pcVPS->getAllRefLayersActiveFlag( ) ? 1 : 0 , "all_ref_layers_active_flag" );
1283	WRITE_UVLC( pcVPS->getVpsNumProfileTierLevelMinus1( ), "vps_num_profile_tier_level_minus1" );
1284
1285	Int offsetVal = ( pcVPS->getMaxLayersMinus1() > 0 && pcVPS->getVpsBaseLayerInternalFlag() ) ? 2 : 1;
1286	for( Int i = pcVPS->getVpsBaseLayerInternalFlag() ? 2 : 1; i <= pcVPS->getVpsNumProfileTierLevelMinus1(); i++ )
1287	{
1288	WRITE_FLAG( pcVPS->getVpsProfilePresentFlag( i ) ? 1 : 0, "vps_profile_present_flag[i]" );
1289	codePTL( pcVPS->getPTL( offsetVal ), pcVPS->getVpsProfilePresentFlag( i ), pcVPS->getMaxTLayers() - 1 );
1290	offsetVal++;
1291	}
1292
1293
1294	if (pcVPS->getNumLayerSets() > 1)
1295	{
1296	WRITE_UVLC( pcVPS->getNumAddOlss( ), "num_add_olss" );
1297	WRITE_CODE( pcVPS->getDefaultOutputLayerIdc( ), 2, "default_output_layer_idc" );
1298	}
1299
1300	assert( pcVPS->getOutputLayerFlag(0, 0) == pcVPS->inferOutputLayerFlag( 0, 0 ));
1301	assert( pcVPS->getLayerSetIdxForOlsMinus1( 0 ) == -1 );
1302
1303
1304	if (pcVPS->getVpsBaseLayerInternalFlag() )
1305	{
1306	assert( pcVPS->getProfileTierLevelIdx(0,0) == pcVPS->inferProfileTierLevelIdx(0,0) );
1307	}
1308
1309
1310	for( Int i = 1; i < pcVPS->getNumOutputLayerSets( ); i++ )
1311	{
1312	if( pcVPS->getNumLayerSets() > 2 && i >= pcVPS->getNumLayerSets( ) )
1313	{
1314	WRITE_CODE( pcVPS->getLayerSetIdxForOlsMinus1( i ), pcVPS->getLayerSetIdxForOlsMinus1Len( i ) , "layer_set_idx_for_ols_minus1[i]" );
1315	}
1316
1317	if ( i > pcVPS->getVpsNumLayerSetsMinus1() \|\| pcVPS->getDefaultOutputLayerIdc() == 2 )
1318	{
1319	for( Int j = 0; j < pcVPS->getNumLayersInIdList( pcVPS->olsIdxToLsIdx( i ) ); j++ )
1320	{
1321	WRITE_FLAG( pcVPS->getOutputLayerFlag( i, j) ? 1 : 0, "output_layer_flag" );
1322	}
1323	}
1324	else
1325	{
1326	for( Int j = 0; j < pcVPS->getNumLayersInIdList( pcVPS->olsIdxToLsIdx( i ) ) - 1; j++ )
1327	{
1328	assert( pcVPS->getOutputLayerFlag( i , j ) == pcVPS->inferOutputLayerFlag( i, j ));
1329	}
1330	}
1331
1332	for ( Int j = 0; j < pcVPS->getNumLayersInIdList( pcVPS->olsIdxToLsIdx(i)); j++ )
1333	{
1334	if (pcVPS->getNecessaryLayerFlag( i, j ) && pcVPS->getVpsNumProfileTierLevelMinus1() > 0 )
1335	{
1336	WRITE_CODE( pcVPS->getProfileTierLevelIdx( i, j ), pcVPS->getProfileTierLevelIdxLen() ,"profile_tier_level_idx[ i ][ j ]" );
1337	}
1338	if (pcVPS->getNecessaryLayerFlag( i, j ) && pcVPS->getVpsNumProfileTierLevelMinus1() == 0 )
1339	{
1340	assert( pcVPS->getProfileTierLevelIdx( i , j ) == pcVPS->inferProfileTierLevelIdx( i, j ) );
1341	}
1342
1343	}
1344	if( pcVPS->getNumOutputLayersInOutputLayerSet( i ) == 1 && pcVPS->getNumDirectRefLayers( pcVPS->getOlsHighestOutputLayerId( i ) ) > 0 )
1345	{
1346	WRITE_FLAG( pcVPS->getAltOutputLayerFlag( i ) ? 1 : 0 , "alt_output_layer_flag[ i ]" );
1347	}
1348	}
1349
1350	WRITE_UVLC( pcVPS->getVpsNumRepFormatsMinus1( ), "vps_num_rep_formats_minus1" );
1351
1352	for (Int i = 0; i <= pcVPS->getVpsNumRepFormatsMinus1(); i++ )
1353	{
1354	const TComRepFormat* curRepFormat = pcVPS->getRepFormat(i);
1355	const TComRepFormat* prevRepFormat = i > 0 ? pcVPS->getRepFormat( i - 1) : NULL;
1356	codeRepFormat( i, curRepFormat , prevRepFormat);
1357	}
1358
1359	if ( pcVPS->getVpsNumRepFormatsMinus1() > 0 )
1360	{
1361	WRITE_FLAG( pcVPS->getRepFormatIdxPresentFlag( ) ? 1 : 0 , "rep_format_idx_present_flag" );
1362	}
1363
1364	if( pcVPS->getRepFormatIdxPresentFlag() )
1365	{
1366	for( Int i = pcVPS->getVpsBaseLayerInternalFlag() ? 1 : 0; i <= pcVPS->getMaxLayersMinus1(); i++ )
1367	{
1368	WRITE_CODE( pcVPS->getVpsRepFormatIdx(i), pcVPS->getVpsRepFormatIdxLen(), "vps_rep_format_idx[i]" );
1369	}
1370	}
1371	else
1372	{
1373	for( Int i = pcVPS->getVpsBaseLayerInternalFlag() ? 1 : 0; i <= pcVPS->getMaxLayersMinus1(); i++ )
1374	{
1375	assert( pcVPS->getVpsRepFormatIdx( i ) == pcVPS->inferVpsRepFormatIdx( i ) );
1376	}
1377	}
1378
1379	WRITE_FLAG( pcVPS->getMaxOneActiveRefLayerFlag( ) ? 1 : 0, "max_one_active_ref_layer_flag" );
1380	WRITE_FLAG( pcVPS->getVpsPocLsbAlignedFlag( ) ? 1 : 0 , "vps_poc_lsb_aligned_flag" );
1381	for( Int i = 1; i <= pcVPS->getMaxLayersMinus1(); i++ )
1382	{
1383	if( pcVPS->getNumDirectRefLayers( pcVPS->getLayerIdInNuh( i ) ) == 0 )
1384	{
1385	WRITE_FLAG( pcVPS->getPocLsbNotPresentFlag( i ) ? 1 : 0 , "poc_lsb_not_present_flag" );
1386	}
1387	}
1388
1389	codeDpbSize( pcVPS );
1390
1391	WRITE_UVLC( pcVPS->getDirectDepTypeLenMinus2 ( ), "direct_dep_type_len_minus2");
1392
1393	WRITE_FLAG( pcVPS->getDefaultDirectDependencyFlag( ) ? 1 : 0 , "default_direct_dependency_flag" );
1394	if ( pcVPS->getDefaultDirectDependencyFlag( ) )
1395	{
1396	WRITE_CODE( pcVPS->getDefaultDirectDependencyType( ), pcVPS->getDirectDepTypeLenMinus2( ) + 2 , "default_direct_dependency_type" );
1397	}
1398
1399	for( Int i = pcVPS->getVpsBaseLayerInternalFlag() ? 1 : 2; i <= pcVPS->getMaxLayersMinus1(); i++ )
1400	{
1401	for( Int j = pcVPS->getVpsBaseLayerInternalFlag() ? 0 : 1; j < i; j++ )
1402	{
1403	if (pcVPS->getDirectDependencyFlag( i, j) )
1404	{
1405	if ( pcVPS->getDefaultDirectDependencyFlag( ) )
1406	{
1407	assert( pcVPS->getDirectDependencyType( i, j ) == pcVPS->getDefaultDirectDependencyType( ) );
1408	}
1409	else
1410	{
1411	assert ( pcVPS->getDirectDependencyType( i, j ) != -1 );
1412	WRITE_CODE( pcVPS->getDirectDependencyType( i, j ),pcVPS->getDirectDepTypeLenMinus2( ) + 2, "direct_dependency_type[i][j]" );
1413	}
1414	}
1415	}
1416	}
1417	WRITE_UVLC( 0, "vps_non_vui_extension_length" );
1418
1419
1420
1421
1422	WRITE_FLAG( pcVPS->getVpsVuiPresentFlag() ? 1 : 0 , "vps_vui_present_flag" );
1423	if( pcVPS->getVpsVuiPresentFlag() )
1424	{
1425	m_pcBitIf->writeAlignOne(); // vps_vui_alignment_bit_equal_to_one
1426	codeVPSVUI( pcVPS );
1427	}
1428	else
1429	{
1430	const TComVPSVUI* pcVPSVUI = pcVPS->getVPSVUI( );
1431	assert( pcVPSVUI );
1432	assert( !pcVPSVUI->getCrossLayerIrapAlignedFlag() );
1433	}
1434
1435	}
1436
1437	Void TEncCavlc::codeVideoSignalInfo( const TComVideoSignalInfo* pcVideoSignalInfo )
1438	{
1439	assert( pcVideoSignalInfo );
1440	WRITE_CODE( pcVideoSignalInfo->getVideoVpsFormat( ), 3, "video_vps_format" );
1441	WRITE_FLAG( pcVideoSignalInfo->getVideoFullRangeVpsFlag( ) ? 1 : 0 , "video_full_range_vps_flag" );
1442	WRITE_CODE( pcVideoSignalInfo->getColourPrimariesVps( ), 8, "colour_primaries_vps" );
1443	WRITE_CODE( pcVideoSignalInfo->getTransferCharacteristicsVps( ), 8, "transfer_characteristics_vps" );
1444	WRITE_CODE( pcVideoSignalInfo->getMatrixCoeffsVps( ), 8, "matrix_coeffs_vps" );
1445	}
1446
1447	Void TEncCavlc::codeDpbSize( const TComVPS* vps )
1448	{
1449	const TComDpbSize * dpbSize = vps->getDpbSize();
1450
1451	for( Int i = 1; i < vps->getNumOutputLayerSets(); i++ )
1452	{
1453	Int currLsIdx = vps->olsIdxToLsIdx( i );
1454	WRITE_FLAG( dpbSize->getSubLayerFlagInfoPresentFlag( i ) ? 1 : 0 , "sub_layer_flag_info_present_flag" );
1455	for( Int j = 0; j <= vps->getMaxSubLayersInLayerSetMinus1( currLsIdx ); j++ )
1456	{
1457	if( j > 0 && dpbSize->getSubLayerDpbInfoPresentFlag( i, j ) )
1458	{
1459	WRITE_FLAG( dpbSize->getSubLayerDpbInfoPresentFlag( i, j ) ? 1 : 0 , "sub_layer_dpb_info_present_flag" );
1460	}
1461	if( dpbSize->getSubLayerDpbInfoPresentFlag( i, j ) )
1462	{
1463	for( Int k = 0; k < vps->getNumLayersInIdList( currLsIdx ); k++ )
1464	{
1465	if ( vps->getNecessaryLayerFlag( i, k ) && ( vps->getVpsBaseLayerInternalFlag() \|\| ( vps->getLayerSetLayerIdList(vps->olsIdxToLsIdx(i),k) != 0 ) ))
1466	{
1467	WRITE_UVLC( dpbSize->getMaxVpsDecPicBufferingMinus1( i, k, j ), "max_vps_dec_pic_buffering_minus1" );
1468	}
1469	else
1470	{
1471	if ( vps->getNecessaryLayerFlag( i, k ) && ( j == 0 ) && ( k == 0 ) )
1472	{
1473	assert( dpbSize->getMaxVpsDecPicBufferingMinus1(i ,k, j ) == 0 );
1474	}
1475	}
1476	}
1477	WRITE_UVLC( dpbSize->getMaxVpsNumReorderPics( i, j ), "max_vps_num_reorder_pics" );
1478	WRITE_UVLC( dpbSize->getMaxVpsLatencyIncreasePlus1( i, j ), "max_vps_latency_increase_plus1" );
1479	}
1480	else
1481	{
1482	if ( j > 0 )
1483	{
1484	for( Int k = 0; k < vps->getNumLayersInIdList( vps->olsIdxToLsIdx( i ) ); k++ )
1485	{
1486	if ( vps->getNecessaryLayerFlag(i, k ) )
1487	{
1488	assert( dpbSize->getMaxVpsDecPicBufferingMinus1( i, k, j ) == dpbSize->getMaxVpsDecPicBufferingMinus1( i,k, j - 1 ) );
1489	}
1490	}
1491	assert( dpbSize->getMaxVpsNumReorderPics ( i, j ) == dpbSize->getMaxVpsNumReorderPics ( i, j - 1 ) );
1492	assert( dpbSize->getMaxVpsLatencyIncreasePlus1( i, j ) == dpbSize->getMaxVpsLatencyIncreasePlus1( i, j - 1 ) );
1493	}
1494	}
1495	}
1496	}
1497	}
1498
1499	Void TEncCavlc::codeRepFormat( Int i, const TComRepFormat* pcRepFormat, const TComRepFormat* pcPrevRepFormat )
1500	{
1501	assert( pcRepFormat );
1502
1503	WRITE_CODE( pcRepFormat->getPicWidthVpsInLumaSamples( ), 16, "pic_width_vps_in_luma_samples" );
1504	WRITE_CODE( pcRepFormat->getPicHeightVpsInLumaSamples( ), 16, "pic_height_vps_in_luma_samples" );
1505	WRITE_FLAG( pcRepFormat->getChromaAndBitDepthVpsPresentFlag( ) ? 1 : 0 , "chroma_and_bit_depth_vps_present_flag" );
1506
1507	pcRepFormat->checkChromaAndBitDepthVpsPresentFlag( i );
1508
1509	if ( pcRepFormat->getChromaAndBitDepthVpsPresentFlag() )
1510	{
1511	WRITE_CODE( pcRepFormat->getChromaFormatVpsIdc( ), 2, "chroma_format_vps_idc" );
1512
1513	if ( pcRepFormat->getChromaFormatVpsIdc() == 3 )
1514	{
1515	WRITE_FLAG( pcRepFormat->getSeparateColourPlaneVpsFlag( ) ? 1 : 0 , "separate_colour_plane_vps_flag" );
1516	}
1517	WRITE_CODE( pcRepFormat->getBitDepthVpsLumaMinus8( ), 4, "bit_depth_vps_luma_minus8" );
1518	WRITE_CODE( pcRepFormat->getBitDepthVpsChromaMinus8( ), 4, "bit_depth_vps_chroma_minus8" );
1519	}
1520	else
1521	{
1522	pcRepFormat->checkInferChromaAndBitDepth(pcPrevRepFormat );
1523	}
1524	WRITE_FLAG( pcRepFormat->getConformanceWindowVpsFlag( ) ? 1 : 0 , "conformance_window_vps_flag" );
1525	if ( pcRepFormat->getConformanceWindowVpsFlag() )
1526	{
1527	WRITE_UVLC( pcRepFormat->getConfWinVpsLeftOffset( ), "conf_win_vps_left_offset" );
1528	WRITE_UVLC( pcRepFormat->getConfWinVpsRightOffset( ), "conf_win_vps_right_offset" );
1529	WRITE_UVLC( pcRepFormat->getConfWinVpsTopOffset( ), "conf_win_vps_top_offset" );
1530	WRITE_UVLC( pcRepFormat->getConfWinVpsBottomOffset( ), "conf_win_vps_bottom_offset" );
1531	}
1532	}
1533
1534	Void TEncCavlc::codeVPSVUI( const TComVPS* pcVPS )
1535	{
1536	assert( pcVPS );
1537
1538	const TComVPSVUI* pcVPSVUI = pcVPS->getVPSVUI( );
1539
1540	assert( pcVPSVUI );
1541
1542
1543	WRITE_FLAG( pcVPSVUI->getCrossLayerPicTypeAlignedFlag( ) ? 1 : 0 , "cross_layer_pic_type_aligned_flag" );
1544	if ( !pcVPSVUI->getCrossLayerPicTypeAlignedFlag() )
1545	{
1546	WRITE_FLAG( pcVPSVUI->getCrossLayerIrapAlignedFlag( ) ? 1 : 0 , "cross_layer_irap_aligned_flag" );
1547	}
1548	if( pcVPSVUI->getCrossLayerIrapAlignedFlag( ) )
1549	{
1550	WRITE_FLAG( pcVPSVUI->getAllLayersIdrAlignedFlag( ) ? 1 : 0 , "all_layers_idr_aligned_flag" );
1551	}
1552	WRITE_FLAG( pcVPSVUI->getBitRatePresentVpsFlag( ) ? 1 : 0 , "bit_rate_present_vps_flag" );
1553	WRITE_FLAG( pcVPSVUI->getPicRatePresentVpsFlag( ) ? 1 : 0 , "pic_rate_present_vps_flag" );
1554	if( pcVPSVUI->getBitRatePresentVpsFlag( ) \|\| pcVPSVUI->getPicRatePresentVpsFlag( ) )
1555	{
1556	for( Int i = pcVPS->getVpsBaseLayerInternalFlag() ? 0 : 1; i < pcVPS->getNumLayerSets(); i++ )
1557	{
1558	for( Int j = 0; j <= pcVPS->getMaxSubLayersInLayerSetMinus1( i ); j++ )
1559	{
1560	if( pcVPSVUI->getBitRatePresentVpsFlag( ) )
1561	{
1562	WRITE_FLAG( pcVPSVUI->getBitRatePresentFlag( i, j ) ? 1 : 0 , "bit_rate_present_flag" );
1563	}
1564	if( pcVPSVUI->getBitRatePresentVpsFlag( ) )
1565	{
1566	WRITE_FLAG( pcVPSVUI->getPicRatePresentFlag( i, j ) ? 1 : 0 , "pic_rate_present_flag" );
1567	}
1568	if( pcVPSVUI->getBitRatePresentFlag( i, j ) )
1569	{
1570	WRITE_CODE( pcVPSVUI->getAvgBitRate( i, j ), 16, "avg_bit_rate" );
1571	WRITE_CODE( pcVPSVUI->getMaxBitRate( i, j ), 16, "max_bit_rate" );
1572	}
1573	if( pcVPSVUI->getPicRatePresentFlag( i, j ) )
1574	{
1575	WRITE_CODE( pcVPSVUI->getConstantPicRateIdc( i, j ), 2, "constant_pic_rate_idc" );
1576	WRITE_CODE( pcVPSVUI->getAvgPicRate( i, j ), 16, "avg_pic_rate" );
1577	}
1578	}
1579	}
1580	}
1581
1582	WRITE_FLAG( pcVPSVUI->getVideoSignalInfoIdxPresentFlag( ) ? 1 : 0 , "video_signal_info_idx_present_flag" );
1583	if( pcVPSVUI->getVideoSignalInfoIdxPresentFlag() )
1584	{
1585	WRITE_CODE( pcVPSVUI->getVpsNumVideoSignalInfoMinus1( ), 4, "vps_num_video_signal_info_minus1" );
1586	}
1587	else
1588	{
1589	assert( pcVPSVUI->getVpsNumVideoSignalInfoMinus1() == pcVPS->getMaxLayersMinus1() - ( pcVPS->getVpsBaseLayerInternalFlag() ? 0 : 1) );
1590	}
1591
1592	for( Int i = 0; i <= pcVPSVUI->getVpsNumVideoSignalInfoMinus1(); i++ )
1593	{
1594	assert( pcVPSVUI->getVideoSignalInfo( i ) != NULL );
1595	const TComVideoSignalInfo* curVideoSignalInfo = pcVPSVUI->getVideoSignalInfo( i );
1596	codeVideoSignalInfo( curVideoSignalInfo );
1597
1598	}
1599
1600	if( pcVPSVUI->getVideoSignalInfoIdxPresentFlag() && pcVPSVUI->getVpsNumVideoSignalInfoMinus1() > 0 )
1601	{
1602	for( Int i = pcVPS->getVpsBaseLayerInternalFlag() ? 0 : 1; i <= pcVPS->getMaxLayersMinus1(); i++ )
1603	{
1604	WRITE_CODE( pcVPSVUI->getVpsVideoSignalInfoIdx( i ), 4, "vps_video_signal_info_idx" );
1605	}
1606	}
1607	WRITE_FLAG( pcVPSVUI->getTilesNotInUseFlag( ) ? 1 : 0 , "tiles_not_in_use_flag" );
1608	if( !pcVPSVUI->getTilesNotInUseFlag() )
1609	{
1610	for( Int i = pcVPS->getVpsBaseLayerInternalFlag() ? 0 : 1; i <= pcVPS->getMaxLayersMinus1(); i++ )
1611	{
1612	WRITE_FLAG( pcVPSVUI->getTilesInUseFlag( i ) ? 1 : 0 , "tiles_in_use_flag[i]" );
1613	if( pcVPSVUI->getTilesInUseFlag( i ) )
1614	{
1615	WRITE_FLAG( pcVPSVUI->getLoopFilterNotAcrossTilesFlag( i ) ? 1 : 0, "loop_filter_not_across_tiles_flag[i]" );
1616	}
1617	}
1618	for( Int i = pcVPS->getVpsBaseLayerInternalFlag() ? 1 : 2; i <= pcVPS->getMaxLayersMinus1(); i++ )
1619	{
1620	for( Int j = 0; j < pcVPS->getNumDirectRefLayers( pcVPS->getLayerIdInNuh( i ) ) ; j++ )
1621	{
1622	Int layerIdx = pcVPS->getLayerIdInVps(pcVPS->getIdRefLayer(pcVPS->getLayerIdInNuh( i ) , j ));
1623	if( pcVPSVUI->getTilesInUseFlag( i ) && pcVPSVUI->getTilesInUseFlag( layerIdx ) )
1624	{
1625	WRITE_FLAG( pcVPSVUI->getTileBoundariesAlignedFlag( i, j ) ? 1 : 0 , "tile_boundaries_aligned_flag[i][j]" );
1626	}
1627	}
1628	}
1629	}
1630
1631	WRITE_FLAG( pcVPSVUI->getWppNotInUseFlag( ) ? 1 : 0 , "wpp_not_in_use_flag" );
1632
1633	if( !pcVPSVUI->getWppNotInUseFlag( ) )
1634	{
1635	for( Int i = 0; i <= pcVPS->getMaxLayersMinus1(); i++ )
1636	{
1637	WRITE_FLAG( pcVPSVUI->getWppInUseFlag( i ) ? 1 : 0 , "wpp_in_use_flag[i]" );
1638	}
1639	}
1640	WRITE_FLAG( pcVPSVUI->getSingleLayerForNonIrapFlag( ) ? 1 : 0 , "single_layer_for_non_irap_flag" );
1641	WRITE_FLAG( pcVPSVUI->getHigherLayerIrapSkipFlag( ) ? 1 : 0 , "higher_layer_irap_skip_flag" );
1642	WRITE_FLAG( pcVPSVUI->getIlpRestrictedRefLayersFlag( ) ? 1 : 0 , "ilp_restricted_ref_layers_flag" );
1643
1644	if( pcVPSVUI->getIlpRestrictedRefLayersFlag( ) )
1645	{
1646	for( Int i = 1; i <= pcVPS->getMaxLayersMinus1(); i++ )
1647	{
1648	for( Int j = 0; j < pcVPS->getNumDirectRefLayers( pcVPS->getLayerIdInNuh( i ) ); j++ )
1649	{
1650	if( pcVPS->getVpsBaseLayerInternalFlag() \|\| pcVPS->getIdRefLayer( pcVPS->getLayerIdInNuh( i ), j ) > 0 )
1651	{
1652	WRITE_UVLC( pcVPSVUI->getMinSpatialSegmentOffsetPlus1( i, j ), "min_spatial_segment_offset_plus1" );
1653	if( pcVPSVUI->getMinSpatialSegmentOffsetPlus1( i, j ) > 0 )
1654	{
1655	WRITE_FLAG( pcVPSVUI->getCtuBasedOffsetEnabledFlag( i, j ) ? 1 : 0 , "ctu_based_offset_enabled_flag" );
1656	if( pcVPSVUI->getCtuBasedOffsetEnabledFlag( i, j ) )
1657	{
1658	WRITE_UVLC( pcVPSVUI->getMinHorizontalCtuOffsetPlus1( i, j ), "min_horizontal_ctu_offset_plus1" );
1659	}
1660	}
1661	}
1662	}
1663	}
1664	}
1665
1666
1667	WRITE_FLAG( pcVPSVUI->getVpsVuiBspHrdPresentFlag( ) ? 1 : 0 , "vps_vui_bsp_hrd_present_flag" );
1668	if ( pcVPSVUI->getVpsVuiBspHrdPresentFlag( ) )
1669	{
1670	codeVpsVuiBspHrdParameters( pcVPS );
1671	}
1672	for( Int i = 1; i <= pcVPS->getMaxLayersMinus1(); i++ )
1673	{
1674	if( pcVPS->getNumDirectRefLayers( pcVPS->getLayerIdInNuh( i )) == 0 )
1675	{
1676	WRITE_FLAG( pcVPSVUI->getBaseLayerParameterSetCompatibilityFlag( i ) ? 1 : 0 , "base_layer_parameter_set_compatibility_flag" );
1677	}
1678	}
1679	}
1680
1681	Void TEncCavlc::codeVpsVuiBspHrdParameters( const TComVPS* pcVPS )
1682	{
1683	assert( pcVPS );
1684
1685	const TComVPSVUI* pcVPSVUI = pcVPS->getVPSVUI( );
1686
1687	assert( pcVPSVUI );
1688
1689	const TComVpsVuiBspHrdParameters* vpsVuiBspHrdP = pcVPSVUI->getVpsVuiBspHrdParameters();
1690
1691	assert ( vpsVuiBspHrdP );
1692
1693	WRITE_UVLC( vpsVuiBspHrdP->getVpsNumAddHrdParams( ), "vps_num_add_hrd_params" );
1694
1695	for( Int i = pcVPS->getNumHrdParameters(); i < pcVPS->getNumHrdParameters() + vpsVuiBspHrdP->getVpsNumAddHrdParams(); i++ )
1696	{
1697	if( i > 0 )
1698	{
1699	WRITE_FLAG( vpsVuiBspHrdP->getCprmsAddPresentFlag( i ) ? 1 : 0 , "cprms_add_present_flag" );
1700	}
1701	WRITE_UVLC( vpsVuiBspHrdP->getNumSubLayerHrdMinus1( i ), "num_sub_layer_hrd_minus1" );
1702	const TComHRD* hrdParameters = vpsVuiBspHrdP->getHrdParametermeters( i );
1703	codeHrdParameters( hrdParameters, vpsVuiBspHrdP->getCprmsAddPresentFlag( i ), vpsVuiBspHrdP->getNumSubLayerHrdMinus1( i ) );
1704	}
1705
1706	for( Int h = 1; h < pcVPS->getNumOutputLayerSets(); h++ )
1707	{
1708	WRITE_UVLC( vpsVuiBspHrdP->getNumSignalledPartitioningSchemes( h ), "num_signalled_partitioning_schemes" );
1709
1710	for( Int j = 1; j < vpsVuiBspHrdP->getNumSignalledPartitioningSchemes( h ) + 1; j++ )
1711	{
1712	WRITE_UVLC( vpsVuiBspHrdP->getNumPartitionsInSchemeMinus1( h, j ), "num_partitions_in_scheme_minus1" );
1713	for( Int k = 0; k <= vpsVuiBspHrdP->getNumPartitionsInSchemeMinus1( h, j ); k++ )
1714	{
1715	for( Int r = 0; r < pcVPS->getNumLayersInIdList(pcVPS->olsIdxToLsIdx( h ) ) ; r++ )
1716	{
1717	WRITE_FLAG( vpsVuiBspHrdP->getLayerIncludedInPartitionFlag( h, j, k, r ) ? 1 : 0 , "layer_included_in_partition_flag" );
1718	}
1719	}
1720	}
1721	for( Int i = 0; i < vpsVuiBspHrdP->getNumSignalledPartitioningSchemes( h ) + 1; i++ )
1722	{
1723	for( Int t = 0; t <= pcVPS->getMaxSubLayersInLayerSetMinus1( pcVPS->olsIdxToLsIdx( h ) ); t++ )
1724	{
1725	WRITE_UVLC( vpsVuiBspHrdP->getNumBspSchedulesMinus1( h, i, t ), "num_bsp_schedules_minus1" );
1726	for( Int j = 0; j <= vpsVuiBspHrdP->getNumBspSchedulesMinus1( h, i, t ); j++ )
1727	{
1728	for( Int k = 0; k <= vpsVuiBspHrdP->getNumPartitionsInSchemeMinus1( h, j ); k++ )
1729	{
1730	WRITE_CODE( vpsVuiBspHrdP->getBspHrdIdx( h, i, t, j, k ), vpsVuiBspHrdP->getBspHrdIdxLen( pcVPS ), "bsp_hrd_idx" );
1731	WRITE_UVLC( vpsVuiBspHrdP->getBspSchedIdx( h, i, t, j, k ), "bsp_sched_idx" );
1732	}
1733	}
1734	}
1735	}
1736	}
1737	}
1738	#endif
1739
1740	#if NH_3D
1741	Void TEncCavlc::codeVPS3dExtension( const TComVPS* pcVPS )
1742	{
1743	WRITE_UVLC( pcVPS->getCpPrecision( ), "cp_precision" );
1744	for (Int n = 1; n < pcVPS->getNumViews(); n++)
1745	{
1746	Int i = pcVPS->getViewOIdxList( n );
1747	Int iInVps = pcVPS->getVoiInVps( i );
1748	WRITE_CODE( pcVPS->getNumCp( iInVps ), 6, "num_cp" );
1749
1750	if( pcVPS->getNumCp( iInVps ) > 0 )
1751	{
1752	WRITE_FLAG( pcVPS->getCpInSliceSegmentHeaderFlag( iInVps ) ? 1 : 0 , "cp_in_slice_segment_header_flag" );
1753	for( Int m = 0; m < pcVPS->getNumCp( iInVps ); m++ )
1754	{
1755	WRITE_UVLC( pcVPS->getCpRefVoi( iInVps, m ), "cp_ref_voi" );
1756	if( !pcVPS->getCpInSliceSegmentHeaderFlag( iInVps ) )
1757	{
1758	Int j = pcVPS->getCpRefVoi( iInVps, m );
1759	Int jInVps = pcVPS->getVoiInVps( j );
1760	WRITE_SVLC( pcVPS->getVpsCpScale ( iInVps, jInVps ), "vps_cp_scale" );
1761	WRITE_SVLC( pcVPS->getVpsCpOff ( iInVps, jInVps ), "vps_cp_off" );
1762	WRITE_SVLC( pcVPS->getVpsCpInvScale( iInVps, jInVps ) + pcVPS->getVpsCpScale( iInVps, jInVps ), "vps_cp_inv_scale_plus_scale" );
1763	WRITE_SVLC( pcVPS->getVpsCpInvOff ( iInVps, jInVps ) + pcVPS->getVpsCpOff ( iInVps, jInVps ), "vps_cp_inv_off_plus_off" );
1764	}
1765	}
1766	}
1767	}
1768	}
1769	#endif
1770
1771
1772	Void TEncCavlc::codeSliceHeader ( TComSlice* pcSlice )
1773	{
1774	#if NH_MV
1775	const TComVPS* vps = pcSlice->getVPS();
1776	#endif
1777
1778	#if ENC_DEC_TRACE
1779	#if NH_MV
1780	tracePSHeader( "Slice", pcSlice->getLayerId() );
1781	#else
1782	xTraceSliceHeader ();
1783	#endif
1784	#endif
1785
1786	const ChromaFormat format = pcSlice->getSPS()->getChromaFormatIdc();
1787	const UInt numberValidComponents = getNumberValidComponents(format);
1788	const Bool chromaEnabled = isChromaEnabled(format);
1789
1790	//calculate number of bits required for slice address
1791	Int maxSliceSegmentAddress = pcSlice->getPic()->getNumberOfCtusInFrame();
1792	Int bitsSliceSegmentAddress = 0;
1793	while(maxSliceSegmentAddress>(1<<bitsSliceSegmentAddress))
1794	{
1795	bitsSliceSegmentAddress++;
1796	}
1797	const Int ctuTsAddress = pcSlice->getSliceSegmentCurStartCtuTsAddr();
1798
1799	//write slice address
1800	const Int sliceSegmentRsAddress = pcSlice->getPic()->getPicSym()->getCtuTsToRsAddrMap(ctuTsAddress);
1801
1802	WRITE_FLAG( sliceSegmentRsAddress==0, "first_slice_segment_in_pic_flag" );
1803	if ( pcSlice->getRapPicFlag() )
1804	{
1805	WRITE_FLAG( pcSlice->getNoOutputPriorPicsFlag() ? 1 : 0, "no_output_of_prior_pics_flag" );
1806	}
1807	#if PPS_FIX_DEPTH
1808	if( pcSlice->getIsDepth() )
1809	{
1810	WRITE_UVLC( 1, "slice_pic_parameter_set_id" );
1811	}
1812	else
1813	#endif
1814
1815	WRITE_UVLC( pcSlice->getPPS()->getPPSId(), "slice_pic_parameter_set_id" );
1816	if ( pcSlice->getPPS()->getDependentSliceSegmentsEnabledFlag() && (sliceSegmentRsAddress!=0) )
1817	{
1818	WRITE_FLAG( pcSlice->getDependentSliceSegmentFlag() ? 1 : 0, "dependent_slice_segment_flag" );
1819	}
1820	if(sliceSegmentRsAddress>0)
1821	{
1822	WRITE_CODE( sliceSegmentRsAddress, bitsSliceSegmentAddress, "slice_segment_address" );
1823	}
1824	if ( !pcSlice->getDependentSliceSegmentFlag() )
1825	{
1826
1827	#if NH_MV
1828	Int esb = 0; //Don't use i, otherwise will shadow something below
1829
1830	if ( pcSlice->getPPS()->getNumExtraSliceHeaderBits() > esb )
1831	{
1832	esb++;
1833	WRITE_FLAG( pcSlice->getDiscardableFlag( ) ? 1 : 0 , "discardable_flag" );
1834	if (pcSlice->getDiscardableFlag( ))
1835	{
1836	assert(pcSlice->getNalUnitType() != NAL_UNIT_CODED_SLICE_TRAIL_R &&
1837	pcSlice->getNalUnitType() != NAL_UNIT_CODED_SLICE_TSA_R &&
1838	pcSlice->getNalUnitType() != NAL_UNIT_CODED_SLICE_STSA_R &&
1839	pcSlice->getNalUnitType() != NAL_UNIT_CODED_SLICE_RADL_R &&
1840	pcSlice->getNalUnitType() != NAL_UNIT_CODED_SLICE_RASL_R);
1841	}
1842	}
1843
1844	if ( pcSlice->getPPS()->getNumExtraSliceHeaderBits() > esb )
1845	{
1846	esb++;
1847	WRITE_FLAG( pcSlice->getCrossLayerBlaFlag( ) ? 1 : 0 , "cross_layer_bla_flag" );
1848	}
1849	pcSlice->checkCrossLayerBlaFlag( );
1850
1851	for (; esb < pcSlice->getPPS()->getNumExtraSliceHeaderBits(); esb++)
1852	#else
1853	for (Int i = 0; i < pcSlice->getPPS()->getNumExtraSliceHeaderBits(); i++)
1854	#endif
1855	{
1856	WRITE_FLAG(0, "slice_reserved_flag[]");
1857	}
1858
1859
1860
1861	WRITE_UVLC( pcSlice->getSliceType(), "slice_type" );
1862
1863	if( pcSlice->getPPS()->getOutputFlagPresentFlag() )
1864	{
1865	WRITE_FLAG( pcSlice->getPicOutputFlag() ? 1 : 0, "pic_output_flag" );
1866	}
1867
1868	#if NH_MV
1869	if ( (pcSlice->getLayerId() > 0 && !vps->getPocLsbNotPresentFlag( pcSlice->getLayerIdInVps())) \|\| !pcSlice->getIdrPicFlag() )
1870	{
1871	Int picOrderCntLSB = (pcSlice->getPOC()-pcSlice->getLastIDR()+(1<<pcSlice->getSPS()->getBitsForPOC())) & ((1<<pcSlice->getSPS()->getBitsForPOC())-1);
1872	WRITE_CODE( picOrderCntLSB, pcSlice->getSPS()->getBitsForPOC(), "slice_pic_order_cnt_lsb");
1873	pcSlice->setSlicePicOrderCntLsb( picOrderCntLSB );
1874	}
1875
1876	#endif
1877
1878	if( !pcSlice->getIdrPicFlag() )
1879	{
1880	#if !NH_MV
1881	Int picOrderCntLSB = (pcSlice->getPOC()-pcSlice->getLastIDR()+(1<<pcSlice->getSPS()->getBitsForPOC())) & ((1<<pcSlice->getSPS()->getBitsForPOC())-1);
1882	WRITE_CODE( picOrderCntLSB, pcSlice->getSPS()->getBitsForPOC(), "slice_pic_order_cnt_lsb");
1883	#endif
1884	const TComReferencePictureSet* rps = pcSlice->getRPS();
1885
1886	// check for bitstream restriction stating that:
1887	// If the current picture is a BLA or CRA picture, the value of NumPocTotalCurr shall be equal to 0.
1888	// Ideally this process should not be repeated for each slice in a picture
1889	if (pcSlice->isIRAP())
1890	{
1891	for (Int picIdx = 0; picIdx < rps->getNumberOfPictures(); picIdx++)
1892	{
1893	assert (!rps->getUsed(picIdx));
1894	}
1895	}
1896
1897	if(pcSlice->getRPSidx() < 0)
1898	{
1899	WRITE_FLAG( 0, "short_term_ref_pic_set_sps_flag");
1900	codeShortTermRefPicSet( rps, true, pcSlice->getSPS()->getRPSList()->getNumberOfReferencePictureSets());
1901	}
1902	else
1903	{
1904	WRITE_FLAG( 1, "short_term_ref_pic_set_sps_flag");
1905	Int numBits = 0;
1906	while ((1 << numBits) < pcSlice->getSPS()->getRPSList()->getNumberOfReferencePictureSets())
1907	{
1908	numBits++;
1909	}
1910	if (numBits > 0)
1911	{
1912	WRITE_CODE( pcSlice->getRPSidx(), numBits, "short_term_ref_pic_set_idx" );
1913	}
1914	}
1915	if(pcSlice->getSPS()->getLongTermRefsPresent())
1916	{
1917	Int numLtrpInSH = rps->getNumberOfLongtermPictures();
1918	Int ltrpInSPS[MAX_NUM_REF_PICS];
1919	Int numLtrpInSPS = 0;
1920	UInt ltrpIndex;
1921	Int counter = 0;
1922	// WARNING: The following code only works only if a matching long-term RPS is
1923	// found in the SPS for ALL long-term pictures
1924	// The problem is that the SPS coded long-term pictures are moved to the
1925	// beginning of the list which causes a mismatch when no reference picture
1926	// list reordering is used
1927	// NB: Long-term coding is currently not supported in general by the HM encoder
1928	for(Int k = rps->getNumberOfPictures()-1; k > rps->getNumberOfPictures()-rps->getNumberOfLongtermPictures()-1; k--)
1929	{
1930	if (findMatchingLTRP(pcSlice, &ltrpIndex, rps->getPOC(k), rps->getUsed(k)))
1931	{
1932	ltrpInSPS[numLtrpInSPS] = ltrpIndex;
1933	numLtrpInSPS++;
1934	}
1935	else
1936	{
1937	counter++;
1938	}
1939	}
1940	numLtrpInSH -= numLtrpInSPS;
1941	// check that either all long-term pictures are coded in SPS or in slice header (no mixing)
1942	assert (numLtrpInSH==0 \|\| numLtrpInSPS==0);
1943
1944	Int bitsForLtrpInSPS = 0;
1945	while (pcSlice->getSPS()->getNumLongTermRefPicSPS() > (1 << bitsForLtrpInSPS))
1946	{
1947	bitsForLtrpInSPS++;
1948	}
1949	if (pcSlice->getSPS()->getNumLongTermRefPicSPS() > 0)
1950	{
1951	WRITE_UVLC( numLtrpInSPS, "num_long_term_sps");
1952	}
1953	WRITE_UVLC( numLtrpInSH, "num_long_term_pics");
1954	// Note that the LSBs of the LT ref. pic. POCs must be sorted before.
1955	// Not sorted here because LT ref indices will be used in setRefPicList()
1956	Int prevDeltaMSB = 0, prevLSB = 0;
1957	Int offset = rps->getNumberOfNegativePictures() + rps->getNumberOfPositivePictures();
1958	counter = 0;
1959	// Warning: If some pictures are moved to ltrpInSPS, i is referring to a wrong index
1960	// (mapping would be required)
1961	for(Int i=rps->getNumberOfPictures()-1 ; i > offset-1; i--, counter++)
1962	{
1963	if (counter < numLtrpInSPS)
1964	{
1965	if (bitsForLtrpInSPS > 0)
1966	{
1967	WRITE_CODE( ltrpInSPS[counter], bitsForLtrpInSPS, "lt_idx_sps[i]");
1968	}
1969	}
1970	else
1971	{
1972	WRITE_CODE( rps->getPocLSBLT(i), pcSlice->getSPS()->getBitsForPOC(), "poc_lsb_lt");
1973	WRITE_FLAG( rps->getUsed(i), "used_by_curr_pic_lt_flag");
1974	}
1975	WRITE_FLAG( rps->getDeltaPocMSBPresentFlag(i), "delta_poc_msb_present_flag");
1976
1977	if(rps->getDeltaPocMSBPresentFlag(i))
1978	{
1979	Bool deltaFlag = false;
1980	// First LTRP from SPS \|\| First LTRP from SH \|\| curr LSB != prev LSB
1981	if( (i == rps->getNumberOfPictures()-1) \|\| (i == rps->getNumberOfPictures()-1-numLtrpInSPS) \|\| (rps->getPocLSBLT(i) != prevLSB) )
1982	{
1983	deltaFlag = true;
1984	}
1985	if(deltaFlag)
1986	{
1987	WRITE_UVLC( rps->getDeltaPocMSBCycleLT(i), "delta_poc_msb_cycle_lt[i]" );
1988	}
1989	else
1990	{
1991	Int differenceInDeltaMSB = rps->getDeltaPocMSBCycleLT(i) - prevDeltaMSB;
1992	assert(differenceInDeltaMSB >= 0);
1993	WRITE_UVLC( differenceInDeltaMSB, "delta_poc_msb_cycle_lt[i]" );
1994	}
1995	prevLSB = rps->getPocLSBLT(i);
1996	prevDeltaMSB = rps->getDeltaPocMSBCycleLT(i);
1997	}
1998	}
1999	}
2000	if (pcSlice->getSPS()->getTMVPFlagsPresent())
2001	{
2002	#if NH_MV
2003	WRITE_FLAG( pcSlice->getEnableTMVPFlag() ? 1 : 0, "slice_temporal_mvp_enabled_flag" );
2004	#else
2005	WRITE_FLAG( pcSlice->getEnableTMVPFlag() ? 1 : 0, "slice_temporal_mvp_enabled_flag" );
2006	#endif
2007	}
2008	}
2009	#if NH_MV
2010	Bool interLayerPredLayerIdcPresentFlag = false;
2011	Int layerId = pcSlice->getLayerId();
2012	#if NH_3D
2013	if( pcSlice->getLayerId() > 0 && !vps->getAllRefLayersActiveFlag() && vps->getNumRefListLayers( layerId ) > 0 )
2014	#else
2015	if( pcSlice->getLayerId() > 0 && !vps->getAllRefLayersActiveFlag() && vps->getNumDirectRefLayers( layerId ) > 0 )
2016	#endif
2017	{
2018	WRITE_FLAG( pcSlice->getInterLayerPredEnabledFlag( ) ? 1 : 0 , "inter_layer_pred_enabled_flag" );
2019	#if NH_3D
2020	if( pcSlice->getInterLayerPredEnabledFlag() && vps->getNumRefListLayers( layerId ) > 1 )
2021	#else
2022	if( pcSlice->getInterLayerPredEnabledFlag() && vps->getNumDirectRefLayers( layerId ) > 1 )
2023	#endif
2024	{
2025	if( !vps->getMaxOneActiveRefLayerFlag())
2026	{
2027	WRITE_CODE( pcSlice->getNumInterLayerRefPicsMinus1( ), pcSlice->getNumInterLayerRefPicsMinus1Len( ), "num_inter_layer_ref_pics_minus1" );
2028	}
2029	#if NH_3D
2030	if ( pcSlice->getNumActiveRefLayerPics() != vps->getNumRefListLayers( layerId ) )
2031	#else
2032	if ( pcSlice->getNumActiveRefLayerPics() != vps->getNumDirectRefLayers( layerId ) )
2033	#endif
2034	{
2035	interLayerPredLayerIdcPresentFlag = true;
2036	for( Int idx = 0; idx < pcSlice->getNumActiveRefLayerPics(); idx++ )
2037	{
2038	WRITE_CODE( pcSlice->getInterLayerPredLayerIdc( idx ), pcSlice->getInterLayerPredLayerIdcLen( ), "inter_layer_pred_layer_idc" );
2039	}
2040	}
2041	}
2042	}
2043	if ( !interLayerPredLayerIdcPresentFlag )
2044	{
2045	for( Int i = 0; i < pcSlice->getNumActiveRefLayerPics(); i++ )
2046	{
2047	assert( pcSlice->getInterLayerPredLayerIdc( i ) == pcSlice->getRefLayerPicIdc( i ) );
2048	}
2049	}
2050	#endif
2051
2052	#if NH_3D
2053	if( getEncTop()->decProcAnnexI() )
2054	{
2055	if ( pcSlice->getInCmpPredAvailFlag() )
2056	{
2057	WRITE_FLAG( pcSlice->getInCompPredFlag(), "in_comp_pred_flag" );
2058	}
2059	}
2060	#endif
2061
2062	if(pcSlice->getSPS()->getUseSAO())
2063	{
2064	WRITE_FLAG( pcSlice->getSaoEnabledFlag(CHANNEL_TYPE_LUMA), "slice_sao_luma_flag" );
2065	if (chromaEnabled)
2066	{
2067	WRITE_FLAG( pcSlice->getSaoEnabledFlag(CHANNEL_TYPE_CHROMA), "slice_sao_chroma_flag" );
2068	}
2069	}
2070
2071	//check if numrefidxes match the defaults. If not, override
2072
2073	if (!pcSlice->isIntra())
2074	{
2075	Bool overrideFlag = (pcSlice->getNumRefIdx( REF_PIC_LIST_0 )!=pcSlice->getPPS()->getNumRefIdxL0DefaultActive()\|\|(pcSlice->isInterB()&&pcSlice->getNumRefIdx( REF_PIC_LIST_1 )!=pcSlice->getPPS()->getNumRefIdxL1DefaultActive()));
2076	#if PPS_FIX_DEPTH
2077	overrideFlag \|= (pcSlice->getIsDepth() && !pcSlice->getViewIndex());
2078	#endif
2079	WRITE_FLAG( overrideFlag ? 1 : 0, "num_ref_idx_active_override_flag");
2080	if (overrideFlag)
2081	{
2082	WRITE_UVLC( pcSlice->getNumRefIdx( REF_PIC_LIST_0 ) - 1, "num_ref_idx_l0_active_minus1" );
2083	if (pcSlice->isInterB())
2084	{
2085	WRITE_UVLC( pcSlice->getNumRefIdx( REF_PIC_LIST_1 ) - 1, "num_ref_idx_l1_active_minus1" );
2086	}
2087	else
2088	{
2089	pcSlice->setNumRefIdx(REF_PIC_LIST_1, 0);
2090	}
2091	}
2092	}
2093	else
2094	{
2095	pcSlice->setNumRefIdx(REF_PIC_LIST_0, 0);
2096	pcSlice->setNumRefIdx(REF_PIC_LIST_1, 0);
2097	}
2098	#if PPS_FIX_DEPTH
2099	if( (pcSlice->getPPS()->getListsModificationPresentFlag() \|\| (pcSlice->getIsDepth() && !pcSlice->getViewIndex())) && pcSlice->getNumRpsCurrTempList() > 1)
2100	#else
2101	if( pcSlice->getPPS()->getListsModificationPresentFlag() && pcSlice->getNumRpsCurrTempList() > 1)
2102	#endif
2103	{
2104	TComRefPicListModification* refPicListModification = pcSlice->getRefPicListModification();
2105	if(!pcSlice->isIntra())
2106	{
2107	WRITE_FLAG(pcSlice->getRefPicListModification()->getRefPicListModificationFlagL0() ? 1 : 0, "ref_pic_list_modification_flag_l0" );
2108	if (pcSlice->getRefPicListModification()->getRefPicListModificationFlagL0())
2109	{
2110	Int numRpsCurrTempList0 = pcSlice->getNumRpsCurrTempList();
2111	if (numRpsCurrTempList0 > 1)
2112	{
2113	Int length = 1;
2114	numRpsCurrTempList0 --;
2115	while ( numRpsCurrTempList0 >>= 1)
2116	{
2117	length ++;
2118	}
2119	for(Int i = 0; i < pcSlice->getNumRefIdx( REF_PIC_LIST_0 ); i++)
2120	{
2121	WRITE_CODE( refPicListModification->getRefPicSetIdxL0(i), length, "list_entry_l0");
2122	}
2123	}
2124	}
2125	}
2126	if(pcSlice->isInterB())
2127	{
2128	WRITE_FLAG(pcSlice->getRefPicListModification()->getRefPicListModificationFlagL1() ? 1 : 0, "ref_pic_list_modification_flag_l1" );
2129	if (pcSlice->getRefPicListModification()->getRefPicListModificationFlagL1())
2130	{
2131	Int numRpsCurrTempList1 = pcSlice->getNumRpsCurrTempList();
2132	if ( numRpsCurrTempList1 > 1 )
2133	{
2134	Int length = 1;
2135	numRpsCurrTempList1 --;
2136	while ( numRpsCurrTempList1 >>= 1)
2137	{
2138	length ++;
2139	}
2140	for(Int i = 0; i < pcSlice->getNumRefIdx( REF_PIC_LIST_1 ); i++)
2141	{
2142	WRITE_CODE( refPicListModification->getRefPicSetIdxL1(i), length, "list_entry_l1");
2143	}
2144	}
2145	}
2146	}
2147	}
2148
2149	if (pcSlice->isInterB())
2150	{
2151	WRITE_FLAG( pcSlice->getMvdL1ZeroFlag() ? 1 : 0, "mvd_l1_zero_flag");
2152	}
2153
2154	if(!pcSlice->isIntra())
2155	{
2156	if (!pcSlice->isIntra() && pcSlice->getPPS()->getCabacInitPresentFlag())
2157	{
2158	SliceType sliceType = pcSlice->getSliceType();
2159	SliceType encCABACTableIdx = pcSlice->getEncCABACTableIdx();
2160	Bool encCabacInitFlag = (sliceType!=encCABACTableIdx && encCABACTableIdx!=I_SLICE) ? true : false;
2161	pcSlice->setCabacInitFlag( encCabacInitFlag );
2162	WRITE_FLAG( encCabacInitFlag?1:0, "cabac_init_flag" );
2163	}
2164	}
2165
2166	if ( pcSlice->getEnableTMVPFlag() )
2167	{
2168	if ( pcSlice->getSliceType() == B_SLICE )
2169	{
2170	WRITE_FLAG( pcSlice->getColFromL0Flag(), "collocated_from_l0_flag" );
2171	}
2172
2173	if ( pcSlice->getSliceType() != I_SLICE &&
2174	((pcSlice->getColFromL0Flag()==1 && pcSlice->getNumRefIdx(REF_PIC_LIST_0)>1)\|\|
2175	(pcSlice->getColFromL0Flag()==0 && pcSlice->getNumRefIdx(REF_PIC_LIST_1)>1)))
2176	{
2177	WRITE_UVLC( pcSlice->getColRefIdx(), "collocated_ref_idx" );
2178	}
2179	}
2180	if ( (pcSlice->getPPS()->getUseWP() && pcSlice->getSliceType()==P_SLICE) \|\| (pcSlice->getPPS()->getWPBiPred() && pcSlice->getSliceType()==B_SLICE) )
2181	{
2182	xCodePredWeightTable( pcSlice );
2183	}
2184	#if H_3D_IC
2185	else if( pcSlice->getViewIndex() && ( pcSlice->getSliceType() == P_SLICE \|\| pcSlice->getSliceType() == B_SLICE )
2186	&& !pcSlice->getIsDepth() && vps->getNumRefListLayers( layerId ) > 0
2187	&& getEncTop()->decProcAnnexI()
2188	)
2189	{
2190	WRITE_FLAG( pcSlice->getApplyIC() ? 1 : 0, "slice_ic_enable_flag" );
2191	if( pcSlice->getApplyIC() )
2192	{
2193	WRITE_FLAG( pcSlice->getIcSkipParseFlag() ? 1 : 0, "ic_skip_mergeidx0" );
2194	}
2195	}
2196	#endif
2197	#if H_3D_IV_MERGE
2198	assert(pcSlice->getMaxNumMergeCand()<=MRG_MAX_NUM_CANDS_MEM);
2199	#else
2200	assert(pcSlice->getMaxNumMergeCand()<=MRG_MAX_NUM_CANDS);
2201	#endif
2202	if (!pcSlice->isIntra())
2203	{
2204	#if H_3D_IV_MERGE
2205	WRITE_UVLC( ( ( pcSlice->getMpiFlag( ) \|\| pcSlice->getIvMvPredFlag( ) \|\| pcSlice->getViewSynthesisPredFlag( ) ) ? MRG_MAX_NUM_CANDS_MEM : MRG_MAX_NUM_CANDS ) - pcSlice->getMaxNumMergeCand(), "five_minus_max_num_merge_cand");
2206	#else
2207	WRITE_UVLC(MRG_MAX_NUM_CANDS - pcSlice->getMaxNumMergeCand(), "five_minus_max_num_merge_cand");
2208	#endif
2209	}
2210	Int iCode = pcSlice->getSliceQp() - ( pcSlice->getPPS()->getPicInitQPMinus26() + 26 );
2211	WRITE_SVLC( iCode, "slice_qp_delta" );
2212	if (pcSlice->getPPS()->getSliceChromaQpFlag())
2213	{
2214	if (numberValidComponents > COMPONENT_Cb)
2215	{
2216	WRITE_SVLC( pcSlice->getSliceChromaQpDelta(COMPONENT_Cb), "slice_cb_qp_offset" );
2217	}
2218	if (numberValidComponents > COMPONENT_Cr)
2219	{
2220	WRITE_SVLC( pcSlice->getSliceChromaQpDelta(COMPONENT_Cr), "slice_cr_qp_offset" );
2221	}
2222	assert(numberValidComponents <= COMPONENT_Cr+1);
2223	}
2224
2225	if (pcSlice->getPPS()->getPpsRangeExtension().getChromaQpOffsetListEnabledFlag())
2226	{
2227	WRITE_FLAG(pcSlice->getUseChromaQpAdj(), "cu_chroma_qp_offset_enabled_flag");
2228	}
2229
2230	if (pcSlice->getPPS()->getDeblockingFilterControlPresentFlag())
2231	{
2232	if (pcSlice->getPPS()->getDeblockingFilterOverrideEnabledFlag() )
2233	{
2234	WRITE_FLAG(pcSlice->getDeblockingFilterOverrideFlag(), "deblocking_filter_override_flag");
2235	}
2236	if (pcSlice->getDeblockingFilterOverrideFlag())
2237	{
2238	WRITE_FLAG(pcSlice->getDeblockingFilterDisable(), "slice_disable_deblocking_filter_flag");
2239	if(!pcSlice->getDeblockingFilterDisable())
2240	{
2241	WRITE_SVLC (pcSlice->getDeblockingFilterBetaOffsetDiv2(), "slice_beta_offset_div2");
2242	WRITE_SVLC (pcSlice->getDeblockingFilterTcOffsetDiv2(), "slice_tc_offset_div2");
2243	}
2244	}
2245	}
2246
2247	Bool isSAOEnabled = pcSlice->getSPS()->getUseSAO() && (pcSlice->getSaoEnabledFlag(CHANNEL_TYPE_LUMA) \|\| (chromaEnabled && pcSlice->getSaoEnabledFlag(CHANNEL_TYPE_CHROMA)));
2248	Bool isDBFEnabled = (!pcSlice->getDeblockingFilterDisable());
2249
2250	if(pcSlice->getPPS()->getLoopFilterAcrossSlicesEnabledFlag() && ( isSAOEnabled \|\| isDBFEnabled ))
2251	{
2252	WRITE_FLAG(pcSlice->getLFCrossSliceBoundaryFlag()?1:0, "slice_loop_filter_across_slices_enabled_flag");
2253	}
2254	#if NH_3D
2255	if (getEncTop()->decProcAnnexI() )
2256	{
2257	Int voiInVps = vps->getVoiInVps( pcSlice->getViewIndex() );
2258	if( vps->getCpInSliceSegmentHeaderFlag( voiInVps ) && !pcSlice->getIsDepth() )
2259	{
2260	for( Int m = 0; m < vps->getNumCp( voiInVps ); m++ )
2261	{
2262	Int jInVps = vps->getVoiInVps( vps->getCpRefVoi( voiInVps, m ));
2263	WRITE_SVLC( pcSlice->getCpScale ( jInVps ) , "cp_scale" );
2264	WRITE_SVLC( pcSlice->getCpOff ( jInVps ) , "cp_off" );
2265	WRITE_SVLC( pcSlice->getCpInvScale( jInVps ) + pcSlice->getCpScale( jInVps ) , "cp_inv_scale_plus_scale" );
2266	WRITE_SVLC( pcSlice->getCpInvOff ( jInVps ) + pcSlice->getCpOff ( jInVps ) , "cp_inv_off_plus_off" );
2267	}
2268	}
2269	}
2270	#endif
2271
2272	}
2273	#if !NH_MV
2274	if(pcSlice->getPPS()->getSliceHeaderExtensionPresentFlag())
2275	{
2276	WRITE_UVLC(0,"slice_segment_header_extension_length");
2277	}
2278	#else
2279	if(pcSlice->getPPS()->getSliceHeaderExtensionPresentFlag())
2280	{
2281	// Derive the value of PocMsbValRequiredFlag
2282
2283	// Determine value of SH extension length.
2284	Int shExtnLengthInBit = 0;
2285	if (pcSlice->getPPS()->getPocResetInfoPresentFlag())
2286	{
2287	shExtnLengthInBit += 2;
2288	}
2289	if (pcSlice->getPocResetIdc() > 0)
2290	{
2291	shExtnLengthInBit += 6;
2292	}
2293	if (pcSlice->getPocResetIdc() == 3)
2294	{
2295	shExtnLengthInBit += (pcSlice->getSPS()->getBitsForPOC() + 1);
2296	}
2297
2298
2299	if( !pcSlice->getPocMsbValRequiredFlag() && pcSlice->getVPS()->getVpsPocLsbAlignedFlag() )
2300	{
2301	shExtnLengthInBit++; // For poc_msb_val_present_flag
2302	}
2303	else
2304	{
2305	if( pcSlice->getPocMsbValRequiredFlag() )
2306	{
2307	pcSlice->setPocMsbValPresentFlag( true );
2308	}
2309	else
2310	{
2311	pcSlice->setPocMsbValPresentFlag( false );
2312	}
2313	}
2314
2315	if( pcSlice->getPocMsbValPresentFlag() )
2316	{
2317	// Int iMaxPOClsb = 1<< pcSlice->getSPS()->getBitsForPOC(); currently unused
2318
2319	UInt lengthVal = 1;
2320	UInt tempVal = pcSlice->getPocMsbVal() + 1;
2321	assert ( tempVal );
2322	while( 1 != tempVal )
2323	{
2324	tempVal >>= 1;
2325	lengthVal += 2;
2326	}
2327	shExtnLengthInBit += lengthVal;
2328	}
2329	Int shExtnAdditionalBits = 0;
2330	if(shExtnLengthInBit % 8 != 0)
2331	{
2332	shExtnAdditionalBits = 8 - (shExtnLengthInBit % 8);
2333	}
2334	pcSlice->setSliceSegmentHeaderExtensionLength((shExtnLengthInBit + shExtnAdditionalBits) / 8);
2335
2336
2337	WRITE_UVLC( pcSlice->getSliceSegmentHeaderExtensionLength( ), "slice_segment_header_extension_length" );
2338	UInt posFollSliceSegHeaderExtLen = m_pcBitIf->getNumberOfWrittenBits();
2339	if( pcSlice->getPPS()->getPocResetInfoPresentFlag() )
2340	{
2341	WRITE_CODE( pcSlice->getPocResetIdc( ), 2, "poc_reset_idc" );
2342	}
2343	else
2344	{
2345	assert( pcSlice->getPocResetIdc( ) == 0 );
2346	}
2347
2348	pcSlice->checkPocResetIdc();
2349
2350	if( pcSlice->getPocResetIdc() != 0 )
2351	{
2352	WRITE_CODE( pcSlice->getPocResetPeriodId( ), 6, "poc_reset_period_id" );
2353	}
2354
2355	if( pcSlice->getPocResetIdc() == 3 )
2356	{
2357	WRITE_FLAG( pcSlice->getFullPocResetFlag( ) ? 1 : 0 , "full_poc_reset_flag" );
2358	WRITE_CODE( pcSlice->getPocLsbVal( ), pcSlice->getPocLsbValLen() , "poc_lsb_val" );
2359	}
2360	pcSlice->checkPocLsbVal();
2361
2362	if( !pcSlice->getPocMsbValRequiredFlag() && pcSlice->getVPS()->getVpsPocLsbAlignedFlag() )
2363	{
2364	WRITE_FLAG( pcSlice->getPocMsbValPresentFlag( ) ? 1 : 0 , "poc_msb_val_present_flag" );
2365	}
2366	else
2367	{
2368	assert( pcSlice->getPocMsbValPresentFlag() == pcSlice->inferPocMsbValPresentFlag( ) );
2369	}
2370
2371	if( pcSlice->getPocMsbValPresentFlag() )
2372	{
2373	WRITE_UVLC( pcSlice->getPocMsbVal( ), "poc_msb_val" );
2374	}
2375
2376	while( ( m_pcBitIf->getNumberOfWrittenBits() - posFollSliceSegHeaderExtLen ) < pcSlice->getSliceSegmentHeaderExtensionLength() * 8 )
2377	{
2378	WRITE_FLAG( 0, "slice_segment_header_extension_data_bit" );
2379	}
2380
2381	assert( ( m_pcBitIf->getNumberOfWrittenBits() - posFollSliceSegHeaderExtLen ) == pcSlice->getSliceSegmentHeaderExtensionLength() * 8 );
2382	}
2383	#endif
2384
2385	}
2386
2387	Void TEncCavlc::codePTL( const TComPTL* pcPTL, Bool profilePresentFlag, Int maxNumSubLayersMinus1)
2388	{
2389	if(profilePresentFlag)
2390	{
2391	codeProfileTier(pcPTL->getGeneralPTL(), false); // general_...
2392	}
2393	WRITE_CODE( Int(pcPTL->getGeneralPTL()->getLevelIdc()), 8, "general_level_idc" );
2394
2395	for (Int i = 0; i < maxNumSubLayersMinus1; i++)
2396	{
2397	#if !NH_MV
2398	#endif
2399	WRITE_FLAG( pcPTL->getSubLayerProfilePresentFlag(i), "sub_layer_profile_present_flag[i]" );
2400	#if !NH_MV
2401	#endif
2402	WRITE_FLAG( pcPTL->getSubLayerLevelPresentFlag(i), "sub_layer_level_present_flag[i]" );
2403	}
2404
2405	if (maxNumSubLayersMinus1 > 0)
2406	{
2407	for (Int i = maxNumSubLayersMinus1; i < 8; i++)
2408	{
2409	WRITE_CODE(0, 2, "reserved_zero_2bits");
2410	}
2411	}
2412
2413	for(Int i = 0; i < maxNumSubLayersMinus1; i++)
2414	{
2415	if( pcPTL->getSubLayerProfilePresentFlag(i) )
2416	{
2417	codeProfileTier(pcPTL->getSubLayerPTL(i), true); // sub_layer_...
2418	}
2419	if( pcPTL->getSubLayerLevelPresentFlag(i) )
2420	{
2421	WRITE_CODE( Int(pcPTL->getSubLayerPTL(i)->getLevelIdc()), 8, "sub_layer_level_idc[i]" );
2422	}
2423	}
2424	}
2425
2426	#if ENC_DEC_TRACE \|\| RExt__DECODER_DEBUG_BIT_STATISTICS
2427	Void TEncCavlc::codeProfileTier( const ProfileTierLevel* ptl, const Bool bIsSubLayer )
2428	#define PTL_TRACE_TEXT(txt) bIsSubLayer?("sub_layer_" txt) : ("general_" txt)
2429	#else
2430	Void TEncCavlc::codeProfileTier( const ProfileTierLevel* ptl, const Bool /bIsSubLayer/ )
2431	#define PTL_TRACE_TEXT(txt) txt
2432	#endif
2433	{
2434	WRITE_CODE( ptl->getProfileSpace(), 2 , PTL_TRACE_TEXT("profile_space" ));
2435	WRITE_FLAG( ptl->getTierFlag()==Level::HIGH, PTL_TRACE_TEXT("tier_flag" ));
2436	WRITE_CODE( Int(ptl->getProfileIdc()), 5 , PTL_TRACE_TEXT("profile_idc" ));
2437	for(Int j = 0; j < 32; j++)
2438	{
2439	WRITE_FLAG( ptl->getProfileCompatibilityFlag(j), PTL_TRACE_TEXT("profile_compatibility_flag[][j]" ));
2440	}
2441
2442	WRITE_FLAG(ptl->getProgressiveSourceFlag(), PTL_TRACE_TEXT("progressive_source_flag" ));
2443	WRITE_FLAG(ptl->getInterlacedSourceFlag(), PTL_TRACE_TEXT("interlaced_source_flag" ));
2444	WRITE_FLAG(ptl->getNonPackedConstraintFlag(), PTL_TRACE_TEXT("non_packed_constraint_flag" ));
2445	WRITE_FLAG(ptl->getFrameOnlyConstraintFlag(), PTL_TRACE_TEXT("frame_only_constraint_flag" ));
2446
2447	#if NH_MV
2448	if( ptl->getV2ConstraintsPresentFlag() )
2449	{
2450	WRITE_FLAG( ptl->getMax12bitConstraintFlag( ) ? 1 : 0 , "max_12bit_constraint_flag" );
2451	WRITE_FLAG( ptl->getMax10bitConstraintFlag( ) ? 1 : 0 , "max_10bit_constraint_flag" );
2452	WRITE_FLAG( ptl->getMax8bitConstraintFlag( ) ? 1 : 0 , "max_8bit_constraint_flag" );
2453	WRITE_FLAG( ptl->getMax422chromaConstraintFlag( ) ? 1 : 0 , "max_422chroma_constraint_flag" );
2454	WRITE_FLAG( ptl->getMax420chromaConstraintFlag( ) ? 1 : 0 , "max_420chroma_constraint_flag" );
2455	WRITE_FLAG( ptl->getMaxMonochromeConstraintFlag( ) ? 1 : 0 , "max_monochrome_constraint_flag" );
2456	WRITE_FLAG( ptl->getIntraConstraintFlag( ) ? 1 : 0 , "intra_constraint_flag" );
2457	WRITE_FLAG( ptl->getOnePictureOnlyConstraintFlag( ) ? 1 : 0 , "one_picture_only_constraint_flag" );
2458	WRITE_FLAG( ptl->getLowerBitRateConstraintFlag( ) ? 1 : 0 , "lower_bit_rate_constraint_flag" );
2459	WRITE_CODE( 0, 16, "XXX_reserved_zero_34bits[0..15]");
2460	WRITE_CODE( 0, 16, "XXX_reserved_zero_34bits[16..31]");
2461	WRITE_CODE( 0, 2 , "XXX_reserved_zero_34bits[32..33]");
2462	}
2463	else
2464	{
2465	WRITE_CODE( 0, 16, "XXX_reserved_zero_43bits[0..15]");
2466	WRITE_CODE( 0, 16, "XXX_reserved_zero_43bits[16..31]");
2467	WRITE_CODE( 0, 11, "XXX_reserved_zero_43bits[32..42]");
2468	}
2469	if( ptl->getInbldPresentFlag() )
2470	{
2471	WRITE_FLAG( ptl->getInbldFlag( ) ? 1 : 0 , "inbld_flag" );
2472	}
2473	else
2474	{
2475	WRITE_FLAG(0, "reserved_zero_bit");
2476	}
2477	#else
2478	if (ptl->getProfileIdc() == Profile::MAINREXT \|\| ptl->getProfileIdc() == Profile::HIGHTHROUGHPUTREXT )
2479	{
2480	const UInt bitDepthConstraint=ptl->getBitDepthConstraint();
2481	WRITE_FLAG(bitDepthConstraint<=12, PTL_TRACE_TEXT("max_12bit_constraint_flag" ));
2482	WRITE_FLAG(bitDepthConstraint<=10, PTL_TRACE_TEXT("max_10bit_constraint_flag" ));
2483	WRITE_FLAG(bitDepthConstraint<= 8, PTL_TRACE_TEXT("max_8bit_constraint_flag" ));
2484	const ChromaFormat chromaFmtConstraint=ptl->getChromaFormatConstraint();
2485	WRITE_FLAG(chromaFmtConstraint==CHROMA_422\|\|chromaFmtConstraint==CHROMA_420\|\|chromaFmtConstraint==CHROMA_400, PTL_TRACE_TEXT("max_422chroma_constraint_flag" ));
2486	WRITE_FLAG(chromaFmtConstraint==CHROMA_420\|\|chromaFmtConstraint==CHROMA_400, PTL_TRACE_TEXT("max_420chroma_constraint_flag" ));
2487	WRITE_FLAG(chromaFmtConstraint==CHROMA_400, PTL_TRACE_TEXT("max_monochrome_constraint_flag"));
2488	WRITE_FLAG(ptl->getIntraConstraintFlag(), PTL_TRACE_TEXT("intra_constraint_flag" ));
2489	WRITE_FLAG(ptl->getOnePictureOnlyConstraintFlag(), PTL_TRACE_TEXT("one_picture_only_constraint_flag"));
2490	WRITE_FLAG(ptl->getLowerBitRateConstraintFlag(), PTL_TRACE_TEXT("lower_bit_rate_constraint_flag" ));
2491	WRITE_CODE(0 , 16, PTL_TRACE_TEXT("reserved_zero_34bits[0..15]" ));
2492	WRITE_CODE(0 , 16, PTL_TRACE_TEXT("reserved_zero_34bits[16..31]" ));
2493	WRITE_CODE(0 , 2, PTL_TRACE_TEXT("reserved_zero_34bits[32..33]" ));
2494	}
2495	else
2496	{
2497	WRITE_CODE(0x0000 , 16, PTL_TRACE_TEXT("reserved_zero_43bits[0..15]" ));
2498	WRITE_CODE(0x0000 , 16, PTL_TRACE_TEXT("reserved_zero_43bits[16..31]" ));
2499	WRITE_CODE(0x000 , 11, PTL_TRACE_TEXT("reserved_zero_43bits[32..42]" ));
2500	}
2501	WRITE_FLAG(false, PTL_TRACE_TEXT("inbld_flag" ));
2502	#undef PTL_TRACE_TEXT
2503	#endif
2504	}
2505
2506	/**
2507	* Write tiles and wavefront substreams sizes for the slice header (entry points).
2508	*
2509	* \param pSlice TComSlice structure that contains the substream size information.
2510	*/
2511	Void TEncCavlc::codeTilesWPPEntryPoint( TComSlice* pSlice )
2512	{
2513	if (!pSlice->getPPS()->getTilesEnabledFlag() && !pSlice->getPPS()->getEntropyCodingSyncEnabledFlag())
2514	{
2515	return;
2516	}
2517	UInt maxOffset = 0;
2518	for(Int idx=0; idx<pSlice->getNumberOfSubstreamSizes(); idx++)
2519	{
2520	UInt offset=pSlice->getSubstreamSize(idx);
2521	if ( offset > maxOffset )
2522	{
2523	maxOffset = offset;
2524	}
2525	}
2526
2527	// Determine number of bits "offsetLenMinus1+1" required for entry point information
2528	UInt offsetLenMinus1 = 0;
2529	while (maxOffset >= (1u << (offsetLenMinus1 + 1)))
2530	{
2531	offsetLenMinus1++;
2532	assert(offsetLenMinus1 + 1 < 32);
2533	}
2534
2535	WRITE_UVLC(pSlice->getNumberOfSubstreamSizes(), "num_entry_point_offsets");
2536	if (pSlice->getNumberOfSubstreamSizes()>0)
2537	{
2538	WRITE_UVLC(offsetLenMinus1, "offset_len_minus1");
2539
2540	for (UInt idx=0; idx<pSlice->getNumberOfSubstreamSizes(); idx++)
2541	{
2542	WRITE_CODE(pSlice->getSubstreamSize(idx)-1, offsetLenMinus1+1, "entry_point_offset_minus1");
2543	}
2544	}
2545	}
2546
2547	Void TEncCavlc::codeTerminatingBit ( UInt /uilsLast/ )
2548	{
2549	}
2550
2551	Void TEncCavlc::codeSliceFinish ()
2552	{
2553	}
2554
2555	Void TEncCavlc::codeMVPIdx ( TComDataCU* /pcCU/, UInt /uiAbsPartIdx/, RefPicList /eRefList/ )
2556	{
2557	assert(0);
2558	}
2559
2560	Void TEncCavlc::codePartSize( TComDataCU* /pcCU/, UInt /uiAbsPartIdx/, UInt /uiDepth/ )
2561	{
2562	assert(0);
2563	}
2564
2565	Void TEncCavlc::codePredMode( TComDataCU* /pcCU/, UInt /uiAbsPartIdx/ )
2566	{
2567	assert(0);
2568	}
2569
2570	Void TEncCavlc::codeMergeFlag ( TComDataCU* /pcCU/, UInt /uiAbsPartIdx/ )
2571	{
2572	assert(0);
2573	}
2574
2575	Void TEncCavlc::codeMergeIndex ( TComDataCU* /pcCU/, UInt /uiAbsPartIdx/ )
2576	{
2577	assert(0);
2578	}
2579
2580	#if H_3D_ARP
2581	Void TEncCavlc::codeARPW( TComDataCU* pcCU, UInt uiAbsPartIdx )
2582	{
2583	assert(0);
2584	}
2585	#endif
2586
2587	#if H_3D_IC
2588	Void TEncCavlc::codeICFlag( TComDataCU* pcCU, UInt uiAbsPartIdx )
2589	{
2590	assert(0);
2591	}
2592	#endif
2593
2594	Void TEncCavlc::codeInterModeFlag( TComDataCU* /pcCU/, UInt /uiAbsPartIdx/, UInt /uiDepth/, UInt /uiEncMode/ )
2595	{
2596	assert(0);
2597	}
2598
2599	Void TEncCavlc::codeCUTransquantBypassFlag( TComDataCU* /pcCU/, UInt /uiAbsPartIdx/ )
2600	{
2601	assert(0);
2602	}
2603
2604	Void TEncCavlc::codeSkipFlag( TComDataCU* /pcCU/, UInt /uiAbsPartIdx/ )
2605	{
2606	assert(0);
2607	}
2608	#if H_3D
2609	Void TEncCavlc::codeDIS( TComDataCU* pcCU, UInt uiAbsPartIdx )
2610	{
2611	assert(0);
2612	}
2613	#endif
2614
2615	Void TEncCavlc::codeSplitFlag ( TComDataCU* /pcCU/, UInt /uiAbsPartIdx/, UInt /uiDepth/ )
2616	{
2617	assert(0);
2618	}
2619
2620	Void TEncCavlc::codeTransformSubdivFlag( UInt /uiSymbol/, UInt /uiCtx/ )
2621	{
2622	assert(0);
2623	}
2624
2625	Void TEncCavlc::codeQtCbf( TComTU& /rTu/, const ComponentID /compID/, const Bool /lowestLevel/ )
2626	{
2627	assert(0);
2628	}
2629
2630	Void TEncCavlc::codeQtRootCbf( TComDataCU* /pcCU/, UInt /uiAbsPartIdx/ )
2631	{
2632	assert(0);
2633	}
2634
2635	Void TEncCavlc::codeQtCbfZero( TComTU& /rTu/, const ChannelType /chType/ )
2636	{
2637	assert(0);
2638	}
2639	Void TEncCavlc::codeQtRootCbfZero( )
2640	{
2641	assert(0);
2642	}
2643
2644	Void TEncCavlc::codeTransformSkipFlags (TComTU& /rTu/, ComponentID /component/ )
2645	{
2646	assert(0);
2647	}
2648
2649	/** Code I_PCM information.
2650	* \param pcCU pointer to CU
2651	* \param uiAbsPartIdx CU index
2652	* \returns Void
2653	*/
2654	Void TEncCavlc::codeIPCMInfo( TComDataCU* /pcCU/, UInt /uiAbsPartIdx/ )
2655	{
2656	assert(0);
2657	}
2658
2659	Void TEncCavlc::codeIntraDirLumaAng( TComDataCU* /pcCU/, UInt /uiAbsPartIdx/, Bool /isMultiple/)
2660	{
2661	assert(0);
2662	}
2663
2664	Void TEncCavlc::codeIntraDirChroma( TComDataCU* /pcCU/, UInt /uiAbsPartIdx/ )
2665	{
2666	assert(0);
2667	}
2668
2669	Void TEncCavlc::codeInterDir( TComDataCU* /pcCU/, UInt /uiAbsPartIdx/ )
2670	{
2671	assert(0);
2672	}
2673
2674	Void TEncCavlc::codeRefFrmIdx( TComDataCU* /pcCU/, UInt /uiAbsPartIdx/, RefPicList /eRefList/ )
2675	{
2676	assert(0);
2677	}
2678
2679	Void TEncCavlc::codeMvd( TComDataCU* /pcCU/, UInt /uiAbsPartIdx/, RefPicList /eRefList/ )
2680	{
2681	assert(0);
2682	}
2683
2684	Void TEncCavlc::codeCrossComponentPrediction( TComTU& /rTu/, ComponentID /compID/ )
2685	{
2686	assert(0);
2687	}
2688
2689	Void TEncCavlc::codeDeltaQP( TComDataCU* pcCU, UInt uiAbsPartIdx )
2690	{
2691	Int iDQp = pcCU->getQP( uiAbsPartIdx ) - pcCU->getRefQP( uiAbsPartIdx );
2692
2693	Int qpBdOffsetY = pcCU->getSlice()->getSPS()->getQpBDOffset(CHANNEL_TYPE_LUMA);
2694	iDQp = (iDQp + 78 + qpBdOffsetY + (qpBdOffsetY/2)) % (52 + qpBdOffsetY) - 26 - (qpBdOffsetY/2);
2695
2696	xWriteSvlc( iDQp );
2697
2698	return;
2699	}
2700
2701	Void TEncCavlc::codeChromaQpAdjustment( TComDataCU* /pcCU/, UInt /uiAbsPartIdx/ )
2702	{
2703	assert(0);
2704	}
2705
2706	Void TEncCavlc::codeCoeffNxN ( TComTU& /rTu/, TCoeff* /pcCoef/, const ComponentID /compID/ )
2707	{
2708	assert(0);
2709	}
2710
2711	Void TEncCavlc::estBit( estBitsSbacStruct* /pcEstBitsCabac/, Int /width/, Int /height/, ChannelType /chType/ )
2712	{
2713	// printf("error : no VLC mode support in this version\n");
2714	return;
2715	}
2716
2717	// ====================================================================================================================
2718	// Protected member functions
2719	// ====================================================================================================================
2720
2721	//! Code weighted prediction tables
2722	Void TEncCavlc::xCodePredWeightTable( TComSlice* pcSlice )
2723	{
2724	WPScalingParam *wp;
2725	const ChromaFormat format = pcSlice->getPic()->getChromaFormat();
2726	const UInt numberValidComponents = getNumberValidComponents(format);
2727	const Bool bChroma = isChromaEnabled(format);
2728	const Int iNbRef = (pcSlice->getSliceType() == B_SLICE ) ? (2) : (1);
2729	Bool bDenomCoded = false;
2730	UInt uiTotalSignalledWeightFlags = 0;
2731
2732	if ( (pcSlice->getSliceType()==P_SLICE && pcSlice->getPPS()->getUseWP()) \|\| (pcSlice->getSliceType()==B_SLICE && pcSlice->getPPS()->getWPBiPred()) )
2733	{
2734	for ( Int iNumRef=0 ; iNumRef<iNbRef ; iNumRef++ ) // loop over l0 and l1 syntax elements
2735	{
2736	RefPicList eRefPicList = ( iNumRef ? REF_PIC_LIST_1 : REF_PIC_LIST_0 );
2737
2738	// NOTE: wp[].uiLog2WeightDenom and wp[].bPresentFlag are actually per-channel-type settings.
2739
2740	for ( Int iRefIdx=0 ; iRefIdx<pcSlice->getNumRefIdx(eRefPicList) ; iRefIdx++ )
2741	{
2742	pcSlice->getWpScaling(eRefPicList, iRefIdx, wp);
2743	if ( !bDenomCoded )
2744	{
2745	Int iDeltaDenom;
2746	WRITE_UVLC( wp[COMPONENT_Y].uiLog2WeightDenom, "luma_log2_weight_denom" );
2747
2748	if( bChroma )
2749	{
2750	assert(wp[COMPONENT_Cb].uiLog2WeightDenom == wp[COMPONENT_Cr].uiLog2WeightDenom); // check the channel-type settings are consistent across components.
2751	iDeltaDenom = (wp[COMPONENT_Cb].uiLog2WeightDenom - wp[COMPONENT_Y].uiLog2WeightDenom);
2752	WRITE_SVLC( iDeltaDenom, "delta_chroma_log2_weight_denom" );
2753	}
2754	bDenomCoded = true;
2755	}
2756	WRITE_FLAG( wp[COMPONENT_Y].bPresentFlag, iNumRef==0?"luma_weight_l0_flag[i]":"luma_weight_l1_flag[i]" );
2757	uiTotalSignalledWeightFlags += wp[COMPONENT_Y].bPresentFlag;
2758	}
2759	if (bChroma)
2760	{
2761	for ( Int iRefIdx=0 ; iRefIdx<pcSlice->getNumRefIdx(eRefPicList) ; iRefIdx++ )
2762	{
2763	pcSlice->getWpScaling(eRefPicList, iRefIdx, wp);
2764	assert(wp[COMPONENT_Cb].bPresentFlag == wp[COMPONENT_Cr].bPresentFlag); // check the channel-type settings are consistent across components.
2765	WRITE_FLAG( wp[COMPONENT_Cb].bPresentFlag, iNumRef==0?"chroma_weight_l0_flag[i]":"chroma_weight_l1_flag[i]" );
2766	uiTotalSignalledWeightFlags += 2*wp[COMPONENT_Cb].bPresentFlag;
2767	}
2768	}
2769
2770	for ( Int iRefIdx=0 ; iRefIdx<pcSlice->getNumRefIdx(eRefPicList) ; iRefIdx++ )
2771	{
2772	pcSlice->getWpScaling(eRefPicList, iRefIdx, wp);
2773	if ( wp[COMPONENT_Y].bPresentFlag )
2774	{
2775	Int iDeltaWeight = (wp[COMPONENT_Y].iWeight - (1<<wp[COMPONENT_Y].uiLog2WeightDenom));
2776	WRITE_SVLC( iDeltaWeight, iNumRef==0?"delta_luma_weight_l0[i]":"delta_luma_weight_l1[i]" );
2777	WRITE_SVLC( wp[COMPONENT_Y].iOffset, iNumRef==0?"luma_offset_l0[i]":"luma_offset_l1[i]" );
2778	}
2779
2780	if ( bChroma )
2781	{
2782	if ( wp[COMPONENT_Cb].bPresentFlag )
2783	{
2784	for ( Int j = COMPONENT_Cb ; j < numberValidComponents ; j++ )
2785	{
2786	assert(wp[COMPONENT_Cb].uiLog2WeightDenom == wp[COMPONENT_Cr].uiLog2WeightDenom);
2787	Int iDeltaWeight = (wp[j].iWeight - (1<<wp[COMPONENT_Cb].uiLog2WeightDenom));
2788	WRITE_SVLC( iDeltaWeight, iNumRef==0?"delta_chroma_weight_l0[i]":"delta_chroma_weight_l1[i]" );
2789
2790	Int range=pcSlice->getSPS()->getSpsRangeExtension().getHighPrecisionOffsetsEnabledFlag() ? (1<<pcSlice->getSPS()->getBitDepth(CHANNEL_TYPE_CHROMA))/2 : 128;
2791	Int pred = ( range - ( ( range*wp[j].iWeight)>>(wp[j].uiLog2WeightDenom) ) );
2792	Int iDeltaChroma = (wp[j].iOffset - pred);
2793	WRITE_SVLC( iDeltaChroma, iNumRef==0?"delta_chroma_offset_l0[i]":"delta_chroma_offset_l1[i]" );
2794	}
2795	}
2796	}
2797	}
2798	}
2799	assert(uiTotalSignalledWeightFlags<=24);
2800	}
2801	}
2802
2803	/** code quantization matrix
2804	* \param scalingList quantization matrix information
2805	*/
2806	Void TEncCavlc::codeScalingList( const TComScalingList &scalingList )
2807	{
2808	//for each size
2809	for(UInt sizeId = 0; sizeId < SCALING_LIST_SIZE_NUM; sizeId++)
2810	{
2811	const Int predListStep = (sizeId == SCALING_LIST_32x32? (SCALING_LIST_NUM/NUMBER_OF_PREDICTION_MODES) : 1); // if 32x32, skip over chroma entries.
2812
2813	for(UInt listId = 0; listId < SCALING_LIST_NUM; listId+=predListStep)
2814	{
2815	Bool scalingListPredModeFlag = scalingList.getScalingListPredModeFlag(sizeId, listId);
2816	WRITE_FLAG( scalingListPredModeFlag, "scaling_list_pred_mode_flag" );
2817	if(!scalingListPredModeFlag)// Copy Mode
2818	{
2819	if (sizeId == SCALING_LIST_32x32)
2820	{
2821	// adjust the code, to cope with the missing chroma entries
2822	WRITE_UVLC( ((Int)listId - (Int)scalingList.getRefMatrixId (sizeId,listId)) / (SCALING_LIST_NUM/NUMBER_OF_PREDICTION_MODES), "scaling_list_pred_matrix_id_delta");
2823	}
2824	else
2825	{
2826	WRITE_UVLC( (Int)listId - (Int)scalingList.getRefMatrixId (sizeId,listId), "scaling_list_pred_matrix_id_delta");
2827	}
2828	}
2829	else// DPCM Mode
2830	{
2831	xCodeScalingList(&scalingList, sizeId, listId);
2832	}
2833	}
2834	}
2835	return;
2836	}
2837	/** code DPCM
2838	* \param scalingList quantization matrix information
2839	* \param sizeId size index
2840	* \param listId list index
2841	*/
2842	Void TEncCavlc::xCodeScalingList(const TComScalingList* scalingList, UInt sizeId, UInt listId)
2843	{
2844	Int coefNum = min(MAX_MATRIX_COEF_NUM,(Int)g_scalingListSize[sizeId]);
2845	UInt* scan = g_scanOrder[SCAN_UNGROUPED][SCAN_DIAG][sizeId==0 ? 2 : 3][sizeId==0 ? 2 : 3];
2846	Int nextCoef = SCALING_LIST_START_VALUE;
2847	Int data;
2848	const Int *src = scalingList->getScalingListAddress(sizeId, listId);
2849	if( sizeId > SCALING_LIST_8x8 )
2850	{
2851	WRITE_SVLC( scalingList->getScalingListDC(sizeId,listId) - 8, "scaling_list_dc_coef_minus8");
2852	nextCoef = scalingList->getScalingListDC(sizeId,listId);
2853	}
2854	for(Int i=0;i<coefNum;i++)
2855	{
2856	data = src[scan[i]] - nextCoef;
2857	nextCoef = src[scan[i]];
2858	if(data > 127)
2859	{
2860	data = data - 256;
2861	}
2862	if(data < -128)
2863	{
2864	data = data + 256;
2865	}
2866
2867	WRITE_SVLC( data, "scaling_list_delta_coef");
2868	}
2869	}
2870	Bool TEncCavlc::findMatchingLTRP ( TComSlice* pcSlice, UInt *ltrpsIndex, Int ltrpPOC, Bool usedFlag )
2871	{
2872	// Bool state = true, state2 = false;
2873	Int lsb = ltrpPOC & ((1<<pcSlice->getSPS()->getBitsForPOC())-1);
2874	for (Int k = 0; k < pcSlice->getSPS()->getNumLongTermRefPicSPS(); k++)
2875	{
2876	if ( (lsb == pcSlice->getSPS()->getLtRefPicPocLsbSps(k)) && (usedFlag == pcSlice->getSPS()->getUsedByCurrPicLtSPSFlag(k)) )
2877	{
2878	*ltrpsIndex = k;
2879	return true;
2880	}
2881	}
2882	return false;
2883	}
2884
2885	Void TEncCavlc::codeExplicitRdpcmMode( TComTU& /rTu/, const ComponentID /compID/ )
2886	{
2887	assert(0);
2888	}
2889
2890	#if H_3D_INTER_SDC
2891	Void TEncCavlc::codeDeltaDC( TComDataCU* pcCU, UInt uiAbsPartIdx )
2892	{
2893	assert(0);
2894	}
2895
2896	Void TEncCavlc::codeSDCFlag ( TComDataCU* pcCU, UInt uiAbsPartIdx )
2897	{
2898	assert(0);
2899	}
2900
2901	#endif
2902
2903	#if H_3D_DBBP
2904	Void TEncCavlc::codeDBBPFlag ( TComDataCU* pcCU, UInt uiAbsPartIdx )
2905	{
2906	assert(0);
2907	}
2908	#endif
2909
2910
2911	//! \}

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

JCT-3V 3D-HEVC

Context navigation

source: 3DVCSoftware/branches/HTM-14.1-update-dev2-Qualcomm/source/Lib/TLibEncoder/TEncCavlc.cpp @ 1204

Download in other formats: