Context navigation

source: SHVCSoftware/branches/SHM-6-dev/source/Lib/TLibEncoder/TEncCavlc.cpp @ 718

Visit:

Last change on this file since 718 was 705, checked in by seregin, 12 years ago
change the conformance input to be not multiplied by SubWidthC and SubHeightC, it should be a lossless change
Property svn:eol-style set to `native`
File size: 98.5 KB

Line
1	/* The copyright in this software is being made available under the BSD
2	* License, included below. This software may be subject to other third party
3	* and contributor rights, including patent rights, and no such rights are
4	* granted under this license.
5	*
6	* Copyright (c) 2010-2014, ITU/ISO/IEC
7	* All rights reserved.
8	*
9	* Redistribution and use in source and binary forms, with or without
10	* modification, are permitted provided that the following conditions are met:
11	*
12	* * Redistributions of source code must retain the above copyright notice,
13	* this list of conditions and the following disclaimer.
14	* * Redistributions in binary form must reproduce the above copyright notice,
15	* this list of conditions and the following disclaimer in the documentation
16	* and/or other materials provided with the distribution.
17	* * Neither the name of the ITU/ISO/IEC nor the names of its contributors may
18	* be used to endorse or promote products derived from this software without
19	* specific prior written permission.
20	*
21	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
22	* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24	* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS
25	* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
26	* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
27	* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
28	* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
29	* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
30	* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
31	* THE POSSIBILITY OF SUCH DAMAGE.
32	*/
33
34	/** \file TEncCavlc.cpp
35	\brief CAVLC encoder class
36	*/
37
38	#include "../TLibCommon/CommonDef.h"
39	#include "TEncCavlc.h"
40	#include "SEIwrite.h"
41
42	//! \ingroup TLibEncoder
43	//! \{
44
45	#if ENC_DEC_TRACE
46
47	Void xTraceSPSHeader (TComSPS *pSPS)
48	{
49	fprintf( g_hTrace, "=========== Sequence Parameter Set ID: %d ===========\n", pSPS->getSPSId() );
50	}
51
52	Void xTracePPSHeader (TComPPS *pPPS)
53	{
54	fprintf( g_hTrace, "=========== Picture Parameter Set ID: %d ===========\n", pPPS->getPPSId() );
55	}
56
57	Void xTraceSliceHeader (TComSlice *pSlice)
58	{
59	fprintf( g_hTrace, "=========== Slice ===========\n");
60	}
61
62	#endif
63
64
65
66	// ====================================================================================================================
67	// Constructor / destructor / create / destroy
68	// ====================================================================================================================
69
70	TEncCavlc::TEncCavlc()
71	{
72	m_pcBitIf = NULL;
73	m_uiCoeffCost = 0;
74	}
75
76	TEncCavlc::~TEncCavlc()
77	{
78	}
79
80
81	// ====================================================================================================================
82	// Public member functions
83	// ====================================================================================================================
84
85	Void TEncCavlc::resetEntropy()
86	{
87	}
88
89
90	Void TEncCavlc::codeDFFlag(UInt uiCode, const Char *pSymbolName)
91	{
92	WRITE_FLAG(uiCode, pSymbolName);
93	}
94	Void TEncCavlc::codeDFSvlc(Int iCode, const Char *pSymbolName)
95	{
96	WRITE_SVLC(iCode, pSymbolName);
97	}
98
99	Void TEncCavlc::codeShortTermRefPicSet( TComSPS* pcSPS, TComReferencePictureSet* rps, Bool calledFromSliceHeader, Int idx)
100	{
101	#if PRINT_RPS_INFO
102	Int lastBits = getNumberOfWrittenBits();
103	#endif
104	if (idx > 0)
105	{
106	WRITE_FLAG( rps->getInterRPSPrediction(), "inter_ref_pic_set_prediction_flag" ); // inter_RPS_prediction_flag
107	}
108	if (rps->getInterRPSPrediction())
109	{
110	Int deltaRPS = rps->getDeltaRPS();
111	if(calledFromSliceHeader)
112	{
113	WRITE_UVLC( rps->getDeltaRIdxMinus1(), "delta_idx_minus1" ); // delta index of the Reference Picture Set used for prediction minus 1
114	}
115
116	WRITE_CODE( (deltaRPS >=0 ? 0: 1), 1, "delta_rps_sign" ); //delta_rps_sign
117	WRITE_UVLC( abs(deltaRPS) - 1, "abs_delta_rps_minus1"); // absolute delta RPS minus 1
118
119	for(Int j=0; j < rps->getNumRefIdc(); j++)
120	{
121	Int refIdc = rps->getRefIdc(j);
122	WRITE_CODE( (refIdc==1? 1: 0), 1, "used_by_curr_pic_flag" ); //first bit is "1" if Idc is 1
123	if (refIdc != 1)
124	{
125	WRITE_CODE( refIdc>>1, 1, "use_delta_flag" ); //second bit is "1" if Idc is 2, "0" otherwise.
126	}
127	}
128	}
129	else
130	{
131	WRITE_UVLC( rps->getNumberOfNegativePictures(), "num_negative_pics" );
132	WRITE_UVLC( rps->getNumberOfPositivePictures(), "num_positive_pics" );
133	Int prev = 0;
134	for(Int j=0 ; j < rps->getNumberOfNegativePictures(); j++)
135	{
136	WRITE_UVLC( prev-rps->getDeltaPOC(j)-1, "delta_poc_s0_minus1" );
137	prev = rps->getDeltaPOC(j);
138	WRITE_FLAG( rps->getUsed(j), "used_by_curr_pic_s0_flag");
139	}
140	prev = 0;
141	for(Int j=rps->getNumberOfNegativePictures(); j < rps->getNumberOfNegativePictures()+rps->getNumberOfPositivePictures(); j++)
142	{
143	WRITE_UVLC( rps->getDeltaPOC(j)-prev-1, "delta_poc_s1_minus1" );
144	prev = rps->getDeltaPOC(j);
145	WRITE_FLAG( rps->getUsed(j), "used_by_curr_pic_s1_flag" );
146	}
147	}
148
149	#if PRINT_RPS_INFO
150	printf("irps=%d (%2d bits) ", rps->getInterRPSPrediction(), getNumberOfWrittenBits() - lastBits);
151	rps->printDeltaPOC();
152	#endif
153	}
154
155
156	Void TEncCavlc::codePPS( TComPPS* pcPPS
157	#if Q0048_CGS_3D_ASYMLUT
158	, TEnc3DAsymLUT * pc3DAsymLUT
159	#endif
160	)
161	{
162	#if ENC_DEC_TRACE
163	xTracePPSHeader (pcPPS);
164	#endif
165
166	WRITE_UVLC( pcPPS->getPPSId(), "pps_pic_parameter_set_id" );
167	WRITE_UVLC( pcPPS->getSPSId(), "pps_seq_parameter_set_id" );
168	WRITE_FLAG( pcPPS->getDependentSliceSegmentsEnabledFlag() ? 1 : 0, "dependent_slice_segments_enabled_flag" );
169	WRITE_FLAG( pcPPS->getOutputFlagPresentFlag() ? 1 : 0, "output_flag_present_flag" );
170	WRITE_CODE( pcPPS->getNumExtraSliceHeaderBits(), 3, "num_extra_slice_header_bits");
171	WRITE_FLAG( pcPPS->getSignHideFlag(), "sign_data_hiding_flag" );
172	WRITE_FLAG( pcPPS->getCabacInitPresentFlag() ? 1 : 0, "cabac_init_present_flag" );
173	WRITE_UVLC( pcPPS->getNumRefIdxL0DefaultActive()-1, "num_ref_idx_l0_default_active_minus1");
174	WRITE_UVLC( pcPPS->getNumRefIdxL1DefaultActive()-1, "num_ref_idx_l1_default_active_minus1");
175
176	WRITE_SVLC( pcPPS->getPicInitQPMinus26(), "init_qp_minus26");
177	WRITE_FLAG( pcPPS->getConstrainedIntraPred() ? 1 : 0, "constrained_intra_pred_flag" );
178	WRITE_FLAG( pcPPS->getUseTransformSkip() ? 1 : 0, "transform_skip_enabled_flag" );
179	WRITE_FLAG( pcPPS->getUseDQP() ? 1 : 0, "cu_qp_delta_enabled_flag" );
180	if ( pcPPS->getUseDQP() )
181	{
182	WRITE_UVLC( pcPPS->getMaxCuDQPDepth(), "diff_cu_qp_delta_depth" );
183	}
184	WRITE_SVLC( pcPPS->getChromaCbQpOffset(), "pps_cb_qp_offset" );
185	WRITE_SVLC( pcPPS->getChromaCrQpOffset(), "pps_cr_qp_offset" );
186	WRITE_FLAG( pcPPS->getSliceChromaQpFlag() ? 1 : 0, "pps_slice_chroma_qp_offsets_present_flag" );
187
188	WRITE_FLAG( pcPPS->getUseWP() ? 1 : 0, "weighted_pred_flag" ); // Use of Weighting Prediction (P_SLICE)
189	WRITE_FLAG( pcPPS->getWPBiPred() ? 1 : 0, "weighted_bipred_flag" ); // Use of Weighting Bi-Prediction (B_SLICE)
190	WRITE_FLAG( pcPPS->getTransquantBypassEnableFlag() ? 1 : 0, "transquant_bypass_enable_flag" );
191	WRITE_FLAG( pcPPS->getTilesEnabledFlag() ? 1 : 0, "tiles_enabled_flag" );
192	WRITE_FLAG( pcPPS->getEntropyCodingSyncEnabledFlag() ? 1 : 0, "entropy_coding_sync_enabled_flag" );
193	if( pcPPS->getTilesEnabledFlag() )
194	{
195	WRITE_UVLC( pcPPS->getNumColumnsMinus1(), "num_tile_columns_minus1" );
196	WRITE_UVLC( pcPPS->getNumRowsMinus1(), "num_tile_rows_minus1" );
197	WRITE_FLAG( pcPPS->getUniformSpacingFlag(), "uniform_spacing_flag" );
198	if( pcPPS->getUniformSpacingFlag() == 0 )
199	{
200	for(UInt i=0; i<pcPPS->getNumColumnsMinus1(); i++)
201	{
202	WRITE_UVLC( pcPPS->getColumnWidth(i)-1, "column_width_minus1" );
203	}
204	for(UInt i=0; i<pcPPS->getNumRowsMinus1(); i++)
205	{
206	WRITE_UVLC( pcPPS->getRowHeight(i)-1, "row_height_minus1" );
207	}
208	}
209	if(pcPPS->getNumColumnsMinus1() !=0 \|\| pcPPS->getNumRowsMinus1() !=0)
210	{
211	WRITE_FLAG( pcPPS->getLoopFilterAcrossTilesEnabledFlag()?1 : 0, "loop_filter_across_tiles_enabled_flag");
212	}
213	}
214	WRITE_FLAG( pcPPS->getLoopFilterAcrossSlicesEnabledFlag()?1 : 0, "loop_filter_across_slices_enabled_flag");
215	WRITE_FLAG( pcPPS->getDeblockingFilterControlPresentFlag()?1 : 0, "deblocking_filter_control_present_flag");
216	if(pcPPS->getDeblockingFilterControlPresentFlag())
217	{
218	WRITE_FLAG( pcPPS->getDeblockingFilterOverrideEnabledFlag() ? 1 : 0, "deblocking_filter_override_enabled_flag" );
219	WRITE_FLAG( pcPPS->getPicDisableDeblockingFilterFlag() ? 1 : 0, "pps_disable_deblocking_filter_flag" );
220	if(!pcPPS->getPicDisableDeblockingFilterFlag())
221	{
222	WRITE_SVLC( pcPPS->getDeblockingFilterBetaOffsetDiv2(), "pps_beta_offset_div2" );
223	WRITE_SVLC( pcPPS->getDeblockingFilterTcOffsetDiv2(), "pps_tc_offset_div2" );
224	}
225	}
226
227	#if SCALINGLIST_INFERRING
228	if( pcPPS->getLayerId() > 0 )
229	{
230	WRITE_FLAG( pcPPS->getInferScalingListFlag() ? 1 : 0, "pps_infer_scaling_list_flag" );
231	}
232
233	if( pcPPS->getInferScalingListFlag() )
234	{
235	// The value of pps_scaling_list_ref_layer_id shall be in the range of 0 to 62, inclusive
236	assert( pcPPS->getScalingListRefLayerId() <= 62 );
237
238	WRITE_UVLC( pcPPS->getScalingListRefLayerId(), "pps_scaling_list_ref_layer_id" );
239	}
240	else
241	{
242	#endif
243
244	WRITE_FLAG( pcPPS->getScalingListPresentFlag() ? 1 : 0, "pps_scaling_list_data_present_flag" );
245	if( pcPPS->getScalingListPresentFlag() )
246	{
247	codeScalingList( m_pcSlice->getScalingList() );
248	}
249
250	#if SCALINGLIST_INFERRING
251	}
252	#endif
253
254	WRITE_FLAG( pcPPS->getListsModificationPresentFlag(), "lists_modification_present_flag");
255	WRITE_UVLC( pcPPS->getLog2ParallelMergeLevelMinus2(), "log2_parallel_merge_level_minus2");
256	WRITE_FLAG( pcPPS->getSliceHeaderExtensionPresentFlag() ? 1 : 0, "slice_segment_header_extension_present_flag");
257	#if P0166_MODIFIED_PPS_EXTENSION
258	WRITE_FLAG( 1, "pps_extension_flag" );
259	if( 1 ) //pps_extension_flag
260	{
261	#if !POC_RESET_IDC
262	UInt ppsExtensionTypeFlag[8] = { 0, 1, 0, 0, 0, 0, 0, 0 };
263	#else
264	UInt ppsExtensionTypeFlag[8] = { 1, 0, 0, 0, 0, 0, 0, 0 };
265	#endif
266	for (UInt i = 0; i < 8; i++)
267	{
268	WRITE_FLAG( ppsExtensionTypeFlag[i], "pps_extension_type_flag" );
269	}
270	#if POC_RESET_IDC
271	if( ppsExtensionTypeFlag[0] )
272	{
273	WRITE_FLAG( pcPPS->getPocResetInfoPresentFlag() ? 1 : 0, "poc_reset_info_present_flag" );
274	#if Q0048_CGS_3D_ASYMLUT
275	UInt uiPos = getNumberOfWrittenBits();
276	WRITE_FLAG( pcPPS->getCGSFlag() , "colour_mapping_enabled_flag" );
277	if( pcPPS->getCGSFlag() )
278	{
279	assert( pc3DAsymLUT != NULL );
280	xCode3DAsymLUT( pc3DAsymLUT );
281	}
282	pc3DAsymLUT->setPPSBit( getNumberOfWrittenBits() - uiPos );
283	#endif
284	#endif
285	}
286	}
287	#else
288	WRITE_FLAG( 0, "pps_extension_flag" );
289	#endif
290	}
291
292	Void TEncCavlc::codeVUI( TComVUI pcVUI, TComSPS pcSPS )
293	{
294	#if ENC_DEC_TRACE
295	fprintf( g_hTrace, "----------- vui_parameters -----------\n");
296	#endif
297	WRITE_FLAG(pcVUI->getAspectRatioInfoPresentFlag(), "aspect_ratio_info_present_flag");
298	if (pcVUI->getAspectRatioInfoPresentFlag())
299	{
300	WRITE_CODE(pcVUI->getAspectRatioIdc(), 8, "aspect_ratio_idc" );
301	if (pcVUI->getAspectRatioIdc() == 255)
302	{
303	WRITE_CODE(pcVUI->getSarWidth(), 16, "sar_width");
304	WRITE_CODE(pcVUI->getSarHeight(), 16, "sar_height");
305	}
306	}
307	WRITE_FLAG(pcVUI->getOverscanInfoPresentFlag(), "overscan_info_present_flag");
308	if (pcVUI->getOverscanInfoPresentFlag())
309	{
310	WRITE_FLAG(pcVUI->getOverscanAppropriateFlag(), "overscan_appropriate_flag");
311	}
312	WRITE_FLAG(pcVUI->getVideoSignalTypePresentFlag(), "video_signal_type_present_flag");
313	if (pcVUI->getVideoSignalTypePresentFlag())
314	{
315	WRITE_CODE(pcVUI->getVideoFormat(), 3, "video_format");
316	WRITE_FLAG(pcVUI->getVideoFullRangeFlag(), "video_full_range_flag");
317	WRITE_FLAG(pcVUI->getColourDescriptionPresentFlag(), "colour_description_present_flag");
318	if (pcVUI->getColourDescriptionPresentFlag())
319	{
320	WRITE_CODE(pcVUI->getColourPrimaries(), 8, "colour_primaries");
321	WRITE_CODE(pcVUI->getTransferCharacteristics(), 8, "transfer_characteristics");
322	WRITE_CODE(pcVUI->getMatrixCoefficients(), 8, "matrix_coefficients");
323	}
324	}
325
326	WRITE_FLAG(pcVUI->getChromaLocInfoPresentFlag(), "chroma_loc_info_present_flag");
327	if (pcVUI->getChromaLocInfoPresentFlag())
328	{
329	WRITE_UVLC(pcVUI->getChromaSampleLocTypeTopField(), "chroma_sample_loc_type_top_field");
330	WRITE_UVLC(pcVUI->getChromaSampleLocTypeBottomField(), "chroma_sample_loc_type_bottom_field");
331	}
332
333	WRITE_FLAG(pcVUI->getNeutralChromaIndicationFlag(), "neutral_chroma_indication_flag");
334	WRITE_FLAG(pcVUI->getFieldSeqFlag(), "field_seq_flag");
335	WRITE_FLAG(pcVUI->getFrameFieldInfoPresentFlag(), "frame_field_info_present_flag");
336
337	Window defaultDisplayWindow = pcVUI->getDefaultDisplayWindow();
338	WRITE_FLAG(defaultDisplayWindow.getWindowEnabledFlag(), "default_display_window_flag");
339	if( defaultDisplayWindow.getWindowEnabledFlag() )
340	{
341	WRITE_UVLC(defaultDisplayWindow.getWindowLeftOffset(), "def_disp_win_left_offset");
342	WRITE_UVLC(defaultDisplayWindow.getWindowRightOffset(), "def_disp_win_right_offset");
343	WRITE_UVLC(defaultDisplayWindow.getWindowTopOffset(), "def_disp_win_top_offset");
344	WRITE_UVLC(defaultDisplayWindow.getWindowBottomOffset(), "def_disp_win_bottom_offset");
345	}
346	TimingInfo *timingInfo = pcVUI->getTimingInfo();
347	WRITE_FLAG(timingInfo->getTimingInfoPresentFlag(), "vui_timing_info_present_flag");
348	if(timingInfo->getTimingInfoPresentFlag())
349	{
350	WRITE_CODE(timingInfo->getNumUnitsInTick(), 32, "vui_num_units_in_tick");
351	WRITE_CODE(timingInfo->getTimeScale(), 32, "vui_time_scale");
352	WRITE_FLAG(timingInfo->getPocProportionalToTimingFlag(), "vui_poc_proportional_to_timing_flag");
353	if(timingInfo->getPocProportionalToTimingFlag())
354	{
355	WRITE_UVLC(timingInfo->getNumTicksPocDiffOneMinus1(), "vui_num_ticks_poc_diff_one_minus1");
356	}
357	WRITE_FLAG(pcVUI->getHrdParametersPresentFlag(), "hrd_parameters_present_flag");
358	if( pcVUI->getHrdParametersPresentFlag() )
359	{
360	codeHrdParameters(pcVUI->getHrdParameters(), 1, pcSPS->getMaxTLayers() - 1 );
361	}
362	}
363
364	WRITE_FLAG(pcVUI->getBitstreamRestrictionFlag(), "bitstream_restriction_flag");
365	if (pcVUI->getBitstreamRestrictionFlag())
366	{
367	WRITE_FLAG(pcVUI->getTilesFixedStructureFlag(), "tiles_fixed_structure_flag");
368	WRITE_FLAG(pcVUI->getMotionVectorsOverPicBoundariesFlag(), "motion_vectors_over_pic_boundaries_flag");
369	WRITE_FLAG(pcVUI->getRestrictedRefPicListsFlag(), "restricted_ref_pic_lists_flag");
370	WRITE_UVLC(pcVUI->getMinSpatialSegmentationIdc(), "min_spatial_segmentation_idc");
371	WRITE_UVLC(pcVUI->getMaxBytesPerPicDenom(), "max_bytes_per_pic_denom");
372	WRITE_UVLC(pcVUI->getMaxBitsPerMinCuDenom(), "max_bits_per_mincu_denom");
373	WRITE_UVLC(pcVUI->getLog2MaxMvLengthHorizontal(), "log2_max_mv_length_horizontal");
374	WRITE_UVLC(pcVUI->getLog2MaxMvLengthVertical(), "log2_max_mv_length_vertical");
375	}
376	}
377
378	Void TEncCavlc::codeHrdParameters( TComHRD *hrd, Bool commonInfPresentFlag, UInt maxNumSubLayersMinus1 )
379	{
380	if( commonInfPresentFlag )
381	{
382	WRITE_FLAG( hrd->getNalHrdParametersPresentFlag() ? 1 : 0 , "nal_hrd_parameters_present_flag" );
383	WRITE_FLAG( hrd->getVclHrdParametersPresentFlag() ? 1 : 0 , "vcl_hrd_parameters_present_flag" );
384	if( hrd->getNalHrdParametersPresentFlag() \|\| hrd->getVclHrdParametersPresentFlag() )
385	{
386	WRITE_FLAG( hrd->getSubPicCpbParamsPresentFlag() ? 1 : 0, "sub_pic_cpb_params_present_flag" );
387	if( hrd->getSubPicCpbParamsPresentFlag() )
388	{
389	WRITE_CODE( hrd->getTickDivisorMinus2(), 8, "tick_divisor_minus2" );
390	WRITE_CODE( hrd->getDuCpbRemovalDelayLengthMinus1(), 5, "du_cpb_removal_delay_length_minus1" );
391	WRITE_FLAG( hrd->getSubPicCpbParamsInPicTimingSEIFlag() ? 1 : 0, "sub_pic_cpb_params_in_pic_timing_sei_flag" );
392	WRITE_CODE( hrd->getDpbOutputDelayDuLengthMinus1(), 5, "dpb_output_delay_du_length_minus1" );
393	}
394	WRITE_CODE( hrd->getBitRateScale(), 4, "bit_rate_scale" );
395	WRITE_CODE( hrd->getCpbSizeScale(), 4, "cpb_size_scale" );
396	if( hrd->getSubPicCpbParamsPresentFlag() )
397	{
398	WRITE_CODE( hrd->getDuCpbSizeScale(), 4, "du_cpb_size_scale" );
399	}
400	WRITE_CODE( hrd->getInitialCpbRemovalDelayLengthMinus1(), 5, "initial_cpb_removal_delay_length_minus1" );
401	WRITE_CODE( hrd->getCpbRemovalDelayLengthMinus1(), 5, "au_cpb_removal_delay_length_minus1" );
402	WRITE_CODE( hrd->getDpbOutputDelayLengthMinus1(), 5, "dpb_output_delay_length_minus1" );
403	}
404	}
405	Int i, j, nalOrVcl;
406	for( i = 0; i <= maxNumSubLayersMinus1; i ++ )
407	{
408	WRITE_FLAG( hrd->getFixedPicRateFlag( i ) ? 1 : 0, "fixed_pic_rate_general_flag");
409	if( !hrd->getFixedPicRateFlag( i ) )
410	{
411	WRITE_FLAG( hrd->getFixedPicRateWithinCvsFlag( i ) ? 1 : 0, "fixed_pic_rate_within_cvs_flag");
412	}
413	else
414	{
415	hrd->setFixedPicRateWithinCvsFlag( i, true );
416	}
417	if( hrd->getFixedPicRateWithinCvsFlag( i ) )
418	{
419	WRITE_UVLC( hrd->getPicDurationInTcMinus1( i ), "elemental_duration_in_tc_minus1");
420	}
421	else
422	{
423	WRITE_FLAG( hrd->getLowDelayHrdFlag( i ) ? 1 : 0, "low_delay_hrd_flag");
424	}
425	if (!hrd->getLowDelayHrdFlag( i ))
426	{
427	WRITE_UVLC( hrd->getCpbCntMinus1( i ), "cpb_cnt_minus1");
428	}
429
430	for( nalOrVcl = 0; nalOrVcl < 2; nalOrVcl ++ )
431	{
432	if( ( ( nalOrVcl == 0 ) && ( hrd->getNalHrdParametersPresentFlag() ) ) \|\|
433	( ( nalOrVcl == 1 ) && ( hrd->getVclHrdParametersPresentFlag() ) ) )
434	{
435	for( j = 0; j <= ( hrd->getCpbCntMinus1( i ) ); j ++ )
436	{
437	WRITE_UVLC( hrd->getBitRateValueMinus1( i, j, nalOrVcl ), "bit_rate_value_minus1");
438	WRITE_UVLC( hrd->getCpbSizeValueMinus1( i, j, nalOrVcl ), "cpb_size_value_minus1");
439	if( hrd->getSubPicCpbParamsPresentFlag() )
440	{
441	WRITE_UVLC( hrd->getDuCpbSizeValueMinus1( i, j, nalOrVcl ), "cpb_size_du_value_minus1");
442	WRITE_UVLC( hrd->getDuBitRateValueMinus1( i, j, nalOrVcl ), "bit_rate_du_value_minus1");
443	}
444	WRITE_FLAG( hrd->getCbrFlag( i, j, nalOrVcl ) ? 1 : 0, "cbr_flag");
445	}
446	}
447	}
448	}
449	}
450
451	Void TEncCavlc::codeSPS( TComSPS* pcSPS )
452	{
453	#if ENC_DEC_TRACE
454	xTraceSPSHeader (pcSPS);
455	#endif
456	WRITE_CODE( pcSPS->getVPSId (), 4, "sps_video_parameter_set_id" );
457	#if SVC_EXTENSION
458	if(pcSPS->getLayerId() == 0)
459	{
460	#endif
461	WRITE_CODE( pcSPS->getMaxTLayers() - 1, 3, "sps_max_sub_layers_minus1" );
462	WRITE_FLAG( pcSPS->getTemporalIdNestingFlag() ? 1 : 0, "sps_temporal_id_nesting_flag" );
463	#if SVC_EXTENSION
464	}
465	#endif
466	#ifdef SPS_PTL_FIX
467	if (pcSPS->getLayerId() == 0)
468	{
469	codePTL(pcSPS->getPTL(), 1, pcSPS->getMaxTLayers() - 1);
470	}
471	#else
472	codePTL(pcSPS->getPTL(), 1, pcSPS->getMaxTLayers() - 1);
473	#endif
474	WRITE_UVLC( pcSPS->getSPSId (), "sps_seq_parameter_set_id" );
475	#if REPN_FORMAT_IN_VPS
476	if( pcSPS->getLayerId() > 0 )
477	{
478	WRITE_FLAG( pcSPS->getUpdateRepFormatFlag(), "update_rep_format_flag" );
479	}
480	#if O0096_REP_FORMAT_INDEX
481	if( pcSPS->getLayerId() == 0 )
482	#else
483	if( pcSPS->getLayerId() == 0 \|\| pcSPS->getUpdateRepFormatFlag() )
484	#endif
485	{
486	#endif
487	WRITE_UVLC( pcSPS->getChromaFormatIdc (), "chroma_format_idc" );
488	assert(pcSPS->getChromaFormatIdc () == 1);
489	// in the first version chroma_format_idc can only be equal to 1 (4:2:0)
490	if( pcSPS->getChromaFormatIdc () == 3 )
491	{
492	WRITE_FLAG( 0, "separate_colour_plane_flag");
493	}
494
495	WRITE_UVLC( pcSPS->getPicWidthInLumaSamples (), "pic_width_in_luma_samples" );
496	WRITE_UVLC( pcSPS->getPicHeightInLumaSamples(), "pic_height_in_luma_samples" );
497	#if REPN_FORMAT_IN_VPS
498	}
499	#if O0096_REP_FORMAT_INDEX
500	else if (pcSPS->getUpdateRepFormatFlag())
501	{
502	WRITE_CODE( pcSPS->getUpdateRepFormatIndex(), 8, "update_rep_format_index");
503	}
504	#endif
505	#endif
506	Window conf = pcSPS->getConformanceWindow();
507
508	WRITE_FLAG( conf.getWindowEnabledFlag(), "conformance_window_flag" );
509	if (conf.getWindowEnabledFlag())
510	{
511	#if REPN_FORMAT_IN_VPS
512	WRITE_UVLC( conf.getWindowLeftOffset(), "conf_win_left_offset" );
513	WRITE_UVLC( conf.getWindowRightOffset(), "conf_win_right_offset" );
514	WRITE_UVLC( conf.getWindowTopOffset(), "conf_win_top_offset" );
515	WRITE_UVLC( conf.getWindowBottomOffset(), "conf_win_bottom_offset" );
516	#else
517	WRITE_UVLC( conf.getWindowLeftOffset() / TComSPS::getWinUnitX(pcSPS->getChromaFormatIdc() ), "conf_win_left_offset" );
518	WRITE_UVLC( conf.getWindowRightOffset() / TComSPS::getWinUnitX(pcSPS->getChromaFormatIdc() ), "conf_win_right_offset" );
519	WRITE_UVLC( conf.getWindowTopOffset() / TComSPS::getWinUnitY(pcSPS->getChromaFormatIdc() ), "conf_win_top_offset" );
520	WRITE_UVLC( conf.getWindowBottomOffset() / TComSPS::getWinUnitY(pcSPS->getChromaFormatIdc() ), "conf_win_bottom_offset" );
521	#endif
522	}
523
524	#if REPN_FORMAT_IN_VPS
525	#if O0096_REP_FORMAT_INDEX
526	if( pcSPS->getLayerId() == 0 )
527	#else
528	if( pcSPS->getLayerId() == 0 \|\| pcSPS->getUpdateRepFormatFlag() )
529	#endif
530	{
531	assert( pcSPS->getBitDepthY() >= 8 );
532	assert( pcSPS->getBitDepthC() >= 8 );
533	#endif
534	WRITE_UVLC( pcSPS->getBitDepthY() - 8, "bit_depth_luma_minus8" );
535	WRITE_UVLC( pcSPS->getBitDepthC() - 8, "bit_depth_chroma_minus8" );
536	#if REPN_FORMAT_IN_VPS
537	}
538	#endif
539	WRITE_UVLC( pcSPS->getBitsForPOC()-4, "log2_max_pic_order_cnt_lsb_minus4" );
540
541	#if SPS_DPB_PARAMS
542	if( pcSPS->getLayerId() == 0 )
543	{
544	#endif
545	const Bool subLayerOrderingInfoPresentFlag = 1;
546	WRITE_FLAG(subLayerOrderingInfoPresentFlag, "sps_sub_layer_ordering_info_present_flag");
547	for(UInt i=0; i <= pcSPS->getMaxTLayers()-1; i++)
548	{
549	WRITE_UVLC( pcSPS->getMaxDecPicBuffering(i) - 1, "sps_max_dec_pic_buffering_minus1[i]" );
550	WRITE_UVLC( pcSPS->getNumReorderPics(i), "sps_num_reorder_pics[i]" );
551	WRITE_UVLC( pcSPS->getMaxLatencyIncrease(i), "sps_max_latency_increase_plus1[i]" );
552	if (!subLayerOrderingInfoPresentFlag)
553	{
554	break;
555	}
556	}
557	#if SPS_DPB_PARAMS
558	}
559	#endif
560	assert( pcSPS->getMaxCUWidth() == pcSPS->getMaxCUHeight() );
561
562	WRITE_UVLC( pcSPS->getLog2MinCodingBlockSize() - 3, "log2_min_coding_block_size_minus3" );
563	WRITE_UVLC( pcSPS->getLog2DiffMaxMinCodingBlockSize(), "log2_diff_max_min_coding_block_size" );
564	WRITE_UVLC( pcSPS->getQuadtreeTULog2MinSize() - 2, "log2_min_transform_block_size_minus2" );
565	WRITE_UVLC( pcSPS->getQuadtreeTULog2MaxSize() - pcSPS->getQuadtreeTULog2MinSize(), "log2_diff_max_min_transform_block_size" );
566	WRITE_UVLC( pcSPS->getQuadtreeTUMaxDepthInter() - 1, "max_transform_hierarchy_depth_inter" );
567	WRITE_UVLC( pcSPS->getQuadtreeTUMaxDepthIntra() - 1, "max_transform_hierarchy_depth_intra" );
568	WRITE_FLAG( pcSPS->getScalingListFlag() ? 1 : 0, "scaling_list_enabled_flag" );
569	if(pcSPS->getScalingListFlag())
570	{
571	#if SCALINGLIST_INFERRING
572	if( pcSPS->getLayerId() > 0 )
573	{
574	WRITE_FLAG( pcSPS->getInferScalingListFlag() ? 1 : 0, "sps_infer_scaling_list_flag" );
575	}
576
577	if( pcSPS->getInferScalingListFlag() )
578	{
579	// The value of pps_scaling_list_ref_layer_id shall be in the range of 0 to 62, inclusive
580	assert( pcSPS->getScalingListRefLayerId() <= 62 );
581
582	WRITE_UVLC( pcSPS->getScalingListRefLayerId(), "sps_scaling_list_ref_layer_id" );
583	}
584	else
585	{
586	#endif
587	WRITE_FLAG( pcSPS->getScalingListPresentFlag() ? 1 : 0, "sps_scaling_list_data_present_flag" );
588	if(pcSPS->getScalingListPresentFlag())
589	{
590	codeScalingList( m_pcSlice->getScalingList() );
591	}
592	#if SCALINGLIST_INFERRING
593	}
594	#endif
595	}
596	WRITE_FLAG( pcSPS->getUseAMP() ? 1 : 0, "amp_enabled_flag" );
597	WRITE_FLAG( pcSPS->getUseSAO() ? 1 : 0, "sample_adaptive_offset_enabled_flag");
598
599	WRITE_FLAG( pcSPS->getUsePCM() ? 1 : 0, "pcm_enabled_flag");
600	if( pcSPS->getUsePCM() )
601	{
602	WRITE_CODE( pcSPS->getPCMBitDepthLuma() - 1, 4, "pcm_sample_bit_depth_luma_minus1" );
603	WRITE_CODE( pcSPS->getPCMBitDepthChroma() - 1, 4, "pcm_sample_bit_depth_chroma_minus1" );
604	WRITE_UVLC( pcSPS->getPCMLog2MinSize() - 3, "log2_min_pcm_luma_coding_block_size_minus3" );
605	WRITE_UVLC( pcSPS->getPCMLog2MaxSize() - pcSPS->getPCMLog2MinSize(), "log2_diff_max_min_pcm_luma_coding_block_size" );
606	WRITE_FLAG( pcSPS->getPCMFilterDisableFlag()?1 : 0, "pcm_loop_filter_disable_flag");
607	}
608
609	assert( pcSPS->getMaxTLayers() > 0 );
610
611	TComRPSList* rpsList = pcSPS->getRPSList();
612	TComReferencePictureSet* rps;
613
614	WRITE_UVLC(rpsList->getNumberOfReferencePictureSets(), "num_short_term_ref_pic_sets" );
615	for(Int i=0; i < rpsList->getNumberOfReferencePictureSets(); i++)
616	{
617	rps = rpsList->getReferencePictureSet(i);
618	codeShortTermRefPicSet(pcSPS,rps,false, i);
619	}
620	WRITE_FLAG( pcSPS->getLongTermRefsPresent() ? 1 : 0, "long_term_ref_pics_present_flag" );
621	if (pcSPS->getLongTermRefsPresent())
622	{
623	WRITE_UVLC(pcSPS->getNumLongTermRefPicSPS(), "num_long_term_ref_pic_sps" );
624	for (UInt k = 0; k < pcSPS->getNumLongTermRefPicSPS(); k++)
625	{
626	WRITE_CODE( pcSPS->getLtRefPicPocLsbSps(k), pcSPS->getBitsForPOC(), "lt_ref_pic_poc_lsb_sps");
627	WRITE_FLAG( pcSPS->getUsedByCurrPicLtSPSFlag(k), "used_by_curr_pic_lt_sps_flag");
628	}
629	}
630	WRITE_FLAG( pcSPS->getTMVPFlagsPresent() ? 1 : 0, "sps_temporal_mvp_enable_flag" );
631
632	WRITE_FLAG( pcSPS->getUseStrongIntraSmoothing(), "sps_strong_intra_smoothing_enable_flag" );
633
634	WRITE_FLAG( pcSPS->getVuiParametersPresentFlag(), "vui_parameters_present_flag" );
635	if (pcSPS->getVuiParametersPresentFlag())
636	{
637	codeVUI(pcSPS->getVuiParameters(), pcSPS);
638	}
639
640	#if SPS_EXTENSION
641	WRITE_FLAG( 1, "sps_extension_flag" );
642	if( 1 ) // if( sps_extension_flag )
643	{
644	#if O0142_CONDITIONAL_SPS_EXTENSION
645	UInt spsExtensionTypeFlag[8] = { 0, 1, 0, 0, 0, 0, 0, 0 };
646	for (UInt i = 0; i < 8; i++)
647	{
648	WRITE_FLAG( spsExtensionTypeFlag[i], "sps_extension_type_flag" );
649	}
650	if (spsExtensionTypeFlag[1])
651	{
652	codeSPSExtension( pcSPS );
653	}
654	#else
655	codeSPSExtension( pcSPS );
656	WRITE_FLAG( 0, "sps_extension2_flag" );
657	#endif
658	}
659	#else
660	WRITE_FLAG( 0, "sps_extension_flag" );
661	#endif
662	}
663	#if SPS_EXTENSION
664	Void TEncCavlc::codeSPSExtension( TComSPS* pcSPS )
665	{
666	// more syntax elements to be written here
667
668	// Vertical MV component restriction is not used in SHVC CTC
669	WRITE_FLAG( 0, "inter_view_mv_vert_constraint_flag" );
670
671	if( pcSPS->getLayerId() > 0 )
672	{
673	WRITE_UVLC( pcSPS->getNumScaledRefLayerOffsets(), "num_scaled_ref_layer_offsets" );
674	for(Int i = 0; i < pcSPS->getNumScaledRefLayerOffsets(); i++)
675	{
676	Window scaledWindow = pcSPS->getScaledRefLayerWindow(i);
677	#if O0098_SCALED_REF_LAYER_ID
678	WRITE_CODE( pcSPS->getScaledRefLayerId(i), 6, "scaled_ref_layer_id" );
679	#endif
680	WRITE_SVLC( scaledWindow.getWindowLeftOffset() >> 1, "scaled_ref_layer_left_offset" );
681	WRITE_SVLC( scaledWindow.getWindowTopOffset() >> 1, "scaled_ref_layer_top_offset" );
682	WRITE_SVLC( scaledWindow.getWindowRightOffset() >> 1, "scaled_ref_layer_right_offset" );
683	WRITE_SVLC( scaledWindow.getWindowBottomOffset() >> 1, "scaled_ref_layer_bottom_offset" );
684	#if P0312_VERT_PHASE_ADJ
685	WRITE_FLAG( scaledWindow.getVertPhasePositionEnableFlag(), "vert_phase_position_enable_flag" );
686	#endif
687	}
688	}
689	}
690	#endif
691	Void TEncCavlc::codeVPS( TComVPS* pcVPS )
692	{
693	#if !P0125_REVERT_VPS_EXTN_OFFSET_TO_RESERVED
694	#if VPS_EXTN_OFFSET_CALC
695	UInt numBytesInVps = this->m_pcBitIf->getNumberOfWrittenBits();
696	#endif
697	#endif
698	#if !P0307_REMOVE_VPS_VUI_OFFSET
699	#if VPS_VUI_OFFSET
700	m_vpsVuiCounter = this->m_pcBitIf->getNumberOfWrittenBits();
701	#endif
702	#endif
703	WRITE_CODE( pcVPS->getVPSId(), 4, "vps_video_parameter_set_id" );
704	WRITE_CODE( 3, 2, "vps_reserved_three_2bits" );
705	#if VPS_RENAME
706	WRITE_CODE( pcVPS->getMaxLayers() - 1, 6, "vps_max_layers_minus1" );
707	#else
708	WRITE_CODE( 0, 6, "vps_reserved_zero_6bits" );
709	#endif
710	WRITE_CODE( pcVPS->getMaxTLayers() - 1, 3, "vps_max_sub_layers_minus1" );
711	WRITE_FLAG( pcVPS->getTemporalNestingFlag(), "vps_temporal_id_nesting_flag" );
712	assert (pcVPS->getMaxTLayers()>1\|\|pcVPS->getTemporalNestingFlag());
713	#if !P0125_REVERT_VPS_EXTN_OFFSET_TO_RESERVED
714	#if VPS_EXTN_OFFSET
715	WRITE_CODE( pcVPS->getExtensionOffset(), 16, "vps_extension_offset" );
716	#else
717	WRITE_CODE( 0xffff, 16, "vps_reserved_ffff_16bits" );
718	#endif
719	#else
720	WRITE_CODE( 0xffff, 16, "vps_reserved_ffff_16bits" );
721	#endif
722	codePTL( pcVPS->getPTL(), true, pcVPS->getMaxTLayers() - 1 );
723	const Bool subLayerOrderingInfoPresentFlag = 1;
724	WRITE_FLAG(subLayerOrderingInfoPresentFlag, "vps_sub_layer_ordering_info_present_flag");
725	for(UInt i=0; i <= pcVPS->getMaxTLayers()-1; i++)
726	{
727	WRITE_UVLC( pcVPS->getMaxDecPicBuffering(i) - 1, "vps_max_dec_pic_buffering_minus1[i]" );
728	WRITE_UVLC( pcVPS->getNumReorderPics(i), "vps_num_reorder_pics[i]" );
729	WRITE_UVLC( pcVPS->getMaxLatencyIncrease(i), "vps_max_latency_increase_plus1[i]" );
730	if (!subLayerOrderingInfoPresentFlag)
731	{
732	break;
733	}
734	}
735
736	#if VPS_RENAME
737	assert( pcVPS->getNumHrdParameters() <= MAX_VPS_LAYER_SETS_PLUS1 );
738	assert( pcVPS->getMaxLayerId() < MAX_VPS_LAYER_ID_PLUS1 );
739	#if !VPS_EXTN_OP_LAYER_SETS // num layer sets set in TAppEncTop.cpp
740	pcVPS->setNumLayerSets(1);
741	#endif
742	WRITE_CODE( pcVPS->getMaxLayerId(), 6, "vps_max_layer_id" );
743	WRITE_UVLC( pcVPS->getNumLayerSets() - 1, "vps_num_layer_sets_minus1" );
744	for( UInt opsIdx = 1; opsIdx <= ( pcVPS->getNumLayerSets() - 1 ); opsIdx ++ )
745	{
746	// Operation point set
747	for( UInt i = 0; i <= pcVPS->getMaxLayerId(); i ++ )
748	#else
749	assert( pcVPS->getNumHrdParameters() <= MAX_VPS_NUM_HRD_PARAMETERS );
750	assert( pcVPS->getMaxNuhReservedZeroLayerId() < MAX_VPS_NUH_RESERVED_ZERO_LAYER_ID_PLUS1 );
751	WRITE_CODE( pcVPS->getMaxNuhReservedZeroLayerId(), 6, "vps_max_nuh_reserved_zero_layer_id" );
752	pcVPS->setMaxOpSets(1);
753	WRITE_UVLC( pcVPS->getMaxOpSets() - 1, "vps_max_op_sets_minus1" );
754	for( UInt opsIdx = 1; opsIdx <= ( pcVPS->getMaxOpSets() - 1 ); opsIdx ++ )
755	{
756	// Operation point set
757	for( UInt i = 0; i <= pcVPS->getMaxNuhReservedZeroLayerId(); i ++ )
758	#endif
759	{
760	#if !VPS_EXTN_OP_LAYER_SETS // layer Id include flag set in TAppEncTop.cpp
761	// Only applicable for version 1
762	pcVPS->setLayerIdIncludedFlag( true, opsIdx, i );
763	#endif
764	WRITE_FLAG( pcVPS->getLayerIdIncludedFlag( opsIdx, i ) ? 1 : 0, "layer_id_included_flag[opsIdx][i]" );
765	}
766	}
767	#if DERIVE_LAYER_ID_LIST_VARIABLES
768	pcVPS->deriveLayerIdListVariables();
769	#endif
770	TimingInfo *timingInfo = pcVPS->getTimingInfo();
771	WRITE_FLAG(timingInfo->getTimingInfoPresentFlag(), "vps_timing_info_present_flag");
772	if(timingInfo->getTimingInfoPresentFlag())
773	{
774	WRITE_CODE(timingInfo->getNumUnitsInTick(), 32, "vps_num_units_in_tick");
775	WRITE_CODE(timingInfo->getTimeScale(), 32, "vps_time_scale");
776	WRITE_FLAG(timingInfo->getPocProportionalToTimingFlag(), "vps_poc_proportional_to_timing_flag");
777	if(timingInfo->getPocProportionalToTimingFlag())
778	{
779	WRITE_UVLC(timingInfo->getNumTicksPocDiffOneMinus1(), "vps_num_ticks_poc_diff_one_minus1");
780	}
781	pcVPS->setNumHrdParameters( 0 );
782	WRITE_UVLC( pcVPS->getNumHrdParameters(), "vps_num_hrd_parameters" );
783
784	if( pcVPS->getNumHrdParameters() > 0 )
785	{
786	pcVPS->createHrdParamBuffer();
787	}
788	for( UInt i = 0; i < pcVPS->getNumHrdParameters(); i ++ )
789	{
790	// Only applicable for version 1
791	pcVPS->setHrdOpSetIdx( 0, i );
792	WRITE_UVLC( pcVPS->getHrdOpSetIdx( i ), "hrd_op_set_idx" );
793	if( i > 0 )
794	{
795	WRITE_FLAG( pcVPS->getCprmsPresentFlag( i ) ? 1 : 0, "cprms_present_flag[i]" );
796	}
797	codeHrdParameters(pcVPS->getHrdParameters(i), pcVPS->getCprmsPresentFlag( i ), pcVPS->getMaxTLayers() - 1);
798	}
799	}
800	#if VPS_EXTNS
801	// When MaxLayersMinus1 is greater than 0, vps_extension_flag shall be equal to 1.
802	if( pcVPS->getMaxLayers() > 1 )
803	{
804	assert( pcVPS->getVpsExtensionFlag() == true );
805	}
806
807	WRITE_FLAG( pcVPS->getVpsExtensionFlag() ? 1 : 0, "vps_extension_flag" );
808
809	if( pcVPS->getVpsExtensionFlag() )
810	{
811	while ( m_pcBitIf->getNumberOfWrittenBits() % 8 != 0 )
812	{
813	WRITE_FLAG(1, "vps_extension_alignment_bit_equal_to_one");
814	}
815	#if !P0125_REVERT_VPS_EXTN_OFFSET_TO_RESERVED
816	#if VPS_EXTN_OFFSET_CALC
817	Int vpsExntOffsetValueInBits = this->m_pcBitIf->getNumberOfWrittenBits() - numBytesInVps + 16; // 2 bytes for NUH
818	assert( vpsExntOffsetValueInBits % 8 == 0 );
819	pcVPS->setExtensionOffset( vpsExntOffsetValueInBits >> 3 );
820	#endif
821	#endif
822	codeVPSExtension(pcVPS);
823	WRITE_FLAG( 0, "vps_extension2_flag" ); // Flag value of 1 reserved
824	}
825	#else
826	WRITE_FLAG( 0, "vps_extension_flag" );
827	#endif
828	//future extensions here..
829
830	return;
831	}
832
833	#if SVC_EXTENSION
834	#if VPS_EXTNS
835	Void TEncCavlc::codeVPSExtension (TComVPS *vps)
836	{
837	// ... More syntax elements to be written here
838	#if P0300_ALT_OUTPUT_LAYER_FLAG
839	Int NumOutputLayersInOutputLayerSet[MAX_VPS_LAYER_SETS_PLUS1];
840	Int OlsHighestOutputLayerId[MAX_VPS_LAYER_SETS_PLUS1];
841	#endif
842	#if VPS_EXTN_MASK_AND_DIM_INFO
843	UInt i = 0, j = 0;
844
845	WRITE_FLAG( vps->getAvcBaseLayerFlag(), "avc_base_layer_flag" );
846	#if !P0307_REMOVE_VPS_VUI_OFFSET
847	#if O0109_MOVE_VPS_VUI_FLAG
848	#if !VPS_VUI
849	WRITE_FLAG( 0, "vps_vui_present_flag" );
850	vps->setVpsVuiPresentFlag(false);
851	#else
852	WRITE_FLAG( 1, "vps_vui_present_flag" );
853	vps->setVpsVuiPresentFlag(true);
854	#endif
855	if ( vps->getVpsVuiPresentFlag() )
856	{
857	#if VPS_VUI_OFFSET
858	WRITE_CODE( vps->getVpsVuiOffset( ), 16, "vps_vui_offset" );
859	#endif
860	WRITE_FLAG( vps->getSplittingFlag(), "splitting_flag" );
861	}
862	#else
863	#if VPS_VUI_OFFSET
864	WRITE_CODE( vps->getVpsVuiOffset( ), 16, "vps_vui_offset" );
865	#endif
866	WRITE_FLAG( vps->getSplittingFlag(), "splitting_flag" );
867	#endif // O0109_MOVE_VPS_VUI_FLAG
868	#endif
869	WRITE_FLAG( vps->getSplittingFlag(), "splitting_flag" );
870
871	for(i = 0; i < MAX_VPS_NUM_SCALABILITY_TYPES; i++)
872	{
873	WRITE_FLAG( vps->getScalabilityMask(i), "scalability_mask[i]" );
874	}
875
876	for(j = 0; j < vps->getNumScalabilityTypes() - vps->getSplittingFlag(); j++)
877	{
878	WRITE_CODE( vps->getDimensionIdLen(j) - 1, 3, "dimension_id_len_minus1[j]" );
879	}
880
881	#if SPL_FLG_CHK
882	if(vps->getSplittingFlag())
883	{
884	UInt splDimSum=0;
885	for(j = 0; j < vps->getNumScalabilityTypes(); j++)
886	{
887	splDimSum+=(vps->getDimensionIdLen(j));
888	}
889	assert(splDimSum<=6);
890	}
891	#endif
892
893	WRITE_FLAG( vps->getNuhLayerIdPresentFlag(), "vps_nuh_layer_id_present_flag" );
894	for(i = 1; i < vps->getMaxLayers(); i++)
895	{
896	if( vps->getNuhLayerIdPresentFlag() )
897	{
898	WRITE_CODE( vps->getLayerIdInNuh(i), 6, "layer_id_in_nuh[i]" );
899	}
900
901	if( !vps->getSplittingFlag() )
902	{
903	for(j = 0; j < vps->getNumScalabilityTypes(); j++)
904	{
905	UInt bits = vps->getDimensionIdLen(j);
906	WRITE_CODE( vps->getDimensionId(i, j), bits, "dimension_id[i][j]" );
907	}
908	}
909	}
910	#endif
911	#if VIEW_ID_RELATED_SIGNALING
912	// if ( pcVPS->getNumViews() > 1 )
913	// However, this is a bug in the text since, view_id_len_minus1 is needed to parse view_id_val.
914	{
915	#if O0109_VIEW_ID_LEN
916	WRITE_CODE( vps->getViewIdLen( ), 4, "view_id_len" );
917	assert ( vps->getNumViews() >= (1<<vps->getViewIdLen()) );
918	#else
919	WRITE_CODE( vps->getViewIdLenMinus1( ), 4, "view_id_len_minus1" );
920	#endif
921	}
922
923	#if O0109_VIEW_ID_LEN
924	if ( vps->getViewIdLen() > 0 )
925	{
926	#endif
927	for( i = 0; i < vps->getNumViews(); i++ )
928	{
929	#if O0109_VIEW_ID_LEN
930	WRITE_CODE( vps->getViewIdVal( i ), vps->getViewIdLen( ), "view_id_val[i]" );
931	#else
932	WRITE_CODE( vps->getViewIdVal( i ), vps->getViewIdLenMinus1( ) + 1, "view_id_val[i]" );
933	#endif
934	}
935	#if O0109_VIEW_ID_LEN
936	}
937	#endif
938	#endif // VIEW_ID_RELATED_SIGNALING
939
940	#if VPS_EXTN_DIRECT_REF_LAYERS
941	for( Int layerCtr = 1; layerCtr <= vps->getMaxLayers() - 1; layerCtr++)
942	{
943	for( Int refLayerCtr = 0; refLayerCtr < layerCtr; refLayerCtr++)
944	{
945	WRITE_FLAG(vps->getDirectDependencyFlag(layerCtr, refLayerCtr), "direct_dependency_flag[i][j]" );
946	}
947	}
948	#endif
949	#if VPS_TSLAYERS
950	WRITE_FLAG( vps->getMaxTSLayersPresentFlag(), "vps_sub_layers_max_minus1_present_flag");
951	if (vps->getMaxTSLayersPresentFlag())
952	{
953	for( i = 0; i < vps->getMaxLayers(); i++)
954	{
955	WRITE_CODE(vps->getMaxTSLayersMinus1(i), 3, "sub_layers_vps_max_minus1[i]" );
956	}
957	}
958	#endif
959	#if N0120_MAX_TID_REF_PRESENT_FLAG
960	WRITE_FLAG( vps->getMaxTidRefPresentFlag(), "max_tid_ref_present_flag");
961	if (vps->getMaxTidRefPresentFlag())
962	{
963	for( i = 0; i < vps->getMaxLayers() - 1; i++)
964	{
965	#if O0225_MAX_TID_FOR_REF_LAYERS
966	for( j = i+1; j <= vps->getMaxLayers() - 1; j++)
967	{
968	if(vps->getDirectDependencyFlag(j, i))
969	{
970	WRITE_CODE(vps->getMaxTidIlRefPicsPlus1(i,j), 3, "max_tid_il_ref_pics_plus1[i][j]" );
971	}
972	}
973	#else
974	WRITE_CODE(vps->getMaxTidIlRefPicsPlus1(i), 3, "max_tid_il_ref_pics_plus1[i]" );
975	#endif
976	}
977	}
978	#else
979	for( i = 0; i < vps->getMaxLayers() - 1; i++)
980	{
981	#if O0225_MAX_TID_FOR_REF_LAYERS
982	for( j = i+1; j <= vps->getMaxLayers() - 1; j++)
983	{
984	if(vps->getDirectDependencyFlag(j, i))
985	{
986	WRITE_CODE(vps->getMaxTidIlRefPicsPlus1(i,j), 3, "max_tid_il_ref_pics_plus1[i][j]" );
987	}
988	}
989	#else
990	WRITE_CODE(vps->getMaxTidIlRefPicsPlus1(i), 3, "max_tid_il_ref_pics_plus1[i]" );
991	#endif
992	}
993	#endif
994	#if ILP_SSH_SIG
995	WRITE_FLAG( vps->getIlpSshSignalingEnabledFlag(), "all_ref_layers_active_flag" );
996	#endif
997	#if VPS_EXTN_PROFILE_INFO
998	// Profile-tier-level signalling
999	#if !VPS_EXTN_UEV_CODING
1000	WRITE_CODE( vps->getNumLayerSets() - 1 , 10, "vps_number_layer_sets_minus1" );
1001	WRITE_CODE( vps->getNumProfileTierLevel() - 1, 6, "vps_num_profile_tier_level_minus1");
1002	#else
1003	WRITE_UVLC( vps->getNumProfileTierLevel() - 1, "vps_num_profile_tier_level_minus1");
1004	#endif
1005	for(Int idx = 1; idx <= vps->getNumProfileTierLevel() - 1; idx++)
1006	{
1007	WRITE_FLAG( vps->getProfilePresentFlag(idx), "vps_profile_present_flag[i]" );
1008	#if !P0048_REMOVE_PROFILE_REF
1009	if( !vps->getProfilePresentFlag(idx) )
1010	{
1011	WRITE_CODE( vps->getProfileLayerSetRef(idx) - 1, 6, "profile_ref_minus1[i]" );
1012	}
1013	#endif
1014	codePTL( vps->getPTLForExtn(idx), vps->getProfilePresentFlag(idx), vps->getMaxTLayers() - 1 );
1015	}
1016	#endif
1017
1018	#if !VPS_EXTN_UEV_CODING
1019	Int numOutputLayerSets = vps->getNumOutputLayerSets() ;
1020	WRITE_FLAG( (numOutputLayerSets > vps->getNumLayerSets()), "more_output_layer_sets_than_default_flag" );
1021	if(numOutputLayerSets > vps->getNumLayerSets())
1022	{
1023	WRITE_CODE( numOutputLayerSets - vps->getNumLayerSets(), 10, "num_add_output_layer_sets" );
1024	}
1025	#else
1026	Int numOutputLayerSets = vps->getNumOutputLayerSets();
1027	Int numAddOutputLayerSets = numOutputLayerSets - (Int)vps->getNumLayerSets();
1028
1029	// The value of num_add_output_layer_sets shall be in the range of 0 to 1023, inclusive.
1030	assert( numAddOutputLayerSets >= 0 && numAddOutputLayerSets < 1024 );
1031
1032	#if Q0165_NUM_ADD_OUTPUT_LAYER_SETS
1033	if( vps->getNumLayerSets() > 1 )
1034	{
1035	WRITE_UVLC( numAddOutputLayerSets, "num_add_output_layer_sets" );
1036	WRITE_CODE( vps->getDefaultTargetOutputLayerIdc(), 2, "default_target_output_layer_idc" );
1037	}
1038	#else
1039	WRITE_UVLC( numOutputLayerSets - vps->getNumLayerSets(), "num_add_output_layer_sets" );
1040	#endif
1041	#endif
1042
1043	#if !Q0165_NUM_ADD_OUTPUT_LAYER_SETS
1044	if( numOutputLayerSets > 1 )
1045	{
1046	#if P0295_DEFAULT_OUT_LAYER_IDC
1047	WRITE_CODE( vps->getDefaultTargetOutputLayerIdc(), 2, "default_target_output_layer_idc" );
1048	#else
1049	#if O0109_DEFAULT_ONE_OUT_LAYER_IDC
1050	WRITE_CODE( vps->getDefaultOneTargetOutputLayerIdc(), 2, "default_one_target_output_layer_idc" );
1051	#else
1052	WRITE_FLAG( vps->getDefaultOneTargetOutputLayerFlag(), "default_one_target_output_layer_flag" );
1053	#endif
1054	#endif
1055	}
1056	#endif
1057
1058	for(i = 1; i < numOutputLayerSets; i++)
1059	{
1060	if( i > (vps->getNumLayerSets() - 1) )
1061	{
1062	Int numBits = 1;
1063	while ((1 << numBits) < (vps->getNumLayerSets() - 1))
1064	{
1065	numBits++;
1066	}
1067	WRITE_CODE( vps->getOutputLayerSetIdx(i) - 1, numBits, "output_layer_set_idx_minus1");
1068	#if P0295_DEFAULT_OUT_LAYER_IDC
1069	}
1070	if ( i > (vps->getNumLayerSets() - 1) \|\| vps->getDefaultTargetOutputLayerIdc() >= 2 ) //Instead of == 2, >= 2 is used to follow the agreement that value 3 should be interpreted as 2
1071	{
1072	#endif
1073	Int lsIdx = vps->getOutputLayerSetIdx(i);
1074	#if NUM_OL_FLAGS
1075	for(j = 0; j < vps->getNumLayersInIdList(lsIdx) ; j++)
1076	#else
1077	for(j = 0; j < vps->getNumLayersInIdList(lsIdx) - 1; j++)
1078	#endif
1079	{
1080	WRITE_FLAG( vps->getOutputLayerFlag(i,j), "output_layer_flag[i][j]");
1081	}
1082	}
1083	Int numBits = 1;
1084	while ((1 << numBits) < (vps->getNumProfileTierLevel()))
1085	{
1086	numBits++;
1087	}
1088	WRITE_CODE( vps->getProfileLevelTierIdx(i), numBits, "profile_level_tier_idx[i]" );
1089	#if P0300_ALT_OUTPUT_LAYER_FLAG
1090	NumOutputLayersInOutputLayerSet[i] = 0;
1091	Int layerSetIdxForOutputLayerSet = vps->getOutputLayerSetIdx(i);
1092	for (j = 0; j < vps->getNumLayersInIdList(layerSetIdxForOutputLayerSet); j++)
1093	{
1094	NumOutputLayersInOutputLayerSet[i] += vps->getOutputLayerFlag(i, j);
1095	if (vps->getOutputLayerFlag(i, j))
1096	{
1097	OlsHighestOutputLayerId[i] = vps->getLayerSetLayerIdList(layerSetIdxForOutputLayerSet, j);
1098	}
1099	}
1100	if (NumOutputLayersInOutputLayerSet[i] == 1 && vps->getNumDirectRefLayers(OlsHighestOutputLayerId[i]) > 0)
1101	{
1102	WRITE_FLAG(vps->getAltOuputLayerFlag(i), "alt_output_layer_flag[i]");
1103	}
1104
1105	#if Q0165_OUTPUT_LAYER_SET
1106	assert( NumOutputLayersInOutputLayerSet[i]>0 );
1107	#endif
1108
1109	#endif
1110	}
1111
1112	#if !P0300_ALT_OUTPUT_LAYER_FLAG
1113	#if O0153_ALT_OUTPUT_LAYER_FLAG
1114	if( vps->getMaxLayers() > 1 )
1115	{
1116	WRITE_FLAG( vps->getAltOuputLayerFlag(), "alt_output_layer_flag" );
1117	}
1118	#endif
1119	#endif
1120
1121	#if REPN_FORMAT_IN_VPS
1122	#if Q0195_REP_FORMAT_CLEANUP
1123	// The value of vps_num_rep_formats_minus1 shall be in the range of 0 to 255, inclusive.
1124	assert( vps->getVpsNumRepFormats() > 0 && vps->getVpsNumRepFormats() <= 256 );
1125
1126	WRITE_UVLC( vps->getVpsNumRepFormats() - 1, "vps_num_rep_formats_minus1" );
1127
1128	for(i = 0; i < vps->getVpsNumRepFormats(); i++)
1129	{
1130	// Write rep_format_structures
1131	codeRepFormat( vps->getVpsRepFormat(i) );
1132	}
1133
1134	if( vps->getVpsNumRepFormats() > 1 )
1135	{
1136	WRITE_FLAG( vps->getRepFormatIdxPresentFlag(), "rep_format_idx_present_flag");
1137	}
1138	else
1139	{
1140	// When not present, the value of rep_format_idx_present_flag is inferred to be equal to 0
1141	assert( !vps->getRepFormatIdxPresentFlag() );
1142	}
1143
1144	if( vps->getRepFormatIdxPresentFlag() )
1145	{
1146	for(i = 1; i < vps->getMaxLayers(); i++)
1147	{
1148	Int numBits = 1;
1149	while ((1 << numBits) < (vps->getVpsNumRepFormats()))
1150	{
1151	numBits++;
1152	}
1153	WRITE_CODE( vps->getVpsRepFormatIdx(i), numBits, "vps_rep_format_idx[i]" );
1154	}
1155	}
1156	#else
1157	WRITE_FLAG( vps->getRepFormatIdxPresentFlag(), "rep_format_idx_present_flag");
1158
1159	if( vps->getRepFormatIdxPresentFlag() )
1160	{
1161	// The value of vps_num_rep_formats_minus1 shall be in the range of 0 to 255, inclusive.
1162	assert( vps->getVpsNumRepFormats() > 0 && vps->getVpsNumRepFormats() <= 256 );
1163
1164	#if O0096_REP_FORMAT_INDEX
1165	#if !VPS_EXTN_UEV_CODING
1166	WRITE_CODE( vps->getVpsNumRepFormats() - 1, 8, "vps_num_rep_formats_minus1" );
1167	#else
1168	WRITE_UVLC( vps->getVpsNumRepFormats() - 1, "vps_num_rep_formats_minus1" );
1169	#endif
1170	#else
1171	WRITE_CODE( vps->getVpsNumRepFormats() - 1, 4, "vps_num_rep_formats_minus1" );
1172	#endif
1173	}
1174	for(i = 0; i < vps->getVpsNumRepFormats(); i++)
1175	{
1176	// Read rep_format_structures
1177	codeRepFormat( vps->getVpsRepFormat(i) );
1178	}
1179
1180	if( vps->getRepFormatIdxPresentFlag() )
1181	{
1182	for(i = 1; i < vps->getMaxLayers(); i++)
1183	{
1184	if( vps->getVpsNumRepFormats() > 1 )
1185	{
1186	#if O0096_REP_FORMAT_INDEX
1187	#if !VPS_EXTN_UEV_CODING
1188	WRITE_CODE( vps->getVpsRepFormatIdx(i), 8, "vps_rep_format_idx[i]" );
1189	#else
1190	Int numBits = 1;
1191	while ((1 << numBits) < (vps->getVpsNumRepFormats()))
1192	{
1193	numBits++;
1194	}
1195	WRITE_CODE( vps->getVpsRepFormatIdx(i), numBits, "vps_rep_format_idx[i]" );
1196	#endif
1197	#else
1198	WRITE_CODE( vps->getVpsRepFormatIdx(i), 4, "vps_rep_format_idx[i]" );
1199	#endif
1200	}
1201	}
1202	}
1203	#endif
1204	#endif
1205
1206	WRITE_FLAG(vps->getMaxOneActiveRefLayerFlag(), "max_one_active_ref_layer_flag");
1207	#if O0062_POC_LSB_NOT_PRESENT_FLAG
1208	for(i = 1; i< vps->getMaxLayers(); i++)
1209	{
1210	if( vps->getNumDirectRefLayers( vps->getLayerIdInNuh(i) ) == 0 )
1211	{
1212	WRITE_FLAG(vps->getPocLsbNotPresentFlag(i), "poc_lsb_not_present_flag[i]");
1213	}
1214	}
1215	#endif
1216	#if O0215_PHASE_ALIGNMENT
1217	WRITE_FLAG(vps->getPhaseAlignFlag(), "cross_layer_phase_alignment_flag" );
1218	#endif
1219	#if N0147_IRAP_ALIGN_FLAG && !IRAP_ALIGN_FLAG_IN_VPS_VUI
1220	WRITE_FLAG(vps->getCrossLayerIrapAlignFlag(), "cross_layer_irap_aligned_flag");
1221	#endif
1222	#if VPS_DPB_SIZE_TABLE
1223	codeVpsDpbSizeTable(vps);
1224	#endif
1225	#if VPS_EXTN_DIRECT_REF_LAYERS
1226	WRITE_UVLC( vps->getDirectDepTypeLen()-2, "direct_dep_type_len_minus2");
1227	#if O0096_DEFAULT_DEPENDENCY_TYPE
1228	WRITE_FLAG(vps->getDefaultDirectDependencyTypeFlag(), "default_direct_dependency_flag");
1229	if (vps->getDefaultDirectDependencyTypeFlag())
1230	{
1231	WRITE_CODE( vps->getDefaultDirectDependencyType(), vps->getDirectDepTypeLen(), "default_direct_dependency_type" );
1232	}
1233	else
1234	{
1235	for(i = 1; i < vps->getMaxLayers(); i++)
1236	{
1237	for(j = 0; j < i; j++)
1238	{
1239	if (vps->getDirectDependencyFlag(i, j))
1240	{
1241	WRITE_CODE( vps->getDirectDependencyType(i, j), vps->getDirectDepTypeLen(), "direct_dependency_type[i][j]" );
1242	}
1243	}
1244	}
1245	}
1246	#else
1247	for(i = 1; i < vps->getMaxLayers(); i++)
1248	{
1249	for(j = 0; j < i; j++)
1250	{
1251	if (vps->getDirectDependencyFlag(i, j))
1252	{
1253	WRITE_CODE( vps->getDirectDependencyType(i, j), vps->getDirectDepTypeLen(), "direct_dependency_type[i][j]" );
1254	}
1255	}
1256	}
1257	#endif
1258	#endif
1259
1260	#if !O0109_O0199_FLAGS_TO_VUI
1261	#if M0040_ADAPTIVE_RESOLUTION_CHANGE
1262	WRITE_FLAG(vps->getSingleLayerForNonIrapFlag(), "single_layer_for_non_irap_flag" );
1263	#endif
1264	#if HIGHER_LAYER_IRAP_SKIP_FLAG
1265	WRITE_FLAG(vps->getHigherLayerIrapSkipFlag(), "higher_layer_irap_skip_flag" );
1266	#endif
1267	#endif
1268
1269	#if P0307_VPS_NON_VUI_EXTENSION
1270	// The value of vps_non_vui_extension_length shall be in the range of 0 to 4096, inclusive.
1271	assert( vps->getVpsNonVuiExtLength() >= 0 && vps->getVpsNonVuiExtLength() <= 4096 );
1272
1273	WRITE_UVLC( vps->getVpsNonVuiExtLength(), "vps_non_vui_extension_length" );
1274	#if P0307_VPS_NON_VUI_EXT_UPDATE
1275	for (i = 1; i <= vps->getVpsNonVuiExtLength(); i++)
1276	{
1277	WRITE_CODE(1, 8, "vps_non_vui_extension_data_byte");
1278	}
1279	#else
1280	if ( vps->getVpsNonVuiExtLength() > 0 )
1281	{
1282	printf("\n\nUp to the current spec, the value of vps_non_vui_extension_length is supposed to be 0\n");
1283	}
1284	#endif
1285	#endif
1286
1287	#if !O0109_MOVE_VPS_VUI_FLAG
1288	#if !VPS_VUI
1289	WRITE_FLAG( 0, "vps_vui_present_flag" );
1290	#else
1291	WRITE_FLAG( 1, "vps_vui_present_flag" );
1292	if(1) // Should be conditioned on the value of vps_vui_present_flag
1293	{
1294	while ( m_pcBitIf->getNumberOfWrittenBits() % 8 != 0 )
1295	{
1296	WRITE_FLAG(1, "vps_vui_alignment_bit_equal_to_one");
1297	}
1298	#if VPS_VUI_OFFSET
1299	Int vpsVuiOffsetValeInBits = this->m_pcBitIf->getNumberOfWrittenBits() - m_vpsVuiCounter + 16; // 2 bytes for NUH
1300	assert( vpsVuiOffsetValeInBits % 8 == 0 );
1301	vps->setVpsVuiOffset( vpsVuiOffsetValeInBits >> 3 );
1302	#endif
1303	codeVPSVUI(vps);
1304	}
1305	#endif
1306	#else
1307	#if P0307_REMOVE_VPS_VUI_OFFSET
1308	vps->setVpsVuiPresentFlag(true);
1309	WRITE_FLAG( vps->getVpsVuiPresentFlag() ? 1 : 0, "vps_vui_present_flag" );
1310	#endif
1311	if(vps->getVpsVuiPresentFlag()) // Should be conditioned on the value of vps_vui_present_flag
1312	{
1313	while ( m_pcBitIf->getNumberOfWrittenBits() % 8 != 0 )
1314	{
1315	WRITE_FLAG(1, "vps_vui_alignment_bit_equal_to_one");
1316	}
1317	#if !P0307_REMOVE_VPS_VUI_OFFSET
1318	#if VPS_VUI_OFFSET
1319	Int vpsVuiOffsetValeInBits = this->m_pcBitIf->getNumberOfWrittenBits() - m_vpsVuiCounter + 16; // 2 bytes for NUH
1320	assert( vpsVuiOffsetValeInBits % 8 == 0 );
1321	vps->setVpsVuiOffset( vpsVuiOffsetValeInBits >> 3 );
1322	#endif
1323	#endif
1324	codeVPSVUI(vps);
1325	}
1326	#endif // 0109_MOVE_VPS_FLAG
1327	}
1328	#endif
1329	#if REPN_FORMAT_IN_VPS
1330	Void TEncCavlc::codeRepFormat( RepFormat *repFormat )
1331	{
1332	#if REPN_FORMAT_CONTROL_FLAG
1333	WRITE_CODE( repFormat->getPicWidthVpsInLumaSamples (), 16, "pic_width_vps_in_luma_samples" );
1334	WRITE_CODE( repFormat->getPicHeightVpsInLumaSamples(), 16, "pic_height_vps_in_luma_samples" );
1335	WRITE_FLAG( repFormat->getChromaAndBitDepthVpsPresentFlag(), "chroma_and_bit_depth_vps_present_flag" );
1336
1337	if( repFormat->getChromaAndBitDepthVpsPresentFlag() )
1338	{
1339	WRITE_CODE( repFormat->getChromaFormatVpsIdc(), 2, "chroma_format_vps_idc" );
1340
1341	if( repFormat->getChromaFormatVpsIdc() == 3 )
1342	{
1343	WRITE_FLAG( repFormat->getSeparateColourPlaneVpsFlag(), "separate_colour_plane_vps_flag" );
1344	}
1345
1346	assert( repFormat->getBitDepthVpsLuma() >= 8 );
1347	assert( repFormat->getBitDepthVpsChroma() >= 8 );
1348	WRITE_CODE( repFormat->getBitDepthVpsLuma() - 8, 4, "bit_depth_vps_luma_minus8" );
1349	WRITE_CODE( repFormat->getBitDepthVpsChroma() - 8, 4, "bit_depth_vps_chroma_minus8" );
1350	}
1351	#else
1352	WRITE_CODE( repFormat->getChromaFormatVpsIdc(), 2, "chroma_format_idc" );
1353
1354	if( repFormat->getChromaFormatVpsIdc() == 3 )
1355	{
1356	WRITE_FLAG( repFormat->getSeparateColourPlaneVpsFlag(), "separate_colour_plane_flag");
1357	}
1358
1359	WRITE_CODE ( repFormat->getPicWidthVpsInLumaSamples (), 16, "pic_width_in_luma_samples" );
1360	WRITE_CODE ( repFormat->getPicHeightVpsInLumaSamples(), 16, "pic_height_in_luma_samples" );
1361
1362	assert( repFormat->getBitDepthVpsLuma() >= 8 );
1363	assert( repFormat->getBitDepthVpsChroma() >= 8 );
1364	WRITE_CODE( repFormat->getBitDepthVpsLuma() - 8, 4, "bit_depth_luma_minus8" );
1365	WRITE_CODE( repFormat->getBitDepthVpsChroma() - 8, 4, "bit_depth_chroma_minus8" );
1366	#endif
1367	}
1368	#endif
1369	#if VPS_DPB_SIZE_TABLE
1370	Void TEncCavlc::codeVpsDpbSizeTable(TComVPS *vps)
1371	{
1372	#if DPB_PARAMS_MAXTLAYERS
1373	Int * MaxSubLayersInLayerSetMinus1 = new Int[vps->getNumOutputLayerSets()];
1374	for(Int i = 1; i < vps->getNumOutputLayerSets(); i++)
1375	{
1376	UInt maxSLMinus1 = 0;
1377	#if CHANGE_NUMSUBDPB_IDX
1378	Int optLsIdx = vps->getOutputLayerSetIdx( i );
1379	#else
1380	Int optLsIdx = i;
1381	#endif
1382	for(Int k = 0; k < vps->getNumLayersInIdList(optLsIdx); k++ ) {
1383	Int lId = vps->getLayerSetLayerIdList(optLsIdx, k);
1384	maxSLMinus1 = max(maxSLMinus1, vps->getMaxTSLayersMinus1(vps->getLayerIdInVps(lId)));
1385	}
1386	MaxSubLayersInLayerSetMinus1[ i ] = maxSLMinus1;
1387	}
1388	#endif
1389
1390	for(Int i = 1; i < vps->getNumOutputLayerSets(); i++)
1391	{
1392	#if CHANGE_NUMSUBDPB_IDX
1393	Int layerSetIdxForOutputLayerSet = vps->getOutputLayerSetIdx( i );
1394	#endif
1395	WRITE_FLAG( vps->getSubLayerFlagInfoPresentFlag( i ), "sub_layer_flag_info_present_flag[i]");
1396	#if DPB_PARAMS_MAXTLAYERS
1397	for(Int j = 0; j <= MaxSubLayersInLayerSetMinus1[ i ]; j++)
1398	#else
1399	for(Int j = 0; j < vps->getMaxTLayers(); j++)
1400	#endif
1401	{
1402	if( j > 0 && vps->getSubLayerFlagInfoPresentFlag(i) )
1403	{
1404	WRITE_FLAG( vps->getSubLayerDpbInfoPresentFlag( i, j), "sub_layer_dpb_info_present_flag[i]");
1405	}
1406	if( vps->getSubLayerDpbInfoPresentFlag(i, j) )
1407	{
1408	#if CHANGE_NUMSUBDPB_IDX
1409	for(Int k = 0; k < vps->getNumSubDpbs(layerSetIdxForOutputLayerSet); k++)
1410	#else
1411	for(Int k = 0; k < vps->getNumSubDpbs(i); k++)
1412	#endif
1413	{
1414	WRITE_UVLC( vps->getMaxVpsDecPicBufferingMinus1( i, k, j), "max_vps_dec_pic_buffering_minus1[i][k][j]" );
1415	}
1416	WRITE_UVLC( vps->getMaxVpsNumReorderPics( i, j), "max_vps_num_reorder_pics[i][j]" );
1417	#if RESOLUTION_BASED_DPB
1418	if( vps->getNumSubDpbs(layerSetIdxForOutputLayerSet) != vps->getNumLayersInIdList( layerSetIdxForOutputLayerSet ) ) // NumSubDpbs
1419	{
1420	for(Int k = 0; k < vps->getNumLayersInIdList( layerSetIdxForOutputLayerSet ); k++)
1421	{
1422	WRITE_UVLC( vps->getMaxVpsLayerDecPicBuffMinus1( i, k, j), "max_vps_layer_dec_pic_buff_minus1[i][k][j]" );
1423	}
1424	}
1425	#endif
1426	WRITE_UVLC( vps->getMaxVpsLatencyIncreasePlus1( i, j), "max_vps_latency_increase_plus1[i][j]" );
1427	}
1428	}
1429	}
1430	}
1431	#endif
1432	#if VPS_VUI
1433	Void TEncCavlc::codeVPSVUI (TComVPS *vps)
1434	{
1435	Int i,j;
1436	#if O0223_PICTURE_TYPES_ALIGN_FLAG
1437	WRITE_FLAG(vps->getCrossLayerPictureTypeAlignFlag(), "cross_layer_pic_type_aligned_flag");
1438	if (!vps->getCrossLayerPictureTypeAlignFlag())
1439	{
1440	#endif
1441	#if IRAP_ALIGN_FLAG_IN_VPS_VUI
1442	WRITE_FLAG(vps->getCrossLayerIrapAlignFlag(), "cross_layer_irap_aligned_flag");
1443	#if P0068_CROSS_LAYER_ALIGNED_IDR_ONLY_FOR_IRAP_FLAG
1444	if(vps->getCrossLayerIrapAlignFlag())
1445	{
1446	WRITE_FLAG(vps->getCrossLayerAlignedIdrOnlyFlag(), "all_layers_idr_aligned_flag");
1447	}
1448	#endif
1449	#endif
1450	#if O0223_PICTURE_TYPES_ALIGN_FLAG
1451	}
1452	#endif
1453	#if VPS_VUI_BITRATE_PICRATE
1454	WRITE_FLAG( vps->getBitRatePresentVpsFlag(), "bit_rate_present_vps_flag" );
1455	WRITE_FLAG( vps->getPicRatePresentVpsFlag(), "pic_rate_present_vps_flag" );
1456
1457	if( vps->getBitRatePresentVpsFlag() \|\| vps->getPicRatePresentVpsFlag() )
1458	{
1459	for( i = 0; i < vps->getNumLayerSets(); i++ )
1460	{
1461	for( j = 0; j < vps->getMaxTLayers(); j++ )
1462	{
1463	if( vps->getBitRatePresentVpsFlag() )
1464	{
1465	WRITE_FLAG( vps->getBitRatePresentFlag( i, j), "bit_rate_present_flag[i][j]" );
1466	}
1467	if( vps->getPicRatePresentVpsFlag() )
1468	{
1469	WRITE_FLAG( vps->getPicRatePresentFlag( i, j), "pic_rate_present_flag[i][j]" );
1470	}
1471	if( vps->getBitRatePresentFlag(i, j) )
1472	{
1473	WRITE_CODE( vps->getAvgBitRate( i, j ), 16, "avg_bit_rate[i][j]" );
1474	WRITE_CODE( vps->getAvgBitRate( i, j ), 16, "max_bit_rate[i][j]" );
1475	}
1476	if( vps->getPicRatePresentFlag(i, j) )
1477	{
1478	WRITE_CODE( vps->getConstPicRateIdc( i, j), 2 , "constant_pic_rate_idc[i][j]" );
1479	WRITE_CODE( vps->getConstPicRateIdc( i, j), 16, "avg_pic_rate[i][j]" );
1480	}
1481	}
1482	}
1483	}
1484	#endif
1485	#if VPS_VUI_VIDEO_SIGNAL_MOVE
1486	WRITE_FLAG( vps->getVideoSigPresentVpsFlag(), "video_signal_info_idx_present_flag" );
1487	if (vps->getVideoSigPresentVpsFlag())
1488	{
1489	WRITE_CODE(vps->getNumVideoSignalInfo()-1, 4, "vps_num_video_signal_info_minus1" );
1490	}
1491
1492	for(i = 0; i < vps->getNumVideoSignalInfo(); i++)
1493	{
1494	WRITE_CODE(vps->getVideoVPSFormat(i), 3, "video_vps_format" );
1495	WRITE_FLAG(vps->getVideoFullRangeVpsFlag(i), "video_full_range_vps_flag" );
1496	WRITE_CODE(vps->getColorPrimaries(i), 8, "color_primaries_vps" );
1497	WRITE_CODE(vps->getTransCharacter(i), 8, "transfer_characteristics_vps" );
1498	WRITE_CODE(vps->getMaxtrixCoeff(i), 8, "matrix_coeffs_vps" );
1499	}
1500
1501	if (vps->getVideoSigPresentVpsFlag() && vps->getNumVideoSignalInfo() > 1 )
1502	{
1503	for (i=1; i < vps->getMaxLayers(); i++)
1504	WRITE_CODE(vps->getVideoSignalInfoIdx(i), 4, "vps_video_signal_info_idx" );
1505	}
1506	#endif
1507	#if VPS_VUI_TILES_NOT_IN_USE__FLAG
1508	UInt layerIdx;
1509	WRITE_FLAG( vps->getTilesNotInUseFlag() ? 1 : 0 , "tiles_not_in_use_flag" );
1510	if (!vps->getTilesNotInUseFlag())
1511	{
1512	for(i = 0; i < vps->getMaxLayers(); i++)
1513	{
1514	WRITE_FLAG( vps->getTilesInUseFlag(i) ? 1 : 0 , "tiles_in_use_flag[ i ]" );
1515	if (vps->getTilesInUseFlag(i))
1516	{
1517	WRITE_FLAG( vps->getLoopFilterNotAcrossTilesFlag(i) ? 1 : 0 , "loop_filter_not_across_tiles_flag[ i ]" );
1518	}
1519	}
1520	#endif
1521	#if TILE_BOUNDARY_ALIGNED_FLAG
1522	for(i = 1; i < vps->getMaxLayers(); i++)
1523	{
1524	for(j = 0; j < vps->getNumDirectRefLayers(vps->getLayerIdInNuh(i)); j++)
1525	{
1526	#if VPS_VUI_TILES_NOT_IN_USE__FLAG
1527	layerIdx = vps->getLayerIdInVps(vps->getRefLayerId(vps->getLayerIdInNuh(i), j));
1528	if (vps->getTilesInUseFlag(i) && vps->getTilesInUseFlag(layerIdx)) {
1529	WRITE_FLAG( vps->getTileBoundariesAlignedFlag(i,j) ? 1 : 0 , "tile_boundaries_aligned_flag[i][j]" );
1530	}
1531	#else
1532	WRITE_FLAG( vps->getTileBoundariesAlignedFlag(i,j) ? 1 : 0 , "tile_boundaries_aligned_flag[i][j]" );
1533	#endif
1534	}
1535	}
1536	#endif
1537	#if VPS_VUI_TILES_NOT_IN_USE__FLAG
1538	}
1539	#endif
1540	#if VPS_VUI_WPP_NOT_IN_USE__FLAG
1541	WRITE_FLAG( vps->getWppNotInUseFlag() ? 1 : 0 , "wpp_not_in_use_flag" );
1542	if (!vps->getWppNotInUseFlag())
1543	{
1544	for(i = 0; i < vps->getMaxLayers(); i++)
1545	{
1546	WRITE_FLAG( vps->getWppInUseFlag(i) ? 1 : 0 , "wpp_in_use_flag[ i ]" );
1547	}
1548	}
1549	#endif
1550
1551	#if O0109_O0199_FLAGS_TO_VUI
1552	#if M0040_ADAPTIVE_RESOLUTION_CHANGE
1553	WRITE_FLAG(vps->getSingleLayerForNonIrapFlag(), "single_layer_for_non_irap_flag" );
1554	#endif
1555	#if HIGHER_LAYER_IRAP_SKIP_FLAG
1556	// When single_layer_for_non_irap_flag is equal to 0, higher_layer_irap_skip_flag shall be equal to 0
1557	if( !vps->getSingleLayerForNonIrapFlag() )
1558	{
1559	assert( !vps->getHigherLayerIrapSkipFlag() );
1560	}
1561
1562	WRITE_FLAG(vps->getHigherLayerIrapSkipFlag(), "higher_layer_irap_skip_flag" );
1563	#endif
1564	#endif
1565	#if P0312_VERT_PHASE_ADJ
1566	WRITE_FLAG( vps->getVpsVuiVertPhaseInUseFlag(), "vps_vui_vert_phase_in_use_flag" );
1567	#endif
1568	#if N0160_VUI_EXT_ILP_REF
1569	WRITE_FLAG( vps->getIlpRestrictedRefLayersFlag() ? 1 : 0 , "ilp_restricted_ref_layers_flag" );
1570	if( vps->getIlpRestrictedRefLayersFlag())
1571	{
1572	for(i = 1; i < vps->getMaxLayers(); i++)
1573	{
1574	for(j = 0; j < vps->getNumDirectRefLayers(vps->getLayerIdInNuh(i)); j++)
1575	{
1576	WRITE_UVLC(vps->getMinSpatialSegmentOffsetPlus1( i, j), "min_spatial_segment_offset_plus1[i][j]");
1577
1578	if( vps->getMinSpatialSegmentOffsetPlus1(i,j ) > 0 )
1579	{
1580	WRITE_FLAG( vps->getCtuBasedOffsetEnabledFlag( i, j) ? 1 : 0 , "ctu_based_offset_enabled_flag[i][j]" );
1581
1582	if(vps->getCtuBasedOffsetEnabledFlag(i,j))
1583	{
1584	WRITE_UVLC(vps->getMinHorizontalCtuOffsetPlus1( i, j), "min_horizontal_ctu_offset_plus1[i][j]");
1585	}
1586	}
1587	}
1588	}
1589	}
1590	#endif
1591	#if VPS_VUI_VIDEO_SIGNAL
1592	#if VPS_VUI_VIDEO_SIGNAL_MOVE
1593	#else
1594	WRITE_FLAG( vps->getVideoSigPresentVpsFlag(), "video_signal_info_idx_present_flag" );
1595	if (vps->getVideoSigPresentVpsFlag())
1596	{
1597	WRITE_CODE(vps->getNumVideoSignalInfo()-1, 4, "vps_num_video_signal_info_minus1" );
1598	}
1599
1600	for(i = 0; i < vps->getNumVideoSignalInfo(); i++)
1601	{
1602	WRITE_CODE(vps->getVideoVPSFormat(i), 3, "video_vps_format" );
1603	WRITE_FLAG(vps->getVideoFullRangeVpsFlag(i), "video_full_range_vps_flag" );
1604	WRITE_CODE(vps->getColorPrimaries(i), 8, "color_primaries_vps" );
1605	WRITE_CODE(vps->getTransCharacter(i), 8, "transfer_characteristics_vps" );
1606	WRITE_CODE(vps->getMaxtrixCoeff(i), 8, "matrix_coeffs_vps" );
1607	}
1608
1609	if (vps->getVideoSigPresentVpsFlag() && vps->getNumVideoSignalInfo() > 1 )
1610	{
1611	for (i=1; i < vps->getMaxLayers(); i++)
1612	WRITE_CODE(vps->getVideoSignalInfoIdx(i), 4, "vps_video_signal_info_idx" );
1613	}
1614	#endif
1615	#endif
1616	#if O0164_MULTI_LAYER_HRD
1617	WRITE_FLAG(vps->getVpsVuiBspHrdPresentFlag(), "vps_vui_bsp_hrd_present_flag" );
1618	if (vps->getVpsVuiBspHrdPresentFlag())
1619	{
1620	WRITE_UVLC( vps->getVpsNumBspHrdParametersMinus1(), "vps_num_bsp_hrd_parameters_minus1" );
1621	for( i = 0; i <= vps->getVpsNumBspHrdParametersMinus1(); i++ )
1622	{
1623	if( i > 0 )
1624	{
1625	WRITE_FLAG( vps->getBspCprmsPresentFlag(i), "bsp_cprms_present_flag[i]" );
1626	}
1627	codeHrdParameters(vps->getBspHrd(i), i==0 ? 1 : vps->getBspCprmsPresentFlag(i), vps->getMaxTLayers()-1);
1628	}
1629	for( UInt h = 1; h <= (vps->getNumLayerSets()-1); h++ )
1630	{
1631	WRITE_UVLC( vps->getNumBitstreamPartitions(h), "num_bitstream_partitions[i]");
1632	for( i = 0; i < vps->getNumBitstreamPartitions(h); i++ )
1633	{
1634	for( j = 0; j <= (vps->getMaxLayers()-1); j++ )
1635	{
1636	if (vps->getLayerIdIncludedFlag(h, j))
1637	{
1638	WRITE_FLAG( vps->getLayerInBspFlag(h, i, j), "layer_in_bsp_flag[h][i][j]" );
1639	}
1640	}
1641	}
1642	if (vps->getNumBitstreamPartitions(h))
1643	{
1644	WRITE_UVLC( vps->getNumBspSchedCombinations(h), "num_bsp_sched_combinations[h]");
1645	for( i = 0; i < vps->getNumBspSchedCombinations(h); i++ )
1646	{
1647	for( j = 0; j < vps->getNumBitstreamPartitions(h); j++ )
1648	{
1649	WRITE_UVLC( vps->getBspCombHrdIdx(h, i, j), "bsp_comb_hrd_idx[h][i][j]");
1650	WRITE_UVLC( vps->getBspCombSchedIdx(h, i, j), "bsp_comb_sched_idx[h][i][j]");
1651	}
1652	}
1653	}
1654	}
1655	}
1656	#endif
1657	#if P0182_VPS_VUI_PS_FLAG
1658	for(i = 1; i < vps->getMaxLayers(); i++)
1659	{
1660	if( vps->getNumRefLayers(vps->getLayerIdInNuh(i)) == 0 )
1661	{
1662	if( (vps->getSPSId(i) == 0) && (vps->getPPSId(i) == 0) )
1663	{
1664	vps->setBaseLayerPSCompatibilityFlag(i, 1);
1665	}
1666	else
1667	{
1668	vps->setBaseLayerPSCompatibilityFlag(i, 0);
1669	}
1670	WRITE_FLAG(vps->getBaseLayerPSCompatibilityFlag(i), "base_layer_parameter_set_compatibility_flag" );
1671	}
1672	}
1673	#endif
1674	}
1675	#endif
1676	#endif //SVC_EXTENSION
1677
1678	Void TEncCavlc::codeSliceHeader ( TComSlice* pcSlice )
1679	{
1680	#if ENC_DEC_TRACE
1681	xTraceSliceHeader (pcSlice);
1682	#endif
1683
1684	//calculate number of bits required for slice address
1685	Int maxSliceSegmentAddress = pcSlice->getPic()->getNumCUsInFrame();
1686	Int bitsSliceSegmentAddress = 0;
1687	while(maxSliceSegmentAddress>(1<<bitsSliceSegmentAddress))
1688	{
1689	bitsSliceSegmentAddress++;
1690	}
1691	Int ctuAddress;
1692	if (pcSlice->isNextSlice())
1693	{
1694	// Calculate slice address
1695	ctuAddress = (pcSlice->getSliceCurStartCUAddr()/pcSlice->getPic()->getNumPartInCU());
1696	}
1697	else
1698	{
1699	// Calculate slice address
1700	ctuAddress = (pcSlice->getSliceSegmentCurStartCUAddr()/pcSlice->getPic()->getNumPartInCU());
1701	}
1702	//write slice address
1703	Int sliceSegmentAddress = pcSlice->getPic()->getPicSym()->getCUOrderMap(ctuAddress);
1704
1705	WRITE_FLAG( sliceSegmentAddress==0, "first_slice_segment_in_pic_flag" );
1706	if ( pcSlice->getRapPicFlag() )
1707	{
1708	#if SETTING_NO_OUT_PIC_PRIOR
1709	WRITE_FLAG( pcSlice->getNoOutputPriorPicsFlag() ? 1 : 0, "no_output_of_prior_pics_flag" );
1710	#else
1711	WRITE_FLAG( 0, "no_output_of_prior_pics_flag" );
1712	#endif
1713	}
1714	WRITE_UVLC( pcSlice->getPPS()->getPPSId(), "slice_pic_parameter_set_id" );
1715	pcSlice->setDependentSliceSegmentFlag(!pcSlice->isNextSlice());
1716	if ( pcSlice->getPPS()->getDependentSliceSegmentsEnabledFlag() && (sliceSegmentAddress!=0) )
1717	{
1718	WRITE_FLAG( pcSlice->getDependentSliceSegmentFlag() ? 1 : 0, "dependent_slice_segment_flag" );
1719	}
1720	if(sliceSegmentAddress>0)
1721	{
1722	WRITE_CODE( sliceSegmentAddress, bitsSliceSegmentAddress, "slice_segment_address" );
1723	}
1724	if ( !pcSlice->getDependentSliceSegmentFlag() )
1725	{
1726	#if SVC_EXTENSION
1727	#if POC_RESET_FLAG
1728	Int iBits = 0;
1729	if( pcSlice->getPPS()->getNumExtraSliceHeaderBits() > iBits )
1730	{
1731	WRITE_FLAG( pcSlice->getPocResetFlag(), "poc_reset_flag" );
1732	iBits++;
1733	}
1734	if( pcSlice->getPPS()->getNumExtraSliceHeaderBits() > iBits )
1735	{
1736	assert(!!"discardable_flag");
1737	WRITE_FLAG(pcSlice->getDiscardableFlag(), "discardable_flag");
1738	iBits++;
1739	}
1740	#if O0149_CROSS_LAYER_BLA_FLAG
1741	if( pcSlice->getPPS()->getNumExtraSliceHeaderBits() > iBits )
1742	{
1743	assert(!!"cross_layer_bla_flag");
1744	WRITE_FLAG(pcSlice->getCrossLayerBLAFlag(), "cross_layer_bla_flag");
1745	iBits++;
1746	}
1747	#endif
1748	for ( ; iBits < pcSlice->getPPS()->getNumExtraSliceHeaderBits(); iBits++)
1749	{
1750	assert(!!"slice_reserved_undetermined_flag[]");
1751	WRITE_FLAG(0, "slice_reserved_undetermined_flag[]");
1752	}
1753	#else
1754	if (pcSlice->getPPS()->getNumExtraSliceHeaderBits()>0)
1755	{
1756	assert(!!"discardable_flag");
1757	WRITE_FLAG(pcSlice->getDiscardableFlag(), "discardable_flag");
1758	}
1759	for (Int i = 1; i < pcSlice->getPPS()->getNumExtraSliceHeaderBits(); i++)
1760	{
1761	assert(!!"slice_reserved_undetermined_flag[]");
1762	WRITE_FLAG(0, "slice_reserved_undetermined_flag[]");
1763	}
1764	#endif
1765	#else //SVC_EXTENSION
1766	for (Int i = 0; i < pcSlice->getPPS()->getNumExtraSliceHeaderBits(); i++)
1767	{
1768	assert(!!"slice_reserved_undetermined_flag[]");
1769	WRITE_FLAG(0, "slice_reserved_undetermined_flag[]");
1770	}
1771	#endif //SVC_EXTENSION
1772
1773	WRITE_UVLC( pcSlice->getSliceType(), "slice_type" );
1774
1775	if( pcSlice->getPPS()->getOutputFlagPresentFlag() )
1776	{
1777	WRITE_FLAG( pcSlice->getPicOutputFlag() ? 1 : 0, "pic_output_flag" );
1778	}
1779
1780	#if !AUXILIARY_PICTURES
1781	#if REPN_FORMAT_IN_VPS
1782	// in the first version chroma_format_idc is equal to one, thus colour_plane_id will not be present
1783	assert( pcSlice->getChromaFormatIdc() == 1 );
1784	#else
1785	// in the first version chroma_format_idc is equal to one, thus colour_plane_id will not be present
1786	assert (pcSlice->getSPS()->getChromaFormatIdc() == 1 );
1787	#endif
1788	#endif
1789	// if( separate_colour_plane_flag == 1 )
1790	// colour_plane_id u(2)
1791
1792	#if N0065_LAYER_POC_ALIGNMENT
1793	#if O0062_POC_LSB_NOT_PRESENT_FLAG
1794	if( (pcSlice->getLayerId() > 0 && !pcSlice->getVPS()->getPocLsbNotPresentFlag( pcSlice->getVPS()->getLayerIdInVps(pcSlice->getLayerId())) ) \|\| !pcSlice->getIdrPicFlag())
1795	#else
1796	if( pcSlice->getLayerId() > 0 \|\| !pcSlice->getIdrPicFlag() )
1797	#endif
1798	#else
1799	if( !pcSlice->getIdrPicFlag() )
1800	#endif
1801	{
1802	#if POC_RESET_FLAG
1803	Int picOrderCntLSB;
1804	if( !pcSlice->getPocResetFlag() )
1805	{
1806	picOrderCntLSB = (pcSlice->getPOC()-pcSlice->getLastIDR()+(1<<pcSlice->getSPS()->getBitsForPOC())) & ((1<<pcSlice->getSPS()->getBitsForPOC())-1);
1807	}
1808	else
1809	{
1810	picOrderCntLSB = (pcSlice->getPocValueBeforeReset()-pcSlice->getLastIDR()+(1<<pcSlice->getSPS()->getBitsForPOC())) & ((1<<pcSlice->getSPS()->getBitsForPOC())-1);
1811	}
1812	#else
1813	Int picOrderCntLSB = (pcSlice->getPOC()-pcSlice->getLastIDR()+(1<<pcSlice->getSPS()->getBitsForPOC())) & ((1<<pcSlice->getSPS()->getBitsForPOC())-1);
1814	#endif
1815	WRITE_CODE( picOrderCntLSB, pcSlice->getSPS()->getBitsForPOC(), "pic_order_cnt_lsb");
1816
1817	#if N0065_LAYER_POC_ALIGNMENT
1818	#if SHM_FIX7
1819	}
1820	#endif
1821	if( !pcSlice->getIdrPicFlag() )
1822	{
1823	#endif
1824	TComReferencePictureSet* rps = pcSlice->getRPS();
1825
1826	// check for bitstream restriction stating that:
1827	// If the current picture is a BLA or CRA picture, the value of NumPocTotalCurr shall be equal to 0.
1828	// Ideally this process should not be repeated for each slice in a picture
1829	#if SVC_EXTENSION
1830	if( pcSlice->getLayerId() == 0 )
1831	#endif
1832	if (pcSlice->isIRAP())
1833	{
1834	for (Int picIdx = 0; picIdx < rps->getNumberOfPictures(); picIdx++)
1835	{
1836	assert (!rps->getUsed(picIdx));
1837	}
1838	}
1839
1840	if(pcSlice->getRPSidx() < 0)
1841	{
1842	WRITE_FLAG( 0, "short_term_ref_pic_set_sps_flag");
1843	codeShortTermRefPicSet(pcSlice->getSPS(), rps, true, pcSlice->getSPS()->getRPSList()->getNumberOfReferencePictureSets());
1844	}
1845	else
1846	{
1847	WRITE_FLAG( 1, "short_term_ref_pic_set_sps_flag");
1848	Int numBits = 0;
1849	while ((1 << numBits) < pcSlice->getSPS()->getRPSList()->getNumberOfReferencePictureSets())
1850	{
1851	numBits++;
1852	}
1853	if (numBits > 0)
1854	{
1855	WRITE_CODE( pcSlice->getRPSidx(), numBits, "short_term_ref_pic_set_idx" );
1856	}
1857	}
1858	if(pcSlice->getSPS()->getLongTermRefsPresent())
1859	{
1860	Int numLtrpInSH = rps->getNumberOfLongtermPictures();
1861	Int ltrpInSPS[MAX_NUM_REF_PICS];
1862	Int numLtrpInSPS = 0;
1863	UInt ltrpIndex;
1864	Int counter = 0;
1865	for(Int k = rps->getNumberOfPictures()-1; k > rps->getNumberOfPictures()-rps->getNumberOfLongtermPictures()-1; k--)
1866	{
1867	if (findMatchingLTRP(pcSlice, &ltrpIndex, rps->getPOC(k), rps->getUsed(k)))
1868	{
1869	ltrpInSPS[numLtrpInSPS] = ltrpIndex;
1870	numLtrpInSPS++;
1871	}
1872	else
1873	{
1874	counter++;
1875	}
1876	}
1877	numLtrpInSH -= numLtrpInSPS;
1878
1879	Int bitsForLtrpInSPS = 0;
1880	while (pcSlice->getSPS()->getNumLongTermRefPicSPS() > (1 << bitsForLtrpInSPS))
1881	{
1882	bitsForLtrpInSPS++;
1883	}
1884	if (pcSlice->getSPS()->getNumLongTermRefPicSPS() > 0)
1885	{
1886	WRITE_UVLC( numLtrpInSPS, "num_long_term_sps");
1887	}
1888	WRITE_UVLC( numLtrpInSH, "num_long_term_pics");
1889	// Note that the LSBs of the LT ref. pic. POCs must be sorted before.
1890	// Not sorted here because LT ref indices will be used in setRefPicList()
1891	Int prevDeltaMSB = 0, prevLSB = 0;
1892	Int offset = rps->getNumberOfNegativePictures() + rps->getNumberOfPositivePictures();
1893	for(Int i=rps->getNumberOfPictures()-1 ; i > offset-1; i--)
1894	{
1895	if (counter < numLtrpInSPS)
1896	{
1897	if (bitsForLtrpInSPS > 0)
1898	{
1899	WRITE_CODE( ltrpInSPS[counter], bitsForLtrpInSPS, "lt_idx_sps[i]");
1900	}
1901	}
1902	else
1903	{
1904	WRITE_CODE( rps->getPocLSBLT(i), pcSlice->getSPS()->getBitsForPOC(), "poc_lsb_lt");
1905	WRITE_FLAG( rps->getUsed(i), "used_by_curr_pic_lt_flag");
1906	}
1907	WRITE_FLAG( rps->getDeltaPocMSBPresentFlag(i), "delta_poc_msb_present_flag");
1908
1909	if(rps->getDeltaPocMSBPresentFlag(i))
1910	{
1911	Bool deltaFlag = false;
1912	// First LTRP from SPS \|\| First LTRP from SH \|\| curr LSB != prev LSB
1913	if( (i == rps->getNumberOfPictures()-1) \|\| (i == rps->getNumberOfPictures()-1-numLtrpInSPS) \|\| (rps->getPocLSBLT(i) != prevLSB) )
1914	{
1915	deltaFlag = true;
1916	}
1917	if(deltaFlag)
1918	{
1919	WRITE_UVLC( rps->getDeltaPocMSBCycleLT(i), "delta_poc_msb_cycle_lt[i]" );
1920	}
1921	else
1922	{
1923	Int differenceInDeltaMSB = rps->getDeltaPocMSBCycleLT(i) - prevDeltaMSB;
1924	assert(differenceInDeltaMSB >= 0);
1925	WRITE_UVLC( differenceInDeltaMSB, "delta_poc_msb_cycle_lt[i]" );
1926	}
1927	prevLSB = rps->getPocLSBLT(i);
1928	prevDeltaMSB = rps->getDeltaPocMSBCycleLT(i);
1929	}
1930	}
1931	}
1932	if (pcSlice->getSPS()->getTMVPFlagsPresent())
1933	{
1934	WRITE_FLAG( pcSlice->getEnableTMVPFlag() ? 1 : 0, "slice_temporal_mvp_enable_flag" );
1935	}
1936	#if N0065_LAYER_POC_ALIGNMENT && !SHM_FIX7
1937	}
1938	#endif
1939	}
1940
1941	#if SVC_EXTENSION
1942	#if ILP_SSH_SIG
1943	#if ILP_SSH_SIG_FIX
1944	if((pcSlice->getLayerId() > 0) && !(pcSlice->getVPS()->getIlpSshSignalingEnabledFlag()) && (pcSlice->getNumILRRefIdx() > 0) )
1945	#else
1946	if((pcSlice->getLayerId() > 0) && pcSlice->getVPS()->getIlpSshSignalingEnabledFlag() && (pcSlice->getNumILRRefIdx() > 0) )
1947	#endif
1948	#else
1949	if((pcSlice->getLayerId() > 0) && (pcSlice->getNumILRRefIdx() > 0) )
1950	#endif
1951	{
1952	WRITE_FLAG(pcSlice->getInterLayerPredEnabledFlag(),"inter_layer_pred_enabled_flag");
1953	if( pcSlice->getInterLayerPredEnabledFlag())
1954	{
1955	if(pcSlice->getNumILRRefIdx() > 1)
1956	{
1957	Int numBits = 1;
1958	while ((1 << numBits) < pcSlice->getNumILRRefIdx())
1959	{
1960	numBits++;
1961	}
1962	if( !pcSlice->getVPS()->getMaxOneActiveRefLayerFlag())
1963	{
1964	WRITE_CODE(pcSlice->getActiveNumILRRefIdx() - 1, numBits,"num_inter_layer_ref_pics_minus1");
1965	}
1966	#if ILP_NUM_REF_CHK
1967	if( pcSlice->getNumILRRefIdx() != pcSlice->getActiveNumILRRefIdx() )
1968	{
1969	#endif
1970	for(Int i = 0; i < pcSlice->getActiveNumILRRefIdx(); i++ )
1971	{
1972	WRITE_CODE(pcSlice->getInterLayerPredLayerIdc(i),numBits,"inter_layer_pred_layer_idc[i]");
1973	}
1974	#if ILP_NUM_REF_CHK
1975	}
1976	#endif
1977	}
1978	}
1979	}
1980	#if P0312_VERT_PHASE_ADJ
1981	for(Int i = 0; i < pcSlice->getActiveNumILRRefIdx(); i++ )
1982	{
1983	UInt refLayerIdc = pcSlice->getInterLayerPredLayerIdc(i);
1984	if( pcSlice->getSPS()->getVertPhasePositionEnableFlag(refLayerIdc) )
1985	{
1986	WRITE_FLAG( pcSlice->getVertPhasePositionFlag(refLayerIdc), "vert_phase_position_flag" );
1987	}
1988	}
1989	#endif
1990	#endif //SVC_EXTENSION
1991
1992	if(pcSlice->getSPS()->getUseSAO())
1993	{
1994	if (pcSlice->getSPS()->getUseSAO())
1995	{
1996	WRITE_FLAG( pcSlice->getSaoEnabledFlag(), "slice_sao_luma_flag" );
1997	#if AUXILIARY_PICTURES
1998	if (pcSlice->getChromaFormatIdc() != CHROMA_400)
1999	#endif
2000	WRITE_FLAG( pcSlice->getSaoEnabledFlagChroma(), "slice_sao_chroma_flag" );
2001	}
2002	}
2003
2004	//check if numrefidxes match the defaults. If not, override
2005
2006	if (!pcSlice->isIntra())
2007	{
2008	Bool overrideFlag = (pcSlice->getNumRefIdx( REF_PIC_LIST_0 )!=pcSlice->getPPS()->getNumRefIdxL0DefaultActive()\|\|(pcSlice->isInterB()&&pcSlice->getNumRefIdx( REF_PIC_LIST_1 )!=pcSlice->getPPS()->getNumRefIdxL1DefaultActive()));
2009	WRITE_FLAG( overrideFlag ? 1 : 0, "num_ref_idx_active_override_flag");
2010	if (overrideFlag)
2011	{
2012	WRITE_UVLC( pcSlice->getNumRefIdx( REF_PIC_LIST_0 ) - 1, "num_ref_idx_l0_active_minus1" );
2013	if (pcSlice->isInterB())
2014	{
2015	WRITE_UVLC( pcSlice->getNumRefIdx( REF_PIC_LIST_1 ) - 1, "num_ref_idx_l1_active_minus1" );
2016	}
2017	else
2018	{
2019	pcSlice->setNumRefIdx(REF_PIC_LIST_1, 0);
2020	}
2021	}
2022	}
2023	else
2024	{
2025	pcSlice->setNumRefIdx(REF_PIC_LIST_0, 0);
2026	pcSlice->setNumRefIdx(REF_PIC_LIST_1, 0);
2027	}
2028
2029	if( pcSlice->getPPS()->getListsModificationPresentFlag() && pcSlice->getNumRpsCurrTempList() > 1)
2030	{
2031	TComRefPicListModification* refPicListModification = pcSlice->getRefPicListModification();
2032	if(!pcSlice->isIntra())
2033	{
2034	WRITE_FLAG(pcSlice->getRefPicListModification()->getRefPicListModificationFlagL0() ? 1 : 0, "ref_pic_list_modification_flag_l0" );
2035	if (pcSlice->getRefPicListModification()->getRefPicListModificationFlagL0())
2036	{
2037	Int numRpsCurrTempList0 = pcSlice->getNumRpsCurrTempList();
2038	if (numRpsCurrTempList0 > 1)
2039	{
2040	Int length = 1;
2041	numRpsCurrTempList0 --;
2042	while ( numRpsCurrTempList0 >>= 1)
2043	{
2044	length ++;
2045	}
2046	for(Int i = 0; i < pcSlice->getNumRefIdx( REF_PIC_LIST_0 ); i++)
2047	{
2048	WRITE_CODE( refPicListModification->getRefPicSetIdxL0(i), length, "list_entry_l0");
2049	}
2050	}
2051	}
2052	}
2053	if(pcSlice->isInterB())
2054	{
2055	WRITE_FLAG(pcSlice->getRefPicListModification()->getRefPicListModificationFlagL1() ? 1 : 0, "ref_pic_list_modification_flag_l1" );
2056	if (pcSlice->getRefPicListModification()->getRefPicListModificationFlagL1())
2057	{
2058	Int numRpsCurrTempList1 = pcSlice->getNumRpsCurrTempList();
2059	if ( numRpsCurrTempList1 > 1 )
2060	{
2061	Int length = 1;
2062	numRpsCurrTempList1 --;
2063	while ( numRpsCurrTempList1 >>= 1)
2064	{
2065	length ++;
2066	}
2067	for(Int i = 0; i < pcSlice->getNumRefIdx( REF_PIC_LIST_1 ); i++)
2068	{
2069	WRITE_CODE( refPicListModification->getRefPicSetIdxL1(i), length, "list_entry_l1");
2070	}
2071	}
2072	}
2073	}
2074	}
2075
2076	if (pcSlice->isInterB())
2077	{
2078	WRITE_FLAG( pcSlice->getMvdL1ZeroFlag() ? 1 : 0, "mvd_l1_zero_flag");
2079	}
2080
2081	if(!pcSlice->isIntra())
2082	{
2083	if (!pcSlice->isIntra() && pcSlice->getPPS()->getCabacInitPresentFlag())
2084	{
2085	SliceType sliceType = pcSlice->getSliceType();
2086	Int encCABACTableIdx = pcSlice->getPPS()->getEncCABACTableIdx();
2087	Bool encCabacInitFlag = (sliceType!=encCABACTableIdx && encCABACTableIdx!=I_SLICE) ? true : false;
2088	pcSlice->setCabacInitFlag( encCabacInitFlag );
2089	WRITE_FLAG( encCabacInitFlag?1:0, "cabac_init_flag" );
2090	}
2091	}
2092
2093	if ( pcSlice->getEnableTMVPFlag() )
2094	{
2095	if ( pcSlice->getSliceType() == B_SLICE )
2096	{
2097	WRITE_FLAG( pcSlice->getColFromL0Flag(), "collocated_from_l0_flag" );
2098	}
2099
2100	if ( pcSlice->getSliceType() != I_SLICE &&
2101	((pcSlice->getColFromL0Flag()==1 && pcSlice->getNumRefIdx(REF_PIC_LIST_0)>1)\|\|
2102	(pcSlice->getColFromL0Flag()==0 && pcSlice->getNumRefIdx(REF_PIC_LIST_1)>1)))
2103	{
2104	WRITE_UVLC( pcSlice->getColRefIdx(), "collocated_ref_idx" );
2105	}
2106	}
2107	if ( (pcSlice->getPPS()->getUseWP() && pcSlice->getSliceType()==P_SLICE) \|\| (pcSlice->getPPS()->getWPBiPred() && pcSlice->getSliceType()==B_SLICE) )
2108	{
2109	xCodePredWeightTable( pcSlice );
2110	}
2111	assert(pcSlice->getMaxNumMergeCand()<=MRG_MAX_NUM_CANDS);
2112	if (!pcSlice->isIntra())
2113	{
2114	WRITE_UVLC(MRG_MAX_NUM_CANDS - pcSlice->getMaxNumMergeCand(), "five_minus_max_num_merge_cand");
2115	}
2116	Int iCode = pcSlice->getSliceQp() - ( pcSlice->getPPS()->getPicInitQPMinus26() + 26 );
2117	WRITE_SVLC( iCode, "slice_qp_delta" );
2118	if (pcSlice->getPPS()->getSliceChromaQpFlag())
2119	{
2120	iCode = pcSlice->getSliceQpDeltaCb();
2121	WRITE_SVLC( iCode, "slice_qp_delta_cb" );
2122	iCode = pcSlice->getSliceQpDeltaCr();
2123	WRITE_SVLC( iCode, "slice_qp_delta_cr" );
2124	}
2125	if (pcSlice->getPPS()->getDeblockingFilterControlPresentFlag())
2126	{
2127	if (pcSlice->getPPS()->getDeblockingFilterOverrideEnabledFlag() )
2128	{
2129	WRITE_FLAG(pcSlice->getDeblockingFilterOverrideFlag(), "deblocking_filter_override_flag");
2130	}
2131	if (pcSlice->getDeblockingFilterOverrideFlag())
2132	{
2133	WRITE_FLAG(pcSlice->getDeblockingFilterDisable(), "slice_disable_deblocking_filter_flag");
2134	if(!pcSlice->getDeblockingFilterDisable())
2135	{
2136	WRITE_SVLC (pcSlice->getDeblockingFilterBetaOffsetDiv2(), "slice_beta_offset_div2");
2137	WRITE_SVLC (pcSlice->getDeblockingFilterTcOffsetDiv2(), "slice_tc_offset_div2");
2138	}
2139	}
2140	}
2141
2142	Bool isSAOEnabled = (!pcSlice->getSPS()->getUseSAO())?(false):(pcSlice->getSaoEnabledFlag()\|\|pcSlice->getSaoEnabledFlagChroma());
2143	Bool isDBFEnabled = (!pcSlice->getDeblockingFilterDisable());
2144
2145	if(pcSlice->getPPS()->getLoopFilterAcrossSlicesEnabledFlag() && ( isSAOEnabled \|\| isDBFEnabled ))
2146	{
2147	WRITE_FLAG(pcSlice->getLFCrossSliceBoundaryFlag()?1:0, "slice_loop_filter_across_slices_enabled_flag");
2148	}
2149	}
2150
2151	#if !POC_RESET_IDC_SIGNALLING // Wrong place to put slice header extension
2152	if(pcSlice->getPPS()->getSliceHeaderExtensionPresentFlag())
2153	{
2154	WRITE_UVLC(0,"slice_header_extension_length");
2155	}
2156	#endif
2157	}
2158
2159	Void TEncCavlc::codePTL( TComPTL* pcPTL, Bool profilePresentFlag, Int maxNumSubLayersMinus1)
2160	{
2161	if(profilePresentFlag)
2162	{
2163	codeProfileTier(pcPTL->getGeneralPTL()); // general_...
2164	}
2165	WRITE_CODE( pcPTL->getGeneralPTL()->getLevelIdc(), 8, "general_level_idc" );
2166
2167	for (Int i = 0; i < maxNumSubLayersMinus1; i++)
2168	{
2169	if(profilePresentFlag)
2170	{
2171	WRITE_FLAG( pcPTL->getSubLayerProfilePresentFlag(i), "sub_layer_profile_present_flag[i]" );
2172	}
2173
2174	WRITE_FLAG( pcPTL->getSubLayerLevelPresentFlag(i), "sub_layer_level_present_flag[i]" );
2175	}
2176
2177	if (maxNumSubLayersMinus1 > 0)
2178	{
2179	for (Int i = maxNumSubLayersMinus1; i < 8; i++)
2180	{
2181	WRITE_CODE(0, 2, "reserved_zero_2bits");
2182	}
2183	}
2184
2185	for(Int i = 0; i < maxNumSubLayersMinus1; i++)
2186	{
2187	if( profilePresentFlag && pcPTL->getSubLayerProfilePresentFlag(i) )
2188	{
2189	codeProfileTier(pcPTL->getSubLayerPTL(i)); // sub_layer_...
2190	}
2191	if( pcPTL->getSubLayerLevelPresentFlag(i) )
2192	{
2193	WRITE_CODE( pcPTL->getSubLayerPTL(i)->getLevelIdc(), 8, "sub_layer_level_idc[i]" );
2194	}
2195	}
2196	}
2197	Void TEncCavlc::codeProfileTier( ProfileTierLevel* ptl )
2198	{
2199	WRITE_CODE( ptl->getProfileSpace(), 2 , "XXX_profile_space[]");
2200	WRITE_FLAG( ptl->getTierFlag (), "XXX_tier_flag[]" );
2201	WRITE_CODE( ptl->getProfileIdc (), 5 , "XXX_profile_idc[]" );
2202	for(Int j = 0; j < 32; j++)
2203	{
2204	WRITE_FLAG( ptl->getProfileCompatibilityFlag(j), "XXX_profile_compatibility_flag[][j]");
2205	}
2206
2207	WRITE_FLAG(ptl->getProgressiveSourceFlag(), "general_progressive_source_flag");
2208	WRITE_FLAG(ptl->getInterlacedSourceFlag(), "general_interlaced_source_flag");
2209	WRITE_FLAG(ptl->getNonPackedConstraintFlag(), "general_non_packed_constraint_flag");
2210	WRITE_FLAG(ptl->getFrameOnlyConstraintFlag(), "general_frame_only_constraint_flag");
2211
2212	WRITE_CODE(0 , 16, "XXX_reserved_zero_44bits[0..15]");
2213	WRITE_CODE(0 , 16, "XXX_reserved_zero_44bits[16..31]");
2214	WRITE_CODE(0 , 12, "XXX_reserved_zero_44bits[32..43]");
2215	}
2216
2217	/**
2218	- write wavefront substreams sizes for the slice header.
2219	.
2220	\param pcSlice Where we find the substream size information.
2221	*/
2222	Void TEncCavlc::codeTilesWPPEntryPoint( TComSlice* pSlice )
2223	{
2224	if (!pSlice->getPPS()->getTilesEnabledFlag() && !pSlice->getPPS()->getEntropyCodingSyncEnabledFlag())
2225	{
2226	return;
2227	}
2228	UInt numEntryPointOffsets = 0, offsetLenMinus1 = 0, maxOffset = 0;
2229	Int numZeroSubstreamsAtStartOfSlice = 0;
2230	UInt *entryPointOffset = NULL;
2231	if ( pSlice->getPPS()->getTilesEnabledFlag() )
2232	{
2233	numEntryPointOffsets = pSlice->getTileLocationCount();
2234	entryPointOffset = new UInt[numEntryPointOffsets];
2235	for (Int idx=0; idx<pSlice->getTileLocationCount(); idx++)
2236	{
2237	if ( idx == 0 )
2238	{
2239	entryPointOffset [ idx ] = pSlice->getTileLocation( 0 );
2240	}
2241	else
2242	{
2243	entryPointOffset [ idx ] = pSlice->getTileLocation( idx ) - pSlice->getTileLocation( idx-1 );
2244	}
2245
2246	if ( entryPointOffset[ idx ] > maxOffset )
2247	{
2248	maxOffset = entryPointOffset[ idx ];
2249	}
2250	}
2251	}
2252	else if ( pSlice->getPPS()->getEntropyCodingSyncEnabledFlag() )
2253	{
2254	UInt* pSubstreamSizes = pSlice->getSubstreamSizes();
2255	Int maxNumParts = pSlice->getPic()->getNumPartInCU();
2256	numZeroSubstreamsAtStartOfSlice = pSlice->getSliceSegmentCurStartCUAddr()/maxNumParts/pSlice->getPic()->getFrameWidthInCU();
2257	Int numZeroSubstreamsAtEndOfSlice = pSlice->getPic()->getFrameHeightInCU()-1 - ((pSlice->getSliceSegmentCurEndCUAddr()-1)/maxNumParts/pSlice->getPic()->getFrameWidthInCU());
2258	numEntryPointOffsets = pSlice->getPPS()->getNumSubstreams() - numZeroSubstreamsAtStartOfSlice - numZeroSubstreamsAtEndOfSlice - 1;
2259	pSlice->setNumEntryPointOffsets(numEntryPointOffsets);
2260	entryPointOffset = new UInt[numEntryPointOffsets];
2261	for (Int idx=0; idx<numEntryPointOffsets; idx++)
2262	{
2263	entryPointOffset[ idx ] = ( pSubstreamSizes[ idx+numZeroSubstreamsAtStartOfSlice ] >> 3 ) ;
2264	if ( entryPointOffset[ idx ] > maxOffset )
2265	{
2266	maxOffset = entryPointOffset[ idx ];
2267	}
2268	}
2269	}
2270	// Determine number of bits "offsetLenMinus1+1" required for entry point information
2271	offsetLenMinus1 = 0;
2272	while (maxOffset >= (1u << (offsetLenMinus1 + 1)))
2273	{
2274	offsetLenMinus1++;
2275	assert(offsetLenMinus1 + 1 < 32);
2276	}
2277
2278	WRITE_UVLC(numEntryPointOffsets, "num_entry_point_offsets");
2279	if (numEntryPointOffsets>0)
2280	{
2281	WRITE_UVLC(offsetLenMinus1, "offset_len_minus1");
2282	}
2283
2284	for (UInt idx=0; idx<numEntryPointOffsets; idx++)
2285	{
2286	WRITE_CODE(entryPointOffset[ idx ]-1, offsetLenMinus1+1, "entry_point_offset_minus1");
2287	}
2288
2289	delete [] entryPointOffset;
2290	}
2291
2292	#if POC_RESET_IDC_SIGNALLING
2293	Void TEncCavlc::codeSliceHeaderExtn( TComSlice* slice, Int shBitsWrittenTillNow )
2294	{
2295	Int tmpBitsBeforeWriting = getNumberOfWrittenBits();
2296	if(slice->getPPS()->getSliceHeaderExtensionPresentFlag())
2297	{
2298	// Derive the value of PocMsbValRequiredFlag
2299	slice->setPocMsbValRequiredFlag( slice->getCraPicFlag() \|\| slice->getBlaPicFlag()
2300	/* \|\| related to vps_poc_lsb_aligned_flag */
2301	);
2302
2303	// Determine value of SH extension length.
2304	Int shExtnLengthInBit = 0;
2305	if (slice->getPPS()->getPocResetInfoPresentFlag())
2306	{
2307	shExtnLengthInBit += 2;
2308	}
2309	if (slice->getPocResetIdc() > 0)
2310	{
2311	shExtnLengthInBit += 6;
2312	}
2313	if (slice->getPocResetIdc() == 3)
2314	{
2315	shExtnLengthInBit += (slice->getSPS()->getBitsForPOC() + 1);
2316	}
2317
2318
2319	if( !slice->getPocMsbValRequiredFlag() /* && vps_poc_lsb_aligned_flag */ )
2320	{
2321	shExtnLengthInBit++;
2322	}
2323	else
2324	{
2325	if( slice->getPocMsbValRequiredFlag() )
2326	{
2327	slice->setPocMsbValPresentFlag( true );
2328	}
2329	else
2330	{
2331	slice->setPocMsbValPresentFlag( false );
2332	}
2333	}
2334
2335	if( slice->getPocMsbValPresentFlag() )
2336	{
2337	UInt lengthVal = 1;
2338	UInt tempVal = slice->getPocMsbVal() + 1;
2339	assert ( tempVal );
2340	while( 1 != tempVal )
2341	{
2342	tempVal >>= 1;
2343	lengthVal += 2;
2344	}
2345	shExtnLengthInBit += lengthVal;
2346	}
2347	Int shExtnAdditionalBits = 0;
2348	if(shExtnLengthInBit % 8 != 0)
2349	{
2350	shExtnAdditionalBits = 8 - (shExtnLengthInBit % 8);
2351	}
2352	Int shExtnLength = (shExtnLengthInBit + shExtnAdditionalBits) / 8;
2353	WRITE_UVLC( shExtnLength, "slice_header_extension_length" );
2354
2355	if(slice->getPPS()->getPocResetInfoPresentFlag())
2356	{
2357	WRITE_CODE( slice->getPocResetIdc(), 2, "poc_reset_idc");
2358	}
2359	if(slice->getPocResetIdc() > 0)
2360	{
2361	WRITE_CODE( slice->getPocResetPeriodId(), 6, "poc_reset_period_id");
2362	}
2363	if(slice->getPocResetIdc() == 3)
2364	{
2365	WRITE_FLAG( slice->getFullPocResetFlag() ? 1 : 0, "full_poc_reset_flag");
2366	WRITE_CODE( slice->getPocLsbVal(), slice->getSPS()->getBitsForPOC(), "poc_lsb_val");
2367	}
2368
2369	if( !slice->getPocMsbValRequiredFlag() /* && vps_poc_lsb_aligned_flag */ )
2370	{
2371	WRITE_FLAG( slice->getPocMsbValPresentFlag(), "poc_msb_val_present_flag" );
2372	}
2373	if( slice->getPocMsbValPresentFlag() )
2374	{
2375	WRITE_UVLC( slice->getPocMsbVal(), "poc_msb_val" );
2376	}
2377	for (Int i = 0; i < shExtnAdditionalBits; i++)
2378	{
2379	WRITE_FLAG( 1, "slice_segment_header_extension_reserved_bit");
2380	}
2381	}
2382	shBitsWrittenTillNow += ( getNumberOfWrittenBits() - tmpBitsBeforeWriting );
2383
2384	// Slice header byte_alignment() included in xAttachSliceDataToNalUnit
2385	}
2386	#endif
2387
2388	Void TEncCavlc::codeTerminatingBit ( UInt uilsLast )
2389	{
2390	}
2391
2392	Void TEncCavlc::codeSliceFinish ()
2393	{
2394	}
2395
2396	Void TEncCavlc::codeMVPIdx ( TComDataCU* pcCU, UInt uiAbsPartIdx, RefPicList eRefList )
2397	{
2398	assert(0);
2399	}
2400
2401	Void TEncCavlc::codePartSize( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
2402	{
2403	assert(0);
2404	}
2405
2406	Void TEncCavlc::codePredMode( TComDataCU* pcCU, UInt uiAbsPartIdx )
2407	{
2408	assert(0);
2409	}
2410
2411	Void TEncCavlc::codeMergeFlag ( TComDataCU* pcCU, UInt uiAbsPartIdx )
2412	{
2413	assert(0);
2414	}
2415
2416	Void TEncCavlc::codeMergeIndex ( TComDataCU* pcCU, UInt uiAbsPartIdx )
2417	{
2418	assert(0);
2419	}
2420
2421	Void TEncCavlc::codeInterModeFlag( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth, UInt uiEncMode )
2422	{
2423	assert(0);
2424	}
2425
2426	Void TEncCavlc::codeCUTransquantBypassFlag( TComDataCU* pcCU, UInt uiAbsPartIdx )
2427	{
2428	assert(0);
2429	}
2430
2431	Void TEncCavlc::codeSkipFlag( TComDataCU* pcCU, UInt uiAbsPartIdx )
2432	{
2433	assert(0);
2434	}
2435
2436	Void TEncCavlc::codeSplitFlag ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
2437	{
2438	assert(0);
2439	}
2440
2441	Void TEncCavlc::codeTransformSubdivFlag( UInt uiSymbol, UInt uiCtx )
2442	{
2443	assert(0);
2444	}
2445
2446	Void TEncCavlc::codeQtCbf( TComDataCU* pcCU, UInt uiAbsPartIdx, TextType eType, UInt uiTrDepth )
2447	{
2448	assert(0);
2449	}
2450
2451	Void TEncCavlc::codeQtRootCbf( TComDataCU* pcCU, UInt uiAbsPartIdx )
2452	{
2453	assert(0);
2454	}
2455
2456	Void TEncCavlc::codeQtCbfZero( TComDataCU* pcCU, TextType eType, UInt uiTrDepth )
2457	{
2458	assert(0);
2459	}
2460	Void TEncCavlc::codeQtRootCbfZero( TComDataCU* pcCU )
2461	{
2462	assert(0);
2463	}
2464
2465	Void TEncCavlc::codeTransformSkipFlags (TComDataCU* pcCU, UInt uiAbsPartIdx, UInt width, UInt height, TextType eTType )
2466	{
2467	assert(0);
2468	}
2469
2470	/** Code I_PCM information.
2471	* \param pcCU pointer to CU
2472	* \param uiAbsPartIdx CU index
2473	* \returns Void
2474	*/
2475	Void TEncCavlc::codeIPCMInfo( TComDataCU* pcCU, UInt uiAbsPartIdx )
2476	{
2477	assert(0);
2478	}
2479
2480	Void TEncCavlc::codeIntraDirLumaAng( TComDataCU* pcCU, UInt uiAbsPartIdx, Bool isMultiple)
2481	{
2482	assert(0);
2483	}
2484
2485	Void TEncCavlc::codeIntraDirChroma( TComDataCU* pcCU, UInt uiAbsPartIdx )
2486	{
2487	assert(0);
2488	}
2489
2490	Void TEncCavlc::codeInterDir( TComDataCU* pcCU, UInt uiAbsPartIdx )
2491	{
2492	assert(0);
2493	}
2494
2495	Void TEncCavlc::codeRefFrmIdx( TComDataCU* pcCU, UInt uiAbsPartIdx, RefPicList eRefList )
2496	{
2497	assert(0);
2498	}
2499
2500	Void TEncCavlc::codeMvd( TComDataCU* pcCU, UInt uiAbsPartIdx, RefPicList eRefList )
2501	{
2502	assert(0);
2503	}
2504
2505	Void TEncCavlc::codeDeltaQP( TComDataCU* pcCU, UInt uiAbsPartIdx )
2506	{
2507	Int iDQp = pcCU->getQP( uiAbsPartIdx ) - pcCU->getRefQP( uiAbsPartIdx );
2508
2509	#if REPN_FORMAT_IN_VPS
2510	Int qpBdOffsetY = pcCU->getSlice()->getQpBDOffsetY();
2511	#else
2512	Int qpBdOffsetY = pcCU->getSlice()->getSPS()->getQpBDOffsetY();
2513	#endif
2514	iDQp = (iDQp + 78 + qpBdOffsetY + (qpBdOffsetY/2)) % (52 + qpBdOffsetY) - 26 - (qpBdOffsetY/2);
2515
2516	xWriteSvlc( iDQp );
2517
2518	return;
2519	}
2520
2521	Void TEncCavlc::codeCoeffNxN ( TComDataCU* pcCU, TCoeff* pcCoef, UInt uiAbsPartIdx, UInt uiWidth, UInt uiHeight, UInt uiDepth, TextType eTType )
2522	{
2523	assert(0);
2524	}
2525
2526	Void TEncCavlc::estBit( estBitsSbacStruct* pcEstBitsCabac, Int width, Int height, TextType eTType )
2527	{
2528	// printf("error : no VLC mode support in this version\n");
2529	return;
2530	}
2531
2532	// ====================================================================================================================
2533	// Protected member functions
2534	// ====================================================================================================================
2535
2536	/** code explicit wp tables
2537	* \param TComSlice* pcSlice
2538	* \returns Void
2539	*/
2540	Void TEncCavlc::xCodePredWeightTable( TComSlice* pcSlice )
2541	{
2542	wpScalingParam *wp;
2543	Bool bChroma = true; // color always present in HEVC ?
2544	Int iNbRef = (pcSlice->getSliceType() == B_SLICE ) ? (2) : (1);
2545	Bool bDenomCoded = false;
2546	UInt uiMode = 0;
2547	UInt uiTotalSignalledWeightFlags = 0;
2548	#if AUXILIARY_PICTURES
2549	if (pcSlice->getChromaFormatIdc() == CHROMA_400)
2550	{
2551	bChroma = false;
2552	}
2553	#endif
2554	if ( (pcSlice->getSliceType()==P_SLICE && pcSlice->getPPS()->getUseWP()) \|\| (pcSlice->getSliceType()==B_SLICE && pcSlice->getPPS()->getWPBiPred()) )
2555	{
2556	uiMode = 1; // explicit
2557	}
2558	if(uiMode == 1)
2559	{
2560
2561	for ( Int iNumRef=0 ; iNumRef<iNbRef ; iNumRef++ )
2562	{
2563	RefPicList eRefPicList = ( iNumRef ? REF_PIC_LIST_1 : REF_PIC_LIST_0 );
2564
2565	for ( Int iRefIdx=0 ; iRefIdx<pcSlice->getNumRefIdx(eRefPicList) ; iRefIdx++ )
2566	{
2567	pcSlice->getWpScaling(eRefPicList, iRefIdx, wp);
2568	if ( !bDenomCoded )
2569	{
2570	Int iDeltaDenom;
2571	WRITE_UVLC( wp[0].uiLog2WeightDenom, "luma_log2_weight_denom" ); // ue(v): luma_log2_weight_denom
2572
2573	if( bChroma )
2574	{
2575	iDeltaDenom = (wp[1].uiLog2WeightDenom - wp[0].uiLog2WeightDenom);
2576	WRITE_SVLC( iDeltaDenom, "delta_chroma_log2_weight_denom" ); // se(v): delta_chroma_log2_weight_denom
2577	}
2578	bDenomCoded = true;
2579	}
2580	WRITE_FLAG( wp[0].bPresentFlag, "luma_weight_lX_flag" ); // u(1): luma_weight_lX_flag
2581	uiTotalSignalledWeightFlags += wp[0].bPresentFlag;
2582	}
2583	if (bChroma)
2584	{
2585	for ( Int iRefIdx=0 ; iRefIdx<pcSlice->getNumRefIdx(eRefPicList) ; iRefIdx++ )
2586	{
2587	pcSlice->getWpScaling(eRefPicList, iRefIdx, wp);
2588	WRITE_FLAG( wp[1].bPresentFlag, "chroma_weight_lX_flag" ); // u(1): chroma_weight_lX_flag
2589	uiTotalSignalledWeightFlags += 2*wp[1].bPresentFlag;
2590	}
2591	}
2592
2593	for ( Int iRefIdx=0 ; iRefIdx<pcSlice->getNumRefIdx(eRefPicList) ; iRefIdx++ )
2594	{
2595	pcSlice->getWpScaling(eRefPicList, iRefIdx, wp);
2596	if ( wp[0].bPresentFlag )
2597	{
2598	Int iDeltaWeight = (wp[0].iWeight - (1<<wp[0].uiLog2WeightDenom));
2599	WRITE_SVLC( iDeltaWeight, "delta_luma_weight_lX" ); // se(v): delta_luma_weight_lX
2600	WRITE_SVLC( wp[0].iOffset, "luma_offset_lX" ); // se(v): luma_offset_lX
2601	}
2602
2603	if ( bChroma )
2604	{
2605	if ( wp[1].bPresentFlag )
2606	{
2607	for ( Int j=1 ; j<3 ; j++ )
2608	{
2609	Int iDeltaWeight = (wp[j].iWeight - (1<<wp[1].uiLog2WeightDenom));
2610	WRITE_SVLC( iDeltaWeight, "delta_chroma_weight_lX" ); // se(v): delta_chroma_weight_lX
2611
2612	Int pred = ( 128 - ( ( 128*wp[j].iWeight)>>(wp[j].uiLog2WeightDenom) ) );
2613	Int iDeltaChroma = (wp[j].iOffset - pred);
2614	WRITE_SVLC( iDeltaChroma, "delta_chroma_offset_lX" ); // se(v): delta_chroma_offset_lX
2615	}
2616	}
2617	}
2618	}
2619	}
2620	assert(uiTotalSignalledWeightFlags<=24);
2621	}
2622	}
2623
2624	/** code quantization matrix
2625	* \param scalingList quantization matrix information
2626	*/
2627	Void TEncCavlc::codeScalingList( TComScalingList* scalingList )
2628	{
2629	UInt listId,sizeId;
2630	Bool scalingListPredModeFlag;
2631
2632	//for each size
2633	for(sizeId = 0; sizeId < SCALING_LIST_SIZE_NUM; sizeId++)
2634	{
2635	for(listId = 0; listId < g_scalingListNum[sizeId]; listId++)
2636	{
2637	scalingListPredModeFlag = scalingList->checkPredMode( sizeId, listId );
2638	WRITE_FLAG( scalingListPredModeFlag, "scaling_list_pred_mode_flag" );
2639	if(!scalingListPredModeFlag)// Copy Mode
2640	{
2641	WRITE_UVLC( (Int)listId - (Int)scalingList->getRefMatrixId (sizeId,listId), "scaling_list_pred_matrix_id_delta");
2642	}
2643	else// DPCM Mode
2644	{
2645	xCodeScalingList(scalingList, sizeId, listId);
2646	}
2647	}
2648	}
2649	return;
2650	}
2651	/** code DPCM
2652	* \param scalingList quantization matrix information
2653	* \param sizeIdc size index
2654	* \param listIdc list index
2655	*/
2656	Void TEncCavlc::xCodeScalingList(TComScalingList* scalingList, UInt sizeId, UInt listId)
2657	{
2658	Int coefNum = min(MAX_MATRIX_COEF_NUM,(Int)g_scalingListSize[sizeId]);
2659	UInt* scan = (sizeId == 0) ? g_auiSigLastScan [ SCAN_DIAG ] [ 1 ] : g_sigLastScanCG32x32;
2660	Int nextCoef = SCALING_LIST_START_VALUE;
2661	Int data;
2662	Int *src = scalingList->getScalingListAddress(sizeId, listId);
2663	if( sizeId > SCALING_LIST_8x8 )
2664	{
2665	WRITE_SVLC( scalingList->getScalingListDC(sizeId,listId) - 8, "scaling_list_dc_coef_minus8");
2666	nextCoef = scalingList->getScalingListDC(sizeId,listId);
2667	}
2668	for(Int i=0;i<coefNum;i++)
2669	{
2670	data = src[scan[i]] - nextCoef;
2671	nextCoef = src[scan[i]];
2672	if(data > 127)
2673	{
2674	data = data - 256;
2675	}
2676	if(data < -128)
2677	{
2678	data = data + 256;
2679	}
2680
2681	WRITE_SVLC( data, "scaling_list_delta_coef");
2682	}
2683	}
2684	Bool TEncCavlc::findMatchingLTRP ( TComSlice* pcSlice, UInt *ltrpsIndex, Int ltrpPOC, Bool usedFlag )
2685	{
2686	// Bool state = true, state2 = false;
2687	Int lsb = ltrpPOC & ((1<<pcSlice->getSPS()->getBitsForPOC())-1);
2688	for (Int k = 0; k < pcSlice->getSPS()->getNumLongTermRefPicSPS(); k++)
2689	{
2690	if ( (lsb == pcSlice->getSPS()->getLtRefPicPocLsbSps(k)) && (usedFlag == pcSlice->getSPS()->getUsedByCurrPicLtSPSFlag(k)) )
2691	{
2692	*ltrpsIndex = k;
2693	return true;
2694	}
2695	}
2696	return false;
2697	}
2698	Bool TComScalingList::checkPredMode(UInt sizeId, UInt listId)
2699	{
2700	for(Int predListIdx = (Int)listId ; predListIdx >= 0; predListIdx--)
2701	{
2702	if( !memcmp(getScalingListAddress(sizeId,listId),((listId == predListIdx) ?
2703	getScalingListDefaultAddress(sizeId, predListIdx): getScalingListAddress(sizeId, predListIdx)),sizeof(Int)*min(MAX_MATRIX_COEF_NUM,(Int)g_scalingListSize[sizeId])) // check value of matrix
2704	&& ((sizeId < SCALING_LIST_16x16) \|\| (getScalingListDC(sizeId,listId) == getScalingListDC(sizeId,predListIdx)))) // check DC value
2705	{
2706	setRefMatrixId(sizeId, listId, predListIdx);
2707	return false;
2708	}
2709	}
2710	return true;
2711	}
2712
2713	#if Q0048_CGS_3D_ASYMLUT
2714	Void TEncCavlc::xCode3DAsymLUT( TCom3DAsymLUT * pc3DAsymLUT )
2715	{
2716	assert( pc3DAsymLUT->getCurOctantDepth() < 4 );
2717	WRITE_CODE( pc3DAsymLUT->getCurOctantDepth() , 2 , "cm_octant_depth" );
2718	assert( pc3DAsymLUT->getCurYPartNumLog2() < 4 );
2719	WRITE_CODE( pc3DAsymLUT->getCurYPartNumLog2() , 2 , "cm_y_part_num_log2" );
2720	assert( pc3DAsymLUT->getInputBitDepthY() < 16 );
2721	WRITE_CODE( pc3DAsymLUT->getInputBitDepthY() - 8 , 3 , "cm_input_bit_depth_minus8" );
2722	WRITE_SVLC(pc3DAsymLUT->getInputBitDepthC()-pc3DAsymLUT->getInputBitDepthY(), "cm_input_bit_depth_chroma delta");
2723	assert( pc3DAsymLUT->getOutputBitDepthY() < 16 );
2724	WRITE_CODE( pc3DAsymLUT->getOutputBitDepthY() - 8 , 3 , "cm_output_bit_depth_minus8" );
2725	WRITE_SVLC(pc3DAsymLUT->getOutputBitDepthC()-pc3DAsymLUT->getOutputBitDepthY(), "cm_output_bit_depth_chroma_delta");
2726	assert( pc3DAsymLUT->getResQuantBit() < 4 );
2727	WRITE_CODE( pc3DAsymLUT->getResQuantBit() , 2 , "cm_res_quant_bit" );
2728
2729	xCode3DAsymLUTOctant( pc3DAsymLUT , 0 , 0 , 0 , 0 , 1 << pc3DAsymLUT->getCurOctantDepth() );
2730	}
2731
2732	Void TEncCavlc::xCode3DAsymLUTOctant( TCom3DAsymLUT * pc3DAsymLUT , Int nDepth , Int yIdx , Int uIdx , Int vIdx , Int nLength )
2733	{
2734	UInt uiOctantSplit = nDepth < pc3DAsymLUT->getCurOctantDepth();
2735	if( nDepth < pc3DAsymLUT->getCurOctantDepth() )
2736	WRITE_FLAG( uiOctantSplit , "split_octant_flag" );
2737	Int nYPartNum = 1 << pc3DAsymLUT->getCurYPartNumLog2();
2738	if( uiOctantSplit )
2739	{
2740	Int nHalfLength = nLength >> 1;
2741	for( Int l = 0 ; l < 2 ; l++ )
2742	{
2743	for( Int m = 0 ; m < 2 ; m++ )
2744	{
2745	for( Int n = 0 ; n < 2 ; n++ )
2746	{
2747	xCode3DAsymLUTOctant( pc3DAsymLUT , nDepth + 1 , yIdx + l * nHalfLength * nYPartNum , uIdx + m * nHalfLength , vIdx + n * nHalfLength , nHalfLength );
2748	}
2749	}
2750	}
2751	}
2752	else
2753	{
2754	for( Int l = 0 ; l < nYPartNum ; l++ )
2755	{
2756	for( Int nVertexIdx = 0 ; nVertexIdx < 4 ; nVertexIdx++ )
2757	{
2758	SYUVP sRes = pc3DAsymLUT->getCuboidVertexResTree( yIdx + l , uIdx , vIdx , nVertexIdx );
2759	UInt uiCodeVertex = sRes.Y != 0 \|\| sRes.U != 0 \|\| sRes.V != 0;
2760	WRITE_FLAG( uiCodeVertex , "coded_vertex_flag" );
2761	if( uiCodeVertex )
2762	{
2763	WRITE_SVLC( sRes.Y , "resY" );
2764	WRITE_SVLC( sRes.U , "resU" );
2765	WRITE_SVLC( sRes.V , "resV" );
2766	}
2767	}
2768	}
2769	}
2770	}
2771	#endif
2772	//! \}

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

Download in other formats: