Context navigation

← Previous revision
Next revision →
Blame
Revision log

TEncCavlc.cpp

Visit:

Last change on this file was 152, checked in by lg, 12 years ago
integration of JCT3V-B0045. cleanup of defined, valued but not used variable "uiPrevTexPartIndex" in function xCompressCU. This cleanup is made to pass the compiling in Linux.
Property svn:eol-style set to `native`
File size: 66.6 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-2012, 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	#define WRITE_CODE( value, length, name) xWriteCodeTr ( value, length, name )
48	#define WRITE_UVLC( value, name) xWriteUvlcTr ( value, name )
49	#define WRITE_SVLC( value, name) xWriteSvlcTr ( value, name )
50	#define WRITE_FLAG( value, name) xWriteFlagTr ( value, name )
51
52	Void xWriteUvlcTr ( UInt value, const Char *pSymbolName);
53	Void xWriteSvlcTr ( Int value, const Char *pSymbolName);
54	Void xWriteFlagTr ( UInt value, const Char *pSymbolName);
55
56	Void xTraceSPSHeader (TComSPS *pSPS)
57	{
58	fprintf( g_hTrace, "=========== Sequence Parameter Set ID: %d ===========\n", pSPS->getSPSId() );
59	}
60
61	Void xTracePPSHeader (TComPPS *pPPS)
62	{
63	fprintf( g_hTrace, "=========== Picture Parameter Set ID: %d ===========\n", pPPS->getPPSId() );
64	}
65
66	Void xTraceAPSHeader (TComAPS *pAPS)
67	{
68	fprintf( g_hTrace, "=========== Adaptation Parameter Set ===========\n");
69	}
70
71	Void xTraceSliceHeader (TComSlice *pSlice)
72	{
73	fprintf( g_hTrace, "=========== Slice ===========\n");
74	}
75
76
77	Void TEncCavlc::xWriteCodeTr (UInt value, UInt length, const Char *pSymbolName)
78	{
79	xWriteCode (value,length);
80	fprintf( g_hTrace, "%8lld ", g_nSymbolCounter++ );
81	fprintf( g_hTrace, "%-40s u(%d) : %d\n", pSymbolName, length, value );
82	}
83
84	Void TEncCavlc::xWriteUvlcTr (UInt value, const Char *pSymbolName)
85	{
86	xWriteUvlc (value);
87	fprintf( g_hTrace, "%8lld ", g_nSymbolCounter++ );
88	fprintf( g_hTrace, "%-40s u(v) : %d\n", pSymbolName, value );
89	}
90
91	Void TEncCavlc::xWriteSvlcTr (Int value, const Char *pSymbolName)
92	{
93	xWriteSvlc(value);
94	fprintf( g_hTrace, "%8lld ", g_nSymbolCounter++ );
95	fprintf( g_hTrace, "%-40s s(v) : %d\n", pSymbolName, value );
96	}
97
98	Void TEncCavlc::xWriteFlagTr(UInt value, const Char *pSymbolName)
99	{
100	xWriteFlag(value);
101	fprintf( g_hTrace, "%8lld ", g_nSymbolCounter++ );
102	fprintf( g_hTrace, "%-40s u(1) : %d\n", pSymbolName, value );
103	}
104
105	#else
106
107	#define WRITE_CODE( value, length, name) xWriteCode ( value, length )
108	#define WRITE_UVLC( value, name) xWriteUvlc ( value )
109	#define WRITE_SVLC( value, name) xWriteSvlc ( value )
110	#define WRITE_FLAG( value, name) xWriteFlag ( value )
111
112	#endif
113
114
115
116	// ====================================================================================================================
117	// Constructor / destructor / create / destroy
118	// ====================================================================================================================
119
120	TEncCavlc::TEncCavlc()
121	{
122	m_pcBitIf = NULL;
123	m_uiCoeffCost = 0;
124	m_bAlfCtrl = false;
125	m_uiMaxAlfCtrlDepth = 0;
126
127	m_iSliceGranularity = 0;
128	}
129
130	TEncCavlc::~TEncCavlc()
131	{
132	}
133
134
135	// ====================================================================================================================
136	// Public member functions
137	// ====================================================================================================================
138
139	Void TEncCavlc::resetEntropy()
140	{
141	}
142
143	/**
144	* marshall the SEI message sei.
145	*/
146	void TEncCavlc::codeSEI(const SEI& sei)
147	{
148	writeSEImessage(*m_pcBitIf, sei);
149	}
150
151	Void TEncCavlc::codeAPSInitInfo(TComAPS* pcAPS)
152	{
153
154	#if ENC_DEC_TRACE
155	xTraceAPSHeader(pcAPS);
156	#endif
157	//APS ID
158	WRITE_UVLC( pcAPS->getAPSID(), "aps_id" );
159
160	WRITE_FLAG( pcAPS->getScalingListEnabled()?1:0, "aps_scaling_list_data_present_flag");
161	//DF flag
162	WRITE_FLAG(pcAPS->getLoopFilterOffsetInAPS()?1:0, "aps_deblocking_filter_flag");
163	#if !SAO_UNIT_INTERLEAVING
164	//SAO flag
165	WRITE_FLAG( pcAPS->getSaoEnabled()?1:0, "aps_sample_adaptive_offset_flag");
166	#endif
167	#if !LCU_SYNTAX_ALF
168	//ALF flag
169	WRITE_FLAG( pcAPS->getAlfEnabled()?1:0, "aps_adaptive_loop_filter_flag");
170	#endif
171	}
172	#if LCU_SYNTAX_ALF
173	Void TEncCavlc::codeAPSAlflag(UInt uiCode)
174	{
175	WRITE_FLAG(uiCode, "aps_adaptive_loop_filter_flag");
176	}
177	#endif
178
179	Void TEncCavlc::codeDFFlag(UInt uiCode, const Char *pSymbolName)
180	{
181	WRITE_FLAG(uiCode, pSymbolName);
182	}
183	Void TEncCavlc::codeDFSvlc(Int iCode, const Char *pSymbolName)
184	{
185	WRITE_SVLC(iCode, pSymbolName);
186	}
187
188	#if RPS_IN_SPS
189	Void TEncCavlc::codeShortTermRefPicSet( TComSPS* pcSPS, TComReferencePictureSet* rps )
190	#else
191	Void TEncCavlc::codeShortTermRefPicSet( TComPPS* pcPPS, TComReferencePictureSet* rps )
192	#endif
193	{
194	#if PRINT_RPS_INFO
195	int lastBits = getNumberOfWrittenBits();
196	#endif
197	WRITE_FLAG( rps->getInterRPSPrediction(), "inter_ref_pic_set_prediction_flag" ); // inter_RPS_prediction_flag
198	if (rps->getInterRPSPrediction())
199	{
200	Int deltaRPS = rps->getDeltaRPS();
201	WRITE_UVLC( rps->getDeltaRIdxMinus1(), "delta_idx_minus1" ); // delta index of the Reference Picture Set used for prediction minus 1
202	WRITE_CODE( (deltaRPS >=0 ? 0: 1), 1, "delta_rps_sign" ); //delta_rps_sign
203	WRITE_UVLC( abs(deltaRPS) - 1, "abs_delta_rps_minus1"); // absolute delta RPS minus 1
204
205	for(Int j=0; j < rps->getNumRefIdc(); j++)
206	{
207	Int refIdc = rps->getRefIdc(j);
208	WRITE_CODE( (refIdc==1? 1: 0), 1, "used_by_curr_pic_flag" ); //first bit is "1" if Idc is 1
209	if (refIdc != 1)
210	{
211	WRITE_CODE( refIdc>>1, 1, "use_delta_flag" ); //second bit is "1" if Idc is 2, "0" otherwise.
212	}
213	}
214	}
215	else
216	{
217	WRITE_UVLC( rps->getNumberOfNegativePictures(), "num_negative_pics" );
218	WRITE_UVLC( rps->getNumberOfPositivePictures(), "num_positive_pics" );
219	Int prev = 0;
220	for(Int j=0 ; j < rps->getNumberOfNegativePictures(); j++)
221	{
222	WRITE_UVLC( prev-rps->getDeltaPOC(j)-1, "delta_poc_s0_minus1" );
223	prev = rps->getDeltaPOC(j);
224	WRITE_FLAG( rps->getUsed(j), "used_by_curr_pic_s0_flag");
225	}
226	prev = 0;
227	for(Int j=rps->getNumberOfNegativePictures(); j < rps->getNumberOfNegativePictures()+rps->getNumberOfPositivePictures(); j++)
228	{
229	WRITE_UVLC( rps->getDeltaPOC(j)-prev-1, "delta_poc_s1_minus1" );
230	prev = rps->getDeltaPOC(j);
231	WRITE_FLAG( rps->getUsed(j), "used_by_curr_pic_s1_flag" );
232	}
233	}
234
235	#if PRINT_RPS_INFO
236	printf("irps=%d (%2d bits) ", rps->getInterRPSPrediction(), getNumberOfWrittenBits() - lastBits);
237	rps->printDeltaPOC();
238	#endif
239	}
240
241
242	Void TEncCavlc::codePPS( TComPPS* pcPPS )
243	{
244	#if ENC_DEC_TRACE
245	xTracePPSHeader (pcPPS);
246	#endif
247	#if !RPS_IN_SPS
248	TComRPSList* rpsList = pcPPS->getRPSList();
249	#endif
250
251	WRITE_UVLC( pcPPS->getPPSId(), "pic_parameter_set_id" );
252	WRITE_UVLC( pcPPS->getSPSId(), "seq_parameter_set_id" );
253
254	#if MULTIBITS_DATA_HIDING
255	WRITE_FLAG( pcPPS->getSignHideFlag(), "sign_data_hiding_flag" );
256	if( pcPPS->getSignHideFlag() )
257	{
258	WRITE_CODE(pcPPS->getTSIG(), 4, "sign_hiding_threshold");
259	}
260	#endif
261	#if CABAC_INIT_FLAG
262	WRITE_FLAG( pcPPS->getCabacInitPresentFlag() ? 1 : 0, "cabac_init_present_flag" );
263	#endif
264	#if !RPS_IN_SPS
265	// RPS is put before entropy_coding_mode_flag
266	// since entropy_coding_mode_flag will probably be removed from the WD
267	TComReferencePictureSet* rps;
268
269	WRITE_UVLC(rpsList->getNumberOfReferencePictureSets(), "num_short_term_ref_pic_sets" );
270	for(UInt i=0; i < rpsList->getNumberOfReferencePictureSets(); i++)
271	{
272	rps = rpsList->getReferencePictureSet(i);
273	codeShortTermRefPicSet(pcPPS,rps);
274	}
275	WRITE_FLAG( pcPPS->getLongTermRefsPresent() ? 1 : 0, "long_term_ref_pics_present_flag" );
276	#endif
277	// entropy_coding_mode_flag
278	// We code the entropy_coding_mode_flag, it's needed for tests.
279	WRITE_FLAG( pcPPS->getEntropyCodingMode() ? 1 : 0, "entropy_coding_mode_flag" );
280	if (pcPPS->getEntropyCodingMode())
281	{
282	#if !WPP_SIMPLIFICATION
283	WRITE_UVLC( pcPPS->getEntropyCodingSynchro(), "entropy_coding_synchro" );
284	WRITE_FLAG( pcPPS->getCabacIstateReset() ? 1 : 0, "cabac_istate_reset" );
285	#endif
286	#if !TILES_OR_ENTROPY_SYNC_IDC
287	#if !WPP_SIMPLIFICATION
288	if ( pcPPS->getEntropyCodingSynchro() )
289	#endif
290	{
291	WRITE_UVLC( pcPPS->getNumSubstreams()-1, "num_substreams_minus1" );
292	}
293	#endif
294	}
295	#if !H0566_TLA
296	WRITE_UVLC( pcPPS->getNumTLayerSwitchingFlags(), "num_temporal_layer_switching_point_flags" );
297	for( UInt i = 0; i < pcPPS->getNumTLayerSwitchingFlags(); i++ )
298	{
299	WRITE_FLAG( pcPPS->getTLayerSwitchingFlag( i ) ? 1 : 0 , "temporal_layer_switching_point_flag" );
300	}
301	#endif
302	// num_ref_idx_l0_default_active_minus1
303	// num_ref_idx_l1_default_active_minus1
304	WRITE_SVLC( pcPPS->getPicInitQPMinus26(), "pic_init_qp_minus26");
305	WRITE_FLAG( pcPPS->getConstrainedIntraPred() ? 1 : 0, "constrained_intra_pred_flag" );
306	WRITE_FLAG( pcPPS->getEnableTMVPFlag() ? 1 : 0, "enable_temporal_mvp_flag" );
307	WRITE_CODE( pcPPS->getSliceGranularity(), 2, "slice_granularity");
308	WRITE_UVLC( pcPPS->getMaxCuDQPDepth() + pcPPS->getUseDQP(), "max_cu_qp_delta_depth" );
309
310	WRITE_SVLC( pcPPS->getChromaQpOffset(), "chroma_qp_offset" );
311	WRITE_SVLC( pcPPS->getChromaQpOffset2nd(), "chroma_qp_offset_2nd" );
312
313	WRITE_FLAG( pcPPS->getUseWP() ? 1 : 0, "weighted_pred_flag" ); // Use of Weighting Prediction (P_SLICE)
314	WRITE_CODE( pcPPS->getWPBiPredIdc(), 2, "weighted_bipred_idc" ); // Use of Weighting Bi-Prediction (B_SLICE)
315	#if H0388
316	WRITE_FLAG( pcPPS->getOutputFlagPresentFlag() ? 1 : 0, "output_flag_present_flag" );
317	#endif
318	#if TILES_OR_ENTROPY_SYNC_IDC
319	if(pcPPS->getSPS()->getTilesOrEntropyCodingSyncIdc()==1)
320	{
321	#endif
322	WRITE_FLAG( pcPPS->getColumnRowInfoPresent(), "tile_info_present_flag" );
323	WRITE_FLAG( pcPPS->getTileBehaviorControlPresentFlag(), "tile_control_present_flag");
324	if( pcPPS->getColumnRowInfoPresent() == 1 )
325	{
326	WRITE_UVLC( pcPPS->getNumColumnsMinus1(), "num_tile_columns_minus1" );
327	WRITE_UVLC( pcPPS->getNumRowsMinus1(), "num_tile_rows_minus1" );
328	WRITE_FLAG( pcPPS->getUniformSpacingIdr(), "uniform_spacing_flag" );
329	if( pcPPS->getUniformSpacingIdr() == 0 )
330	{
331	for(UInt i=0; i<pcPPS->getNumColumnsMinus1(); i++)
332	{
333	WRITE_UVLC( pcPPS->getColumnWidth(i), "column_width" );
334	}
335	for(UInt i=0; i<pcPPS->getNumRowsMinus1(); i++)
336	{
337	WRITE_UVLC( pcPPS->getRowHeight(i), "row_height" );
338	}
339	}
340	}
341
342	if(pcPPS->getTileBehaviorControlPresentFlag() == 1)
343	{
344	Int iNumColTilesMinus1 = (pcPPS->getColumnRowInfoPresent() == 1)?(pcPPS->getNumColumnsMinus1()):(pcPPS->getSPS()->getNumColumnsMinus1());
345	Int iNumRowTilesMinus1 = (pcPPS->getColumnRowInfoPresent() == 1)?(pcPPS->getNumColumnsMinus1()):(pcPPS->getSPS()->getNumRowsMinus1());
346
347	if(iNumColTilesMinus1 !=0 \|\| iNumRowTilesMinus1 !=0)
348	{
349	#if !REMOVE_TILE_DEPENDENCE
350	WRITE_FLAG( pcPPS->getTileBoundaryIndependenceIdr(), "tile_boundary_independence_flag" );
351	if(pcPPS->getTileBoundaryIndependenceIdr() == 1)
352	{
353	#endif
354	WRITE_FLAG( pcPPS->getLFCrossTileBoundaryFlag()?1 : 0, "loop_filter_across_tile_flag");
355	#if !REMOVE_TILE_DEPENDENCE
356	}
357	#endif
358	}
359	}
360	#if TILES_OR_ENTROPY_SYNC_IDC
361	}
362	else if(pcPPS->getSPS()->getTilesOrEntropyCodingSyncIdc()==2)
363	{
364	WRITE_UVLC( pcPPS->getNumSubstreams()-1, "num_substreams_minus1" );
365	}
366	#endif
367
368	#if DBL_CONTROL
369	WRITE_FLAG( pcPPS->getDeblockingFilterControlPresent()?1 : 0, "deblocking_filter_control_present_flag");
370	#endif
371	#if PARALLEL_MERGE
372	WRITE_UVLC( pcPPS->getLog2ParallelMergeLevelMinus2(), "log2_parallel_merge_level_minus2");
373	#endif
374	WRITE_FLAG( 0, "pps_extension_flag" );
375	}
376
377	#if VIDYO_VPS_INTEGRATION
378	Void TEncCavlc::codeVPS( TComVPS* pcVPS )
379	{
380	WRITE_CODE( pcVPS->getMaxTLayers() - 1, 3, "max_temporal_layers_minus1" );
381	WRITE_CODE( pcVPS->getMaxLayers() - 1, 5, "max_layers_minus1" );
382	WRITE_FLAG( pcVPS->getTemporalNestingFlag() - 1, "temporal_id_nesting_flag" );
383	WRITE_UVLC( pcVPS->getVPSId(), "video_parameter_set_id" );
384	for(UInt i=0; i <= pcVPS->getMaxTLayers()-1; i++)
385	{
386	WRITE_UVLC( pcVPS->getMaxDecPicBuffering(i), "max_dec_pic_buffering[i]" );
387	WRITE_UVLC( pcVPS->getNumReorderPics(i), "num_reorder_pics[i]" );
388	WRITE_UVLC( pcVPS->getMaxLatencyIncrease(i), "max_latency_increase[i]" );
389	}
390
391	WRITE_CODE( 1, 1, "bit_equal_to_one" );
392
393	if( pcVPS->getMaxLayers() - 1 > 0 )
394	{
395	WRITE_UVLC( pcVPS->getExtensionType(), "extension_type" );
396
397	for(UInt i=1; i <= pcVPS->getMaxLayers()-1; i++)
398	{
399	WRITE_FLAG( pcVPS->getDependentFlag(i), "dependent_flag[i]" );
400	if( pcVPS->getDependentFlag(i) )
401	{
402	WRITE_UVLC( i - pcVPS->getDependentLayer(i) - 1, "delta_reference_layer_id_minus1[i]" );
403	if( pcVPS->getExtensionType() == VPS_EXTENSION_TYPE_MULTI_VIEW )
404	{
405	WRITE_UVLC( pcVPS->getViewId(i), "view_id[i]" );
406	WRITE_FLAG( pcVPS->getDepthFlag(i), "depth_flag[i]" );
407	WRITE_SVLC( pcVPS->getViewOrderIdx(i), "view_order_idx[i]" );
408	}
409
410	}
411	}
412	}
413
414	WRITE_FLAG( 0, "vps_extension_flag" );
415
416	//future extensions here..
417
418	return;
419	}
420	#endif
421
422	#if HHI_MPI
423	Void TEncCavlc::codeSPS( TComSPS* pcSPS, Bool bIsDepth )
424	#else
425	Void TEncCavlc::codeSPS( TComSPS* pcSPS )
426	#endif
427	{
428	#if ENC_DEC_TRACE
429	xTraceSPSHeader (pcSPS);
430	#endif
431	WRITE_CODE( pcSPS->getProfileIdc (), 8, "profile_idc" );
432	WRITE_CODE( 0, 8, "reserved_zero_8bits" );
433	WRITE_CODE( pcSPS->getLevelIdc (), 8, "level_idc" );
434	WRITE_UVLC( pcSPS->getSPSId (), "seq_parameter_set_id" );
435	#if VIDYO_VPS_INTEGRATION
436	WRITE_UVLC( pcSPS->getVPSId (), "video_parameter_set_id" );
437	#endif
438	WRITE_UVLC( pcSPS->getChromaFormatIdc (), "chroma_format_idc" );
439	WRITE_CODE( pcSPS->getMaxTLayers() - 1, 3, "max_temporal_layers_minus1" );
440	WRITE_UVLC( pcSPS->getPicWidthInLumaSamples (), "pic_width_in_luma_samples" );
441	WRITE_UVLC( pcSPS->getPicHeightInLumaSamples(), "pic_height_in_luma_samples" );
442	#if PIC_CROPPING
443	WRITE_FLAG( pcSPS->getPicCroppingFlag(), "pic_cropping_flag" );
444	if (pcSPS->getPicCroppingFlag())
445	{
446	WRITE_UVLC( pcSPS->getPicCropLeftOffset(), "pic_crop_left_offset" );
447	WRITE_UVLC( pcSPS->getPicCropRightOffset(), "pic_crop_right_offset" );
448	WRITE_UVLC( pcSPS->getPicCropTopOffset(), "pic_crop_top_offset" );
449	WRITE_UVLC( pcSPS->getPicCropBottomOffset(), "pic_crop_bottom_offset" );
450	}
451	#endif
452
453	#if FULL_NBIT
454	WRITE_UVLC( pcSPS->getBitDepth() - 8, "bit_depth_luma_minus8" );
455	#else
456	WRITE_UVLC( pcSPS->getBitIncrement(), "bit_depth_luma_minus8" );
457	#endif
458	#if FULL_NBIT
459	WRITE_UVLC( pcSPS->getBitDepth() - 8, "bit_depth_chroma_minus8" );
460	#else
461	WRITE_UVLC( pcSPS->getBitIncrement(), "bit_depth_chroma_minus8" );
462	#endif
463
464	WRITE_FLAG( pcSPS->getUsePCM() ? 1 : 0, "pcm_enabled_flag");
465
466	if( pcSPS->getUsePCM() )
467	{
468	WRITE_CODE( pcSPS->getPCMBitDepthLuma() - 1, 4, "pcm_bit_depth_luma_minus1" );
469	WRITE_CODE( pcSPS->getPCMBitDepthChroma() - 1, 4, "pcm_bit_depth_chroma_minus1" );
470	}
471
472	#if LOSSLESS_CODING
473	WRITE_FLAG( (pcSPS->getUseLossless ()) ? 1 : 0, "qpprime_y_zero_transquant_bypass_flag" );
474	#endif
475
476	WRITE_UVLC( pcSPS->getBitsForPOC()-4, "log2_max_pic_order_cnt_lsb_minus4" );
477	#if H0567_DPB_PARAMETERS_PER_TEMPORAL_LAYER
478	for(UInt i=0; i <= pcSPS->getMaxTLayers()-1; i++)
479	{
480	WRITE_UVLC( pcSPS->getMaxDecPicBuffering(i), "max_dec_pic_buffering[i]" );
481	WRITE_UVLC( pcSPS->getNumReorderPics(i), "num_reorder_pics[i]" );
482	WRITE_UVLC( pcSPS->getMaxLatencyIncrease(i), "max_latency_increase[i]" );
483	}
484	#else
485	WRITE_UVLC( pcSPS->getMaxNumberOfReferencePictures(), "max_num_ref_pics" );
486	WRITE_UVLC( pcSPS->getNumReorderFrames(), "num_reorder_frames" );
487	WRITE_UVLC(pcSPS->getMaxDecFrameBuffering(), "max_dec_frame_buffering" );
488	WRITE_UVLC(pcSPS->getMaxLatencyIncrease(), "max_latency_increase" );
489	#endif
490	assert( pcSPS->getMaxCUWidth() == pcSPS->getMaxCUHeight() );
491
492	UInt MinCUSize = pcSPS->getMaxCUWidth() >> ( pcSPS->getMaxCUDepth()-g_uiAddCUDepth );
493	UInt log2MinCUSize = 0;
494	while(MinCUSize > 1)
495	{
496	MinCUSize >>= 1;
497	log2MinCUSize++;
498	}
499
500	#if H0412_REF_PIC_LIST_RESTRICTION
501	WRITE_FLAG( pcSPS->getRestrictedRefPicListsFlag(), "restricted_ref_pic_lists_flag" );
502	if( pcSPS->getRestrictedRefPicListsFlag() )
503	{
504	WRITE_FLAG( pcSPS->getListsModificationPresentFlag(), "lists_modification_present_flag" );
505	}
506	#endif
507	WRITE_UVLC( log2MinCUSize - 3, "log2_min_coding_block_size_minus3" );
508	WRITE_UVLC( pcSPS->getMaxCUDepth()-g_uiAddCUDepth, "log2_diff_max_min_coding_block_size" );
509	WRITE_UVLC( pcSPS->getQuadtreeTULog2MinSize() - 2, "log2_min_transform_block_size_minus2" );
510	WRITE_UVLC( pcSPS->getQuadtreeTULog2MaxSize() - pcSPS->getQuadtreeTULog2MinSize(), "log2_diff_max_min_transform_block_size" );
511
512	if(log2MinCUSize == 3)
513	{
514	xWriteFlag ( (pcSPS->getDisInter4x4()) ? 1 : 0 );
515	}
516
517	if( pcSPS->getUsePCM() )
518	{
519	WRITE_UVLC( pcSPS->getPCMLog2MinSize() - 3, "log2_min_pcm_coding_block_size_minus3" );
520	WRITE_UVLC( pcSPS->getPCMLog2MaxSize() - pcSPS->getPCMLog2MinSize(), "log2_diff_max_min_pcm_coding_block_size" );
521	}
522	WRITE_UVLC( pcSPS->getQuadtreeTUMaxDepthInter() - 1, "max_transform_hierarchy_depth_inter" );
523	WRITE_UVLC( pcSPS->getQuadtreeTUMaxDepthIntra() - 1, "max_transform_hierarchy_depth_intra" );
524	WRITE_FLAG( pcSPS->getScalingListFlag() ? 1 : 0, "scaling_list_enabled_flag" );
525	WRITE_FLAG( pcSPS->getUseLMChroma () ? 1 : 0, "chroma_pred_from_luma_enabled_flag" );
526	WRITE_FLAG( pcSPS->getUseDF() ? 1 : 0, "deblocking_filter_in_aps_enabled_flag");
527	WRITE_FLAG( pcSPS->getLFCrossSliceBoundaryFlag()?1 : 0, "seq_loop_filter_across_slices_enabled_flag");
528	WRITE_FLAG( pcSPS->getUseAMP(), "asymmetric_motion_partitions_enabled_flag" );
529	WRITE_FLAG( pcSPS->getUseNSQT(), "non_square_quadtree_enabled_flag" );
530	WRITE_FLAG( pcSPS->getUseSAO() ? 1 : 0, "sample_adaptive_offset_enabled_flag");
531	WRITE_FLAG( pcSPS->getUseALF () ? 1 : 0, "adaptive_loop_filter_enabled_flag");
532	#if LCU_SYNTAX_ALF
533	if(pcSPS->getUseALF())
534	{
535	WRITE_FLAG( (pcSPS->getUseALFCoefInSlice()) ? 1 : 0, "alf_coef_in_slice_flag");
536	}
537	#endif
538
539	if( pcSPS->getUsePCM() )
540	{
541	WRITE_FLAG( pcSPS->getPCMFilterDisableFlag()?1 : 0, "pcm_loop_filter_disable_flag");
542	}
543
544	assert( pcSPS->getMaxTLayers() > 0 );
545
546	WRITE_FLAG( pcSPS->getTemporalIdNestingFlag() ? 1 : 0, "temporal_id_nesting_flag" );
547
548	#if RPS_IN_SPS
549	TComRPSList* rpsList = pcSPS->getRPSList();
550	TComReferencePictureSet* rps;
551
552	WRITE_UVLC(rpsList->getNumberOfReferencePictureSets(), "num_short_term_ref_pic_sets" );
553	for(Int i=0; i < rpsList->getNumberOfReferencePictureSets(); i++)
554	{
555	rps = rpsList->getReferencePictureSet(i);
556	codeShortTermRefPicSet(pcSPS,rps);
557	}
558	WRITE_FLAG( pcSPS->getLongTermRefsPresent() ? 1 : 0, "long_term_ref_pics_present_flag" );
559	#endif
560	#if !PIC_CROPPING
561	//!!!KS: Syntax not in WD !!!
562
563	xWriteUvlc ( pcSPS->getPad (0) );
564	xWriteUvlc ( pcSPS->getPad (1) );
565	#endif
566	// AMVP mode for each depth
567	for (Int i = 0; i < pcSPS->getMaxCUDepth(); i++)
568	{
569	xWriteFlag( pcSPS->getAMVPMode(i) ? 1 : 0);
570	}
571
572	#if TILES_WPP_ENTRY_POINT_SIGNALLING
573	Int tilesOrEntropyCodingSyncIdc = 0;
574	if ( pcSPS->getNumColumnsMinus1() > 0 \|\| pcSPS->getNumRowsMinus1() > 0)
575	{
576	tilesOrEntropyCodingSyncIdc = 1;
577	}
578	else if ( pcSPS->getNumSubstreams() > 1 )
579	{
580	tilesOrEntropyCodingSyncIdc = 2;
581	}
582	pcSPS->setTilesOrEntropyCodingSyncIdc( tilesOrEntropyCodingSyncIdc );
583	WRITE_CODE(tilesOrEntropyCodingSyncIdc, 2, "tiles_or_entropy_coding_sync_idc");
584	#endif
585
586	#if TILES_OR_ENTROPY_SYNC_IDC
587	if(tilesOrEntropyCodingSyncIdc == 1)
588	{
589	#endif
590	WRITE_UVLC( pcSPS->getNumColumnsMinus1(), "num_tile_columns_minus1" );
591	WRITE_UVLC( pcSPS->getNumRowsMinus1(), "num_tile_rows_minus1" );
592	WRITE_FLAG( pcSPS->getUniformSpacingIdr(), "uniform_spacing_flag" );
593
594	if( pcSPS->getUniformSpacingIdr()==0 )
595	{
596	for(UInt i=0; i<pcSPS->getNumColumnsMinus1(); i++)
597	{
598	WRITE_UVLC( pcSPS->getColumnWidth(i), "column_width" );
599	}
600	for(UInt i=0; i<pcSPS->getNumRowsMinus1(); i++)
601	{
602	WRITE_UVLC( pcSPS->getRowHeight(i), "row_height" );
603	}
604	}
605
606	if( pcSPS->getNumColumnsMinus1() !=0 \|\| pcSPS->getNumRowsMinus1() != 0)
607	{
608	#if !REMOVE_TILE_DEPENDENCE
609	WRITE_FLAG( pcSPS->getTileBoundaryIndependenceIdr(), "tile_boundary_independence_flag" );
610	if(pcSPS->getTileBoundaryIndependenceIdr() == 1)
611	{
612	#endif
613	WRITE_FLAG( pcSPS->getLFCrossTileBoundaryFlag()?1 : 0, "loop_filter_across_tile_flag");
614	#if !REMOVE_TILE_DEPENDENCE
615	}
616	#endif
617	}
618	#if TILES_OR_ENTROPY_SYNC_IDC
619	}
620	#endif
621	WRITE_FLAG( 1, "sps_extension_flag" );
622
623	WRITE_FLAG( (pcSPS->getNumberOfUsableInterViewRefs() > 0) ? 1 : 0, "interview_refs_present_flag" );
624	if( pcSPS->getNumberOfUsableInterViewRefs() > 0 )
625	{
626	WRITE_UVLC( pcSPS->getNumberOfUsableInterViewRefs() - 1, "num_usable_interview_refs_minus1" );
627
628	Int prev = 0;
629	for( Int j = 0 ; j < pcSPS->getNumberOfUsableInterViewRefs(); j++ )
630	{
631	WRITE_UVLC( prev - pcSPS->getUsableInterViewRef( j ) - 1, "delta_usable_interview_ref_minus1" );
632	prev = pcSPS->getUsableInterViewRef( j );
633	}
634	}
635
636	#if HHI_DMM_WEDGE_INTRA \|\| HHI_DMM_PRED_TEX
637	WRITE_FLAG( pcSPS->getUseDMM(), "enable_dmm_flag" );
638	#endif
639
640	#if HHI_MPI
641	if( bIsDepth )
642	{
643	WRITE_FLAG( pcSPS->getUseMVI() ? 1 : 0, "use_mvi_flag" );
644	}
645	#endif
646
647	if( pcSPS->getViewId() \|\| pcSPS->isDepth() )
648	{
649	WRITE_FLAG( 0, "base_view_flag" );
650	if( pcSPS->isDepth() )
651	{
652	WRITE_FLAG( 1, "depth_flag" );
653	WRITE_UVLC( pcSPS->getViewId(), "view_id" );
654	WRITE_SVLC( pcSPS->getViewOrderIdx(), "view_order_idx" );
655	}
656	else
657	{
658	WRITE_FLAG( 0, "depth_flag" );
659	WRITE_UVLC( pcSPS->getViewId() - 1, "view_id_minus1" );
660	WRITE_SVLC( pcSPS->getViewOrderIdx(), "view_order_idx" );
661	WRITE_UVLC( pcSPS->getCamParPrecision(), "camera_parameter_precision" );
662	WRITE_FLAG( pcSPS->hasCamParInSliceHeader() ? 1 : 0, "camera_parameter_in_slice_header" );
663	if( !pcSPS->hasCamParInSliceHeader() )
664	{
665	for( UInt uiId = 0; uiId < pcSPS->getViewId(); uiId++ )
666	{
667	WRITE_SVLC( pcSPS->getCodedScale ()[ uiId ], "coded_scale" );
668	WRITE_SVLC( pcSPS->getCodedOffset ()[ uiId ], "coded_offset" );
669	WRITE_SVLC( pcSPS->getInvCodedScale ()[ uiId ] + pcSPS->getCodedScale ()[ uiId ], "inverse_coded_scale_plus_coded_scale" );
670	WRITE_SVLC( pcSPS->getInvCodedOffset()[ uiId ] + pcSPS->getCodedOffset()[ uiId ], "inverse_coded_offset_plus_coded_offset" );
671	}
672	}
673	#if DEPTH_MAP_GENERATION
674	WRITE_UVLC( pcSPS->getPredDepthMapGeneration(), "Pdm_generation" );
675	if( pcSPS->getPredDepthMapGeneration() )
676	{
677	WRITE_UVLC( pcSPS->getPdmPrecision(), "Pdm_precision" );
678	for( UInt uiId = 0; uiId < pcSPS->getViewId(); uiId++ )
679	{
680	WRITE_SVLC( pcSPS->getPdmScaleNomDelta()[ uiId ], "Pdm_scale_nom_delta" );
681	WRITE_SVLC( pcSPS->getPdmOffset ()[ uiId ], "Pdm_offset" );
682	}
683	#if HHI_INTER_VIEW_MOTION_PRED
684	WRITE_UVLC( pcSPS->getMultiviewMvPredMode(), "multi_view_mv_pred_mode" );
685	#endif
686	#if HHI_INTER_VIEW_RESIDUAL_PRED
687	WRITE_FLAG ( pcSPS->getMultiviewResPredMode(), "multi_view_residual_pred_mode" );
688	#endif
689	}
690	#endif
691	}
692	}
693	else
694	{
695	WRITE_FLAG( 1, "base_view_flag" );
696	}
697	WRITE_FLAG( 0, "sps_extension2_flag" );
698	}
699
700	Void TEncCavlc::writeTileMarker( UInt uiTileIdx, UInt uiBitsUsed )
701	{
702	xWriteCode( uiTileIdx, uiBitsUsed );
703	}
704
705	Void TEncCavlc::codeSliceHeader ( TComSlice* pcSlice )
706	{
707	#if ENC_DEC_TRACE
708	xTraceSliceHeader (pcSlice);
709	#endif
710
711	// if( nal_ref_idc != 0 )
712	// dec_ref_pic_marking( )
713	// if( entropy_coding_mode_flag && slice_type != I)
714	// cabac_init_idc
715	// first_slice_in_pic_flag
716	// if( first_slice_in_pic_flag == 0 )
717	// slice_address
718	//calculate number of bits required for slice address
719	Int maxAddrOuter = pcSlice->getPic()->getNumCUsInFrame();
720	Int reqBitsOuter = 0;
721	while(maxAddrOuter>(1<<reqBitsOuter))
722	{
723	reqBitsOuter++;
724	}
725	Int maxAddrInner = pcSlice->getPic()->getNumPartInCU()>>(2);
726	maxAddrInner = (1<<(pcSlice->getPPS()->getSliceGranularity()<<1));
727	Int reqBitsInner = 0;
728
729	while(maxAddrInner>(1<<reqBitsInner))
730	{
731	reqBitsInner++;
732	}
733	Int lCUAddress;
734	Int innerAddress;
735	if (pcSlice->isNextSlice())
736	{
737	// Calculate slice address
738	lCUAddress = (pcSlice->getSliceCurStartCUAddr()/pcSlice->getPic()->getNumPartInCU());
739	innerAddress = (pcSlice->getSliceCurStartCUAddr()%(pcSlice->getPic()->getNumPartInCU()))>>((pcSlice->getSPS()->getMaxCUDepth()-pcSlice->getPPS()->getSliceGranularity())<<1);
740	}
741	else
742	{
743	// Calculate slice address
744	lCUAddress = (pcSlice->getEntropySliceCurStartCUAddr()/pcSlice->getPic()->getNumPartInCU());
745	innerAddress = (pcSlice->getEntropySliceCurStartCUAddr()%(pcSlice->getPic()->getNumPartInCU()))>>((pcSlice->getSPS()->getMaxCUDepth()-pcSlice->getPPS()->getSliceGranularity())<<1);
746
747	}
748	//write slice address
749	Int address = (pcSlice->getPic()->getPicSym()->getCUOrderMap(lCUAddress) << reqBitsInner) + innerAddress;
750	WRITE_FLAG( address==0, "first_slice_in_pic_flag" );
751
752	#if LGE_ILLUCOMP_B0045
753	// IC flag is on only first_slice_in_pic
754	if (address==0)
755	{
756	if( pcSlice->getSPS()->getViewId() && !pcSlice->getIsDepth() )
757	{
758	WRITE_FLAG( pcSlice->getApplyIC() ? 1 : 0, "applying IC flag" );
759	}
760	}
761	#endif
762
763	if(address>0)
764	{
765	WRITE_CODE( address, reqBitsOuter+reqBitsInner, "slice_address" );
766	}
767
768	WRITE_UVLC( pcSlice->getSliceType(), "slice_type" );
769	Bool bEntropySlice = (!pcSlice->isNextSlice());
770	WRITE_FLAG( bEntropySlice ? 1 : 0, "lightweight_slice_flag" );
771
772	if (!bEntropySlice)
773	{
774	WRITE_UVLC( pcSlice->getPPS()->getPPSId(), "pic_parameter_set_id" );
775	#if H0388
776	if( pcSlice->getPPS()->getOutputFlagPresentFlag() )
777	{
778	WRITE_FLAG( pcSlice->getPicOutputFlag() ? 1 : 0, "pic_output_flag" );
779	}
780	#endif
781	if(pcSlice->getNalUnitType()==NAL_UNIT_CODED_SLICE_IDR)
782	{
783	WRITE_UVLC( 0, "idr_pic_id" );
784	WRITE_FLAG( 0, "no_output_of_prior_pics_flag" );
785	}
786	else
787	{
788	WRITE_CODE( (pcSlice->getPOC()-pcSlice->getLastIDR()+(1<<pcSlice->getSPS()->getBitsForPOC()))%(1<<pcSlice->getSPS()->getBitsForPOC()), pcSlice->getSPS()->getBitsForPOC(), "pic_order_cnt_lsb");
789	if( pcSlice->getPOC() == 0 && pcSlice->getNalUnitType() != NAL_UNIT_CODED_SLICE_IDV )
790	{
791	TComReferencePictureSet* rps = pcSlice->getRPS();
792	if(pcSlice->getRPSidx() < 0)
793	{
794	WRITE_FLAG( 0, "short_term_ref_pic_set_sps_flag");
795	#if RPS_IN_SPS
796	codeShortTermRefPicSet(pcSlice->getSPS(), rps);
797	#else
798	codeShortTermRefPicSet(pcSlice->getPPS(), rps);
799	#endif
800	}
801	else
802	{
803	WRITE_FLAG( 1, "short_term_ref_pic_set_sps_flag");
804	WRITE_UVLC( pcSlice->getRPSidx(), "short_term_ref_pic_set_idx" );
805	}
806	#if RPS_IN_SPS
807	if(pcSlice->getSPS()->getLongTermRefsPresent())
808	#else
809	if(pcSlice->getPPS()->getLongTermRefsPresent())
810	#endif
811	{
812	WRITE_UVLC( rps->getNumberOfLongtermPictures(), "num_long_term_pics");
813	Int maxPocLsb = 1<<pcSlice->getSPS()->getBitsForPOC();
814	Int prev = 0;
815	#if LTRP_MULT
816	Int prevDeltaPocLt=0;
817	Int currDeltaPocLt=0;
818	#endif
819	for(Int i=rps->getNumberOfPictures()-1 ; i > rps->getNumberOfPictures()-rps->getNumberOfLongtermPictures()-1; i--)
820	{
821	WRITE_UVLC((maxPocLsb-rps->getDeltaPOC(i)+prev)%maxPocLsb, "delta_poc_lsb_lt");
822
823	#if LTRP_MULT
824	currDeltaPocLt=((maxPocLsb-rps->getDeltaPOC(i)+prev)%maxPocLsb)+prevDeltaPocLt;
825
826	Int deltaMsbCycle=0;
827	if( (i==(rps->getNumberOfPictures()-1)) )
828	{
829	deltaMsbCycle=((-rps->getDeltaPOC(i))/maxPocLsb)-1;
830	}
831	else if( prevDeltaPocLt!=currDeltaPocLt )
832	{
833	deltaMsbCycle=((-rps->getDeltaPOC(i))/maxPocLsb)-1;
834	if( ((prevDeltaPocLt==maxPocLsb-1) && (currDeltaPocLt==maxPocLsb+1)) \|\| ((prevDeltaPocLt==maxPocLsb-2) && (currDeltaPocLt==maxPocLsb)))
835	{
836	deltaMsbCycle=deltaMsbCycle-1;
837	}
838	}
839	else
840	{
841	deltaMsbCycle=((rps->getDeltaPOC(i+1)-rps->getDeltaPOC(i))/maxPocLsb)-1;
842	}
843
844	if(deltaMsbCycle>=0)
845	{
846	WRITE_FLAG( 1, "delta_poc_msb_present_flag");
847	WRITE_UVLC(deltaMsbCycle, "delta_poc_msb_cycle_lt_minus1");
848	}
849	else
850	{
851	WRITE_FLAG( 0, "delta_poc_msb_present_flag");
852	}
853	prevDeltaPocLt=currDeltaPocLt;
854	#endif
855	prev = rps->getDeltaPOC(i);
856	WRITE_FLAG( rps->getUsed(i), "used_by_curr_pic_lt_flag");
857	}
858	}
859	}
860	if( pcSlice->getPOC() != 0 )
861	{
862	TComReferencePictureSet* rps = pcSlice->getRPS();
863	if(pcSlice->getRPSidx() < 0)
864	{
865	WRITE_FLAG( 0, "short_term_ref_pic_set_sps_flag");
866	#if RPS_IN_SPS
867	codeShortTermRefPicSet(pcSlice->getSPS(), rps);
868	#else
869	codeShortTermRefPicSet(pcSlice->getPPS(), rps);
870	#endif
871	}
872	else
873	{
874	WRITE_FLAG( 1, "short_term_ref_pic_set_sps_flag");
875	WRITE_UVLC( pcSlice->getRPSidx(), "short_term_ref_pic_set_idx" );
876	}
877	#if RPS_IN_SPS
878	if(pcSlice->getSPS()->getLongTermRefsPresent())
879	#else
880	if(pcSlice->getPPS()->getLongTermRefsPresent())
881	#endif
882	{
883	WRITE_UVLC( rps->getNumberOfLongtermPictures(), "num_long_term_pics");
884	Int maxPocLsb = 1<<pcSlice->getSPS()->getBitsForPOC();
885	Int prev = 0;
886	#if LTRP_MULT
887	Int prevDeltaPocLt=0;
888	Int currDeltaPocLt=0;
889	#endif
890	for(Int i=rps->getNumberOfPictures()-1 ; i > rps->getNumberOfPictures()-rps->getNumberOfLongtermPictures()-1; i--)
891	{
892	WRITE_UVLC((maxPocLsb-rps->getDeltaPOC(i)+prev)%maxPocLsb, "delta_poc_lsb_lt");
893
894	#if LTRP_MULT
895	currDeltaPocLt=((maxPocLsb-rps->getDeltaPOC(i)+prev)%maxPocLsb)+prevDeltaPocLt;
896
897	Int deltaMsbCycle=0;
898	if( (i==(rps->getNumberOfPictures()-1)) )
899	{
900	deltaMsbCycle=((-rps->getDeltaPOC(i))/maxPocLsb)-1;
901	}
902	else if( prevDeltaPocLt!=currDeltaPocLt )
903	{
904	deltaMsbCycle=((-rps->getDeltaPOC(i))/maxPocLsb)-1;
905	if( ((prevDeltaPocLt==maxPocLsb-1) && (currDeltaPocLt==maxPocLsb+1)) \|\| ((prevDeltaPocLt==maxPocLsb-2) && (currDeltaPocLt==maxPocLsb)))
906	{
907	deltaMsbCycle=deltaMsbCycle-1;
908	}
909	}
910	else
911	{
912	deltaMsbCycle=((rps->getDeltaPOC(i+1)-rps->getDeltaPOC(i))/maxPocLsb)-1;
913	}
914
915	if(deltaMsbCycle>=0)
916	{
917	WRITE_FLAG( 1, "delta_poc_msb_present_flag");
918	WRITE_UVLC(deltaMsbCycle, "delta_poc_msb_cycle_lt_minus1");
919	}
920	else
921	{
922	WRITE_FLAG( 0, "delta_poc_msb_present_flag");
923	}
924	prevDeltaPocLt=currDeltaPocLt;
925	#endif
926	prev = rps->getDeltaPOC(i);
927	WRITE_FLAG( rps->getUsed(i), "used_by_curr_pic_lt_flag");
928	}
929	}
930	}
931	}
932
933	if(pcSlice->getSPS()->getUseSAO() \|\| pcSlice->getSPS()->getUseALF()\|\| pcSlice->getSPS()->getScalingListFlag() \|\| pcSlice->getSPS()->getUseDF())
934	{
935	if (pcSlice->getSPS()->getUseALF())
936	{
937	#if !LCU_SYNTAX_ALF
938	if (pcSlice->getAlfEnabledFlag())
939	{
940	assert (pcSlice->getAPS()->getAlfEnabled());
941	}
942	#endif
943	WRITE_FLAG( pcSlice->getAlfEnabledFlag(), "ALF on/off flag in slice header" );
944	}
945	if (pcSlice->getSPS()->getUseSAO())
946	{
947	#if SAO_UNIT_INTERLEAVING
948	WRITE_FLAG( pcSlice->getSaoInterleavingFlag(), "SAO interleaving flag" );
949	#endif
950	assert (pcSlice->getSaoEnabledFlag() == pcSlice->getAPS()->getSaoEnabled());
951	WRITE_FLAG( pcSlice->getSaoEnabledFlag(), "SAO on/off flag in slice header" );
952	#if SAO_UNIT_INTERLEAVING
953	if (pcSlice->getSaoInterleavingFlag()&&pcSlice->getSaoEnabledFlag() )
954	{
955	WRITE_FLAG( pcSlice->getAPS()->getSaoParam()->bSaoFlag[1], "SAO on/off flag for Cb in slice header" );
956	WRITE_FLAG( pcSlice->getAPS()->getSaoParam()->bSaoFlag[2], "SAO on/off flag for Cr in slice header" );
957	}
958	#endif
959	}
960	WRITE_UVLC( pcSlice->getAPS()->getAPSID(), "aps_id");
961	}
962
963	// we always set num_ref_idx_active_override_flag equal to one. this might be done in a more intelligent way
964	if (!pcSlice->isIntra())
965	{
966	WRITE_FLAG( 1 , "num_ref_idx_active_override_flag");
967	WRITE_CODE( pcSlice->getNumRefIdx( REF_PIC_LIST_0 ) - 1, 3, "num_ref_idx_l0_active_minus1" );
968	}
969	else
970	{
971	pcSlice->setNumRefIdx(REF_PIC_LIST_0, 0);
972	}
973	if (pcSlice->isInterB())
974	{
975	WRITE_CODE( pcSlice->getNumRefIdx( REF_PIC_LIST_1 ) - 1, 3, "num_ref_idx_l1_active_minus1" );
976	}
977	else
978	{
979	pcSlice->setNumRefIdx(REF_PIC_LIST_1, 0);
980	}
981	#if H0412_REF_PIC_LIST_RESTRICTION
982	if( pcSlice->getSPS()->getListsModificationPresentFlag() )
983	{
984	#endif
985	TComRefPicListModification* refPicListModification = pcSlice->getRefPicListModification();
986	#if H0137_0138_LIST_MODIFICATION
987	if( !pcSlice->isIntra() )
988	{
989	WRITE_FLAG(pcSlice->getRefPicListModification()->getRefPicListModificationFlagL0() ? 1 : 0, "ref_pic_list_modification_flag_l0" );
990	if (pcSlice->getRefPicListModification()->getRefPicListModificationFlagL0())
991	{
992	Int NumPocTotalCurr = pcSlice->getNumPocTotalCurrMvc();
993	if (NumPocTotalCurr > 1)
994	{
995	Int length = 1;
996	NumPocTotalCurr --;
997	while ( NumPocTotalCurr >>= 1)
998	{
999	length ++;
1000	}
1001	for(Int i = 0; i < pcSlice->getNumRefIdx( REF_PIC_LIST_0 ); i++)
1002	{
1003	WRITE_CODE( refPicListModification->getRefPicSetIdxL0(i), length, "list_entry_l0");
1004	}
1005	}
1006	}
1007	}
1008	if(pcSlice->isInterB())
1009	{
1010	WRITE_FLAG(pcSlice->getRefPicListModification()->getRefPicListModificationFlagL1() ? 1 : 0, "ref_pic_list_modification_flag_l1" );
1011	if (pcSlice->getRefPicListModification()->getRefPicListModificationFlagL1())
1012	{
1013	Int NumPocTotalCurr = pcSlice->getNumPocTotalCurrMvc();
1014	if ( NumPocTotalCurr > 1 )
1015	{
1016	Int length = 1;
1017	NumPocTotalCurr --;
1018	while ( NumPocTotalCurr >>= 1)
1019	{
1020	length ++;
1021	}
1022	for(Int i = 0; i < pcSlice->getNumRefIdx( REF_PIC_LIST_1 ); i++)
1023	{
1024	WRITE_CODE( refPicListModification->getRefPicSetIdxL1(i), length, "list_entry_l1");
1025	}
1026	}
1027	}
1028	}
1029	#else
1030	if(!pcSlice->isIntra())
1031	{
1032	WRITE_FLAG(pcSlice->getRefPicListModification()->getRefPicListModificationFlagL0() ? 1 : 0, "ref_pic_list_modification_flag" );
1033	for(Int i = 0; i < refPicListModification->getNumberOfRefPicListModificationsL0(); i++)
1034	{
1035	WRITE_UVLC( refPicListModification->getListIdcL0(i), "ref_pic_list_modification_idc");
1036	WRITE_UVLC( refPicListModification->getRefPicSetIdxL0(i), "ref_pic_set_idx");
1037	}
1038	if(pcSlice->getRefPicListModification()->getRefPicListModificationFlagL0())
1039	WRITE_UVLC( 3, "ref_pic_list_modification_idc");
1040	}
1041	if(pcSlice->isInterB())
1042	{
1043	WRITE_FLAG(pcSlice->getRefPicListModification()->getRefPicListModificationFlagL1() ? 1 : 0, "ref_pic_list_modification_flag" );
1044	for(Int i = 0; i < refPicListModification->getNumberOfRefPicListModificationsL1(); i++)
1045	{
1046	WRITE_UVLC( refPicListModification->getListIdcL1(i), "ref_pic_list_modification_idc");
1047	WRITE_UVLC( refPicListModification->getRefPicSetIdxL1(i), "ref_pic_set_idx");
1048	}
1049	if(pcSlice->getRefPicListModification()->getRefPicListModificationFlagL1())
1050	WRITE_UVLC( 3, "ref_pic_list_modification_idc");
1051	}
1052	#endif
1053	}
1054	#if H0412_REF_PIC_LIST_RESTRICTION
1055	}
1056	#endif
1057	// ref_pic_list_combination( )
1058	// maybe move to own function?
1059	if (pcSlice->isInterB())
1060	{
1061	WRITE_FLAG(pcSlice->getRefPicListCombinationFlag() ? 1 : 0, "ref_pic_list_combination_flag" );
1062	if(pcSlice->getRefPicListCombinationFlag())
1063	{
1064	WRITE_UVLC( pcSlice->getNumRefIdx(REF_PIC_LIST_C) - 1, "num_ref_idx lc_active_minus1");
1065
1066	#if H0412_REF_PIC_LIST_RESTRICTION
1067	if( pcSlice->getSPS()->getListsModificationPresentFlag() )
1068	{
1069	#endif
1070	WRITE_FLAG( pcSlice->getRefPicListModificationFlagLC() ? 1 : 0, "ref_pic_list_modification_flag_lc" );
1071	if(pcSlice->getRefPicListModificationFlagLC())
1072	{
1073	for (UInt i=0;i<pcSlice->getNumRefIdx(REF_PIC_LIST_C);i++)
1074	{
1075	WRITE_FLAG( pcSlice->getListIdFromIdxOfLC(i), "pic_from_list_0_flag" );
1076	#if H0137_0138_LIST_MODIFICATION
1077	if (((pcSlice->getListIdFromIdxOfLC(i)==REF_PIC_LIST_0) && pcSlice->getNumRefIdx( REF_PIC_LIST_0 )>1 ) \|\| ((pcSlice->getListIdFromIdxOfLC(i)==REF_PIC_LIST_1) && pcSlice->getNumRefIdx( REF_PIC_LIST_1 )>1 ) )
1078	{
1079	WRITE_UVLC( pcSlice->getRefIdxFromIdxOfLC(i), "ref_idx_list_curr" );
1080	}
1081	#else
1082	WRITE_UVLC( pcSlice->getRefIdxFromIdxOfLC(i), "ref_idx_list_curr" );
1083	#endif
1084	}
1085	}
1086	#if H0412_REF_PIC_LIST_RESTRICTION
1087	}
1088	#endif
1089	}
1090	}
1091
1092	#if H0111_MVD_L1_ZERO
1093	if (pcSlice->isInterB())
1094	{
1095	WRITE_FLAG( pcSlice->getMvdL1ZeroFlag() ? 1 : 0, "mvd_l1_zero_flag");
1096	}
1097	#endif
1098
1099	if(pcSlice->getPPS()->getEntropyCodingMode() && !pcSlice->isIntra())
1100	{
1101	#if CABAC_INIT_FLAG
1102	if (!pcSlice->isIntra() && pcSlice->getPPS()->getCabacInitPresentFlag())
1103	{
1104	SliceType sliceType = pcSlice->getSliceType();
1105	Int encCABACTableIdx = pcSlice->getPPS()->getEncCABACTableIdx();
1106	Bool encCabacInitFlag = (sliceType!=encCABACTableIdx && encCABACTableIdx!=0) ? true : false;
1107	pcSlice->setCabacInitFlag( encCabacInitFlag );
1108	WRITE_FLAG( encCabacInitFlag?1:0, "cabac_init_flag" );
1109	}
1110	#else
1111	WRITE_UVLC(pcSlice->getCABACinitIDC(), "cabac_init_idc");
1112	#endif
1113	}
1114
1115	// if( !lightweight_slice_flag ) {
1116	if (!bEntropySlice)
1117	{
1118	Int iCode = pcSlice->getSliceQp() - ( pcSlice->getPPS()->getPicInitQPMinus26() + 26 );
1119	WRITE_SVLC( iCode, "slice_qp_delta" );
1120	#if DBL_CONTROL
1121	if (pcSlice->getPPS()->getDeblockingFilterControlPresent())
1122	{
1123	if ( pcSlice->getSPS()->getUseDF() )
1124	{
1125	WRITE_FLAG(pcSlice->getInheritDblParamFromAPS(), "inherit_dbl_param_from_APS_flag");
1126	}
1127	#else
1128	WRITE_FLAG(pcSlice->getInheritDblParamFromAPS(), "inherit_dbl_param_from_APS_flag");
1129	#endif
1130	if (!pcSlice->getInheritDblParamFromAPS())
1131	{
1132	WRITE_FLAG(pcSlice->getLoopFilterDisable(), "loop_filter_disable"); // should be an IDC
1133	if(!pcSlice->getLoopFilterDisable())
1134	{
1135	WRITE_SVLC (pcSlice->getLoopFilterBetaOffset(), "beta_offset_div2");
1136	WRITE_SVLC (pcSlice->getLoopFilterTcOffset(), "tc_offset_div2");
1137	}
1138	}
1139	#if DBL_CONTROL
1140	}
1141	#endif
1142	if ( pcSlice->getSliceType() == B_SLICE )
1143	{
1144	WRITE_FLAG( pcSlice->getColDir(), "collocated_from_l0_flag" );
1145	}
1146
1147	#if COLLOCATED_REF_IDX
1148	if ( pcSlice->getSliceType() != I_SLICE &&
1149	((pcSlice->getColDir()==0 && pcSlice->getNumRefIdx(REF_PIC_LIST_0)>1)\|\|
1150	(pcSlice->getColDir()==1 && pcSlice->getNumRefIdx(REF_PIC_LIST_1)>1)))
1151	{
1152	WRITE_UVLC( pcSlice->getColRefIdx(), "collocated_ref_idx" );
1153	}
1154	#endif
1155
1156	if ( (pcSlice->getPPS()->getUseWP() && pcSlice->getSliceType()==P_SLICE) \|\| (pcSlice->getPPS()->getWPBiPredIdc()==1 && pcSlice->getSliceType()==B_SLICE) )
1157	{
1158	xCodePredWeightTable( pcSlice );
1159	}
1160	}
1161
1162	// !!!! sytnax elements not in the WD !!!!
1163	if (!bEntropySlice)
1164	{
1165	if( pcSlice->getSPS()->hasCamParInSliceHeader() )
1166	{
1167	for( UInt uiId = 0; uiId < pcSlice->getSPS()->getViewId(); uiId++ )
1168	{
1169	WRITE_SVLC( pcSlice->getCodedScale ()[ uiId ], "coded_scale" );
1170	WRITE_SVLC( pcSlice->getCodedOffset ()[ uiId ], "coded_offset" );
1171	WRITE_SVLC( pcSlice->getInvCodedScale ()[ uiId ] + pcSlice->getCodedScale ()[ uiId ], "inverse_coded_scale_plus_coded_scale" );
1172	WRITE_SVLC( pcSlice->getInvCodedOffset()[ uiId ] + pcSlice->getCodedOffset()[ uiId ], "inverse_coded_offset_plus_coded_offset" );
1173	}
1174	}
1175	}
1176
1177	#if ( HHI_MPI \|\| HHI_INTER_VIEW_MOTION_PRED )
1178	#if ( HHI_MPI && HHI_INTER_VIEW_MOTION_PRED )
1179	const int iExtraMergeCandidates = ( pcSlice->getSPS()->getUseMVI() \|\| pcSlice->getSPS()->getMultiviewMvPredMode() ) ? 1 : 0;
1180	#elif HHI_MPI
1181	const int iExtraMergeCandidates = pcSlice->getSPS()->getUseMVI() ? 1 : 0;
1182	#else
1183	const int iExtraMergeCandidates = pcSlice->getSPS()->getMultiviewMvPredMode() ? 1 : 0;
1184	#endif
1185	assert(pcSlice->getMaxNumMergeCand()<=(MRG_MAX_NUM_CANDS_SIGNALED+iExtraMergeCandidates));
1186	assert(MRG_MAX_NUM_CANDS_SIGNALED<=MRG_MAX_NUM_CANDS);
1187	WRITE_UVLC(MRG_MAX_NUM_CANDS + iExtraMergeCandidates - pcSlice->getMaxNumMergeCand(), "maxNumMergeCand");
1188	#else
1189	assert(pcSlice->getMaxNumMergeCand()<=MRG_MAX_NUM_CANDS_SIGNALED);
1190	assert(MRG_MAX_NUM_CANDS_SIGNALED<=MRG_MAX_NUM_CANDS);
1191	WRITE_UVLC(MRG_MAX_NUM_CANDS - pcSlice->getMaxNumMergeCand(), "maxNumMergeCand");
1192	#endif
1193	}
1194
1195
1196	Void TEncCavlc::codeTileMarkerFlag(TComSlice* pcSlice)
1197	{
1198	Bool bEntropySlice = (!pcSlice->isNextSlice());
1199	if (!bEntropySlice)
1200	{
1201	xWriteFlag (pcSlice->getTileMarkerFlag() ? 1 : 0 );
1202	}
1203	}
1204
1205	/**
1206	- write wavefront substreams sizes for the slice header.
1207	.
1208	\param pcSlice Where we find the substream size information.
1209	*/
1210	#if TILES_WPP_ENTRY_POINT_SIGNALLING
1211	Void TEncCavlc::codeTilesWPPEntryPoint( TComSlice* pSlice )
1212	{
1213	Int tilesOrEntropyCodingSyncIdc = pSlice->getSPS()->getTilesOrEntropyCodingSyncIdc();
1214
1215	if ( tilesOrEntropyCodingSyncIdc == 0 )
1216	{
1217	return;
1218	}
1219
1220	UInt numEntryPointOffsets = 0, offsetLenMinus1 = 0, maxOffset = 0;
1221	UInt *entryPointOffset = NULL;
1222	if (tilesOrEntropyCodingSyncIdc == 1) // tiles
1223	{
1224	numEntryPointOffsets = pSlice->getTileLocationCount();
1225	entryPointOffset = new UInt[numEntryPointOffsets];
1226	for (Int idx=0; idx<pSlice->getTileLocationCount(); idx++)
1227	{
1228	if ( idx == 0 )
1229	{
1230	entryPointOffset [ idx ] = pSlice->getTileLocation( 0 );
1231	}
1232	else
1233	{
1234	entryPointOffset [ idx ] = pSlice->getTileLocation( idx ) - pSlice->getTileLocation( idx-1 );
1235	}
1236
1237	if ( entryPointOffset[ idx ] > maxOffset )
1238	{
1239	maxOffset = entryPointOffset[ idx ];
1240	}
1241	}
1242	}
1243	else if (tilesOrEntropyCodingSyncIdc == 2) // wavefront
1244	{
1245	Int numZeroSubstreamsAtEndOfSlice = 0;
1246	UInt* pSubstreamSizes = pSlice->getSubstreamSizes();
1247	// Find number of zero substreams at the end of slice
1248	for (Int idx=pSlice->getPPS()->getNumSubstreams()-2; idx>=0; idx--)
1249	{
1250	if ( pSubstreamSizes[ idx ] == 0 )
1251	{
1252	numZeroSubstreamsAtEndOfSlice++;
1253	}
1254	else
1255	{
1256	break;
1257	}
1258	}
1259	numEntryPointOffsets = pSlice->getPPS()->getNumSubstreams() - 1 - numZeroSubstreamsAtEndOfSlice;
1260	entryPointOffset = new UInt[numEntryPointOffsets];
1261	for (Int idx=0; idx<numEntryPointOffsets; idx++)
1262	{
1263	entryPointOffset[ idx ] = ( pSubstreamSizes[ idx ] >> 3 ) ;
1264	if ( entryPointOffset[ idx ] > maxOffset )
1265	{
1266	maxOffset = entryPointOffset[ idx ];
1267	}
1268	}
1269	}
1270
1271	maxOffset += ((m_pcBitIf->getNumberOfWrittenBits() + 16) >> 3) + 8 + 2; // allowing for NALU header, slice header, bytes added for "offset_len_minus1" and "num_entry_point_offsets"
1272
1273	// Determine number of bits "offsetLenMinus1+1" required for entry point information
1274	offsetLenMinus1 = 0;
1275	while (1)
1276	{
1277	if (maxOffset >= (1 << offsetLenMinus1) )
1278	{
1279	offsetLenMinus1++;
1280	if ( offsetLenMinus1 > 32 )
1281	{
1282	FATAL_ERROR_0("exceeded 32-bits", -1);
1283	}
1284	}
1285	else
1286	{
1287	break;
1288	}
1289	}
1290
1291	WRITE_UVLC(numEntryPointOffsets, "num_entry_point_offsets");
1292	if (numEntryPointOffsets>0)
1293	{
1294	WRITE_UVLC(offsetLenMinus1, "offset_len_minus1");
1295	}
1296
1297	for (UInt idx=0; idx<numEntryPointOffsets; idx++)
1298	{
1299	if ( idx == 0 )
1300	{
1301	// Adding sizes of NALU header and slice header information to entryPointOffset[ 0 ]
1302	Int bitDistFromNALUHdrStart = m_pcBitIf->getNumberOfWrittenBits() + 16;
1303	entryPointOffset[ idx ] += ( bitDistFromNALUHdrStart + numEntryPointOffsets*(offsetLenMinus1+1) ) >> 3;
1304	}
1305	WRITE_CODE(entryPointOffset[ idx ], offsetLenMinus1+1, "entry_point_offset");
1306	}
1307
1308	delete [] entryPointOffset;
1309	}
1310	#else
1311	Void TEncCavlc::codeSliceHeaderSubstreamTable( TComSlice* pcSlice )
1312	{
1313	UInt uiNumSubstreams = pcSlice->getPPS()->getNumSubstreams();
1314	UInt*puiSubstreamSizes = pcSlice->getSubstreamSizes();
1315
1316	// Write header information for all substreams except the last.
1317	for (UInt ui = 0; ui+1 < uiNumSubstreams; ui++)
1318	{
1319	UInt uiNumbits = puiSubstreamSizes[ui];
1320
1321	//the 2 first bits are used to give the size of the header
1322	if ( uiNumbits < (1<<8) )
1323	{
1324	xWriteCode(0, 2 );
1325	xWriteCode(uiNumbits, 8 );
1326	}
1327	else if ( uiNumbits < (1<<16) )
1328	{
1329	xWriteCode(1, 2 );
1330	xWriteCode(uiNumbits, 16 );
1331	}
1332	else if ( uiNumbits < (1<<24) )
1333	{
1334	xWriteCode(2, 2 );
1335	xWriteCode(uiNumbits, 24 );
1336	}
1337	else if ( uiNumbits < (1<<31) )
1338	{
1339	xWriteCode(3, 2 );
1340	xWriteCode(uiNumbits, 32 );
1341	}
1342	else
1343	{
1344	printf("Error in codeSliceHeaderTable\n");
1345	exit(-1);
1346	}
1347	}
1348	}
1349	#endif
1350
1351	Void TEncCavlc::codeTerminatingBit ( UInt uilsLast )
1352	{
1353	}
1354
1355	Void TEncCavlc::codeSliceFinish ()
1356	{
1357	}
1358
1359	#if HHI_INTER_VIEW_MOTION_PRED
1360	Void TEncCavlc::codeMVPIdx ( TComDataCU* pcCU, UInt uiAbsPartIdx, RefPicList eRefList, Int iNum )
1361	#else
1362	Void TEncCavlc::codeMVPIdx ( TComDataCU* pcCU, UInt uiAbsPartIdx, RefPicList eRefList )
1363	#endif
1364	{
1365	assert(0);
1366	}
1367
1368	Void TEncCavlc::codePartSize( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
1369	{
1370	assert(0);
1371	}
1372
1373	Void TEncCavlc::codePredMode( TComDataCU* pcCU, UInt uiAbsPartIdx )
1374	{
1375	assert(0);
1376	}
1377
1378	Void TEncCavlc::codeMergeFlag ( TComDataCU* pcCU, UInt uiAbsPartIdx )
1379	{
1380	assert(0);
1381	}
1382
1383	Void TEncCavlc::codeMergeIndex ( TComDataCU* pcCU, UInt uiAbsPartIdx )
1384	{
1385	assert(0);
1386	}
1387
1388	#if HHI_INTER_VIEW_RESIDUAL_PRED
1389	Void
1390	TEncCavlc::codeResPredFlag( TComDataCU* pcCU, UInt uiAbsPartIdx )
1391	{
1392	assert(0);
1393	}
1394	#endif
1395
1396	Void TEncCavlc::codeAlfCtrlFlag( TComDataCU* pcCU, UInt uiAbsPartIdx )
1397	{
1398	if (!m_bAlfCtrl)
1399	{
1400	return;
1401	}
1402
1403	if( pcCU->getDepth(uiAbsPartIdx) > m_uiMaxAlfCtrlDepth && !pcCU->isFirstAbsZorderIdxInDepth(uiAbsPartIdx, m_uiMaxAlfCtrlDepth))
1404	{
1405	return;
1406	}
1407
1408	// get context function is here
1409	UInt uiSymbol = pcCU->getAlfCtrlFlag( uiAbsPartIdx ) ? 1 : 0;
1410
1411	xWriteFlag( uiSymbol );
1412	}
1413
1414	Void TEncCavlc::codeApsExtensionFlag ()
1415	{
1416	WRITE_FLAG(0, "aps_extension_flag");
1417	}
1418
1419	Void TEncCavlc::codeAlfCtrlDepth()
1420	{
1421	if (!m_bAlfCtrl)
1422	{
1423	return;
1424	}
1425
1426	UInt uiDepth = m_uiMaxAlfCtrlDepth;
1427
1428	xWriteUvlc(uiDepth);
1429	}
1430
1431	Void TEncCavlc::codeInterModeFlag( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth, UInt uiEncMode )
1432	{
1433	assert(0);
1434	}
1435
1436	Void TEncCavlc::codeSkipFlag( TComDataCU* pcCU, UInt uiAbsPartIdx )
1437	{
1438	assert(0);
1439	}
1440
1441	#if LGE_ILLUCOMP_B0045
1442	Void TEncCavlc::codeICFlag( TComDataCU* pcCU, UInt uiAbsPartIdx )
1443	{
1444	assert(0);
1445	}
1446	#endif
1447
1448	Void TEncCavlc::codeSplitFlag ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
1449	{
1450	assert(0);
1451	}
1452
1453	Void TEncCavlc::codeTransformSubdivFlag( UInt uiSymbol, UInt uiCtx )
1454	{
1455	assert(0);
1456	}
1457
1458	Void TEncCavlc::codeQtCbf( TComDataCU* pcCU, UInt uiAbsPartIdx, TextType eType, UInt uiTrDepth )
1459	{
1460	assert(0);
1461	}
1462
1463	Void TEncCavlc::codeQtRootCbf( TComDataCU* pcCU, UInt uiAbsPartIdx )
1464	{
1465	assert(0);
1466	}
1467
1468	#if BURST_IPCM
1469	/** Code I_PCM information.
1470	* \param pcCU pointer to CU
1471	* \param uiAbsPartIdx CU index
1472	* \param numIPCM the number of succesive IPCM blocks with the same size
1473	* \param firstIPCMFlag
1474	* \returns Void
1475	*/
1476	Void TEncCavlc::codeIPCMInfo( TComDataCU* pcCU, UInt uiAbsPartIdx, Int numIPCM, Bool firstIPCMFlag)
1477	{
1478	assert(0);
1479	}
1480	#else
1481	/** Code I_PCM information.
1482	* \param pcCU pointer to CU
1483	* \param uiAbsPartIdx CU index
1484	* \returns Void
1485	*
1486	* If I_PCM flag indicates that the CU is I_PCM, code its PCM alignment bits and codes.
1487	*/
1488	Void TEncCavlc::codeIPCMInfo( TComDataCU* pcCU, UInt uiAbsPartIdx)
1489	{
1490	UInt uiIPCM = (pcCU->getIPCMFlag(uiAbsPartIdx) == true)? 1 : 0;
1491
1492	xWriteFlag(uiIPCM);
1493
1494	if (uiIPCM)
1495	{
1496	xWritePCMAlignZero();
1497
1498	UInt uiMinCoeffSize = pcCU->getPic()->getMinCUWidth()*pcCU->getPic()->getMinCUHeight();
1499	UInt uiLumaOffset = uiMinCoeffSize*uiAbsPartIdx;
1500	UInt uiChromaOffset = uiLumaOffset>>2;
1501
1502	Pel* piPCMSample;
1503	UInt uiWidth;
1504	UInt uiHeight;
1505	UInt uiSampleBits;
1506	UInt uiX, uiY;
1507
1508	piPCMSample = pcCU->getPCMSampleY() + uiLumaOffset;
1509	uiWidth = pcCU->getWidth(uiAbsPartIdx);
1510	uiHeight = pcCU->getHeight(uiAbsPartIdx);
1511	uiSampleBits = pcCU->getSlice()->getSPS()->getPCMBitDepthLuma();
1512
1513	for(uiY = 0; uiY < uiHeight; uiY++)
1514	{
1515	for(uiX = 0; uiX < uiWidth; uiX++)
1516	{
1517	UInt uiSample = piPCMSample[uiX];
1518
1519	xWriteCode(uiSample, uiSampleBits);
1520	}
1521	piPCMSample += uiWidth;
1522	}
1523
1524	piPCMSample = pcCU->getPCMSampleCb() + uiChromaOffset;
1525	uiWidth = pcCU->getWidth(uiAbsPartIdx)/2;
1526	uiHeight = pcCU->getHeight(uiAbsPartIdx)/2;
1527	uiSampleBits = pcCU->getSlice()->getSPS()->getPCMBitDepthChroma();
1528
1529	for(uiY = 0; uiY < uiHeight; uiY++)
1530	{
1531	for(uiX = 0; uiX < uiWidth; uiX++)
1532	{
1533	UInt uiSample = piPCMSample[uiX];
1534
1535	xWriteCode(uiSample, uiSampleBits);
1536	}
1537	piPCMSample += uiWidth;
1538	}
1539
1540	piPCMSample = pcCU->getPCMSampleCr() + uiChromaOffset;
1541	uiWidth = pcCU->getWidth(uiAbsPartIdx)/2;
1542	uiHeight = pcCU->getHeight(uiAbsPartIdx)/2;
1543	uiSampleBits = pcCU->getSlice()->getSPS()->getPCMBitDepthChroma();
1544
1545	for(uiY = 0; uiY < uiHeight; uiY++)
1546	{
1547	for(uiX = 0; uiX < uiWidth; uiX++)
1548	{
1549	UInt uiSample = piPCMSample[uiX];
1550
1551	xWriteCode(uiSample, uiSampleBits);
1552	}
1553	piPCMSample += uiWidth;
1554	}
1555	}
1556	}
1557	#endif
1558
1559	Void TEncCavlc::codeIntraDirLumaAng( TComDataCU* pcCU, UInt uiAbsPartIdx )
1560	{
1561	assert(0);
1562	}
1563
1564	Void TEncCavlc::codeIntraDirChroma( TComDataCU* pcCU, UInt uiAbsPartIdx )
1565	{
1566	assert(0);
1567	}
1568
1569	Void TEncCavlc::codeInterDir( TComDataCU* pcCU, UInt uiAbsPartIdx )
1570	{
1571	assert(0);
1572	}
1573
1574	Void TEncCavlc::codeRefFrmIdx( TComDataCU* pcCU, UInt uiAbsPartIdx, RefPicList eRefList )
1575	{
1576	assert(0);
1577	}
1578
1579	Void TEncCavlc::codeMvd( TComDataCU* pcCU, UInt uiAbsPartIdx, RefPicList eRefList )
1580	{
1581	assert(0);
1582	}
1583
1584	Void TEncCavlc::codeDeltaQP( TComDataCU* pcCU, UInt uiAbsPartIdx )
1585	{
1586	Int iDQp = pcCU->getQP( uiAbsPartIdx ) - pcCU->getRefQP( uiAbsPartIdx );
1587
1588	#if H0736_AVC_STYLE_QP_RANGE
1589	Int qpBdOffsetY = pcCU->getSlice()->getSPS()->getQpBDOffsetY();
1590	iDQp = (iDQp + 78 + qpBdOffsetY + (qpBdOffsetY/2)) % (52 + qpBdOffsetY) - 26 - (qpBdOffsetY/2);
1591	#endif
1592
1593	xWriteSvlc( iDQp );
1594
1595	return;
1596	}
1597
1598	Void TEncCavlc::codeCoeffNxN ( TComDataCU* pcCU, TCoeff* pcCoef, UInt uiAbsPartIdx, UInt uiWidth, UInt uiHeight, UInt uiDepth, TextType eTType )
1599	{
1600	assert(0);
1601	}
1602
1603	Void TEncCavlc::codeAlfFlag( UInt uiCode )
1604	{
1605	xWriteFlag( uiCode );
1606	}
1607
1608	Void TEncCavlc::codeAlfCtrlFlag( UInt uiSymbol )
1609	{
1610	xWriteFlag( uiSymbol );
1611	}
1612
1613	Void TEncCavlc::codeAlfUvlc( UInt uiCode )
1614	{
1615	xWriteUvlc( uiCode );
1616	}
1617
1618	Void TEncCavlc::codeAlfSvlc( Int iCode )
1619	{
1620	xWriteSvlc( iCode );
1621	}
1622	#if LCU_SYNTAX_ALF
1623	/** Code the fixed length code (smaller than one max value) in OSALF
1624	* \param idx: coded value
1625	* \param maxValue: max value
1626	*/
1627	Void TEncCavlc::codeAlfFixedLengthIdx( UInt idx, UInt maxValue)
1628	{
1629	UInt length = 0;
1630	assert(idx<=maxValue);
1631
1632	UInt temp = maxValue;
1633	for(UInt i=0; i<32; i++)
1634	{
1635	if(temp&0x1)
1636	{
1637	length = i+1;
1638	}
1639	temp = (temp >> 1);
1640	}
1641
1642	if(length)
1643	{
1644	xWriteCode( idx, length );
1645	}
1646	}
1647	#endif
1648
1649	Void TEncCavlc::codeSaoFlag( UInt uiCode )
1650	{
1651	xWriteFlag( uiCode );
1652	}
1653
1654	Void TEncCavlc::codeSaoUvlc( UInt uiCode )
1655	{
1656	xWriteUvlc( uiCode );
1657	}
1658
1659	Void TEncCavlc::codeSaoSvlc( Int iCode )
1660	{
1661	xWriteSvlc( iCode );
1662	}
1663	#if SAO_UNIT_INTERLEAVING
1664	/** Code SAO run.
1665	* \param uiCode
1666	* \param maxValue
1667	*/
1668	Void TEncCavlc::codeSaoRun( UInt uiCode, UInt maxValue)
1669	{
1670	UInt uiLength = 0;
1671	if (!maxValue)
1672	{
1673	return;
1674	}
1675	assert(uiCode<=maxValue);
1676
1677	for(UInt i=0; i<32; i++)
1678	{
1679	if(maxValue&0x1)
1680	{
1681	uiLength = i+1;
1682	}
1683	maxValue = (maxValue >> 1);
1684	}
1685	WRITE_CODE( uiCode, uiLength, "sao_run_diff");
1686	}
1687	#endif
1688
1689	Void TEncCavlc::estBit( estBitsSbacStruct* pcEstBitsCabac, Int width, Int height, TextType eTType )
1690	{
1691	// printf("error : no VLC mode support in this version\n");
1692	return;
1693	}
1694
1695	// ====================================================================================================================
1696	// Protected member functions
1697	// ====================================================================================================================
1698
1699	Void TEncCavlc::xWriteCode ( UInt uiCode, UInt uiLength )
1700	{
1701	assert ( uiLength > 0 );
1702	m_pcBitIf->write( uiCode, uiLength );
1703	}
1704
1705	Void TEncCavlc::xWriteUvlc ( UInt uiCode )
1706	{
1707	UInt uiLength = 1;
1708	UInt uiTemp = ++uiCode;
1709
1710	assert ( uiTemp );
1711
1712	while( 1 != uiTemp )
1713	{
1714	uiTemp >>= 1;
1715	uiLength += 2;
1716	}
1717
1718	//m_pcBitIf->write( uiCode, uiLength );
1719	// Take care of cases where uiLength > 32
1720	m_pcBitIf->write( 0, uiLength >> 1);
1721	m_pcBitIf->write( uiCode, (uiLength+1) >> 1);
1722	}
1723
1724	Void TEncCavlc::xWriteSvlc ( Int iCode )
1725	{
1726	UInt uiCode;
1727
1728	uiCode = xConvertToUInt( iCode );
1729	xWriteUvlc( uiCode );
1730	}
1731
1732	Void TEncCavlc::xWriteFlag( UInt uiCode )
1733	{
1734	m_pcBitIf->write( uiCode, 1 );
1735	}
1736
1737	/** Write PCM alignment bits.
1738	* \returns Void
1739	*/
1740	Void TEncCavlc::xWritePCMAlignZero ()
1741	{
1742	m_pcBitIf->writeAlignZero();
1743	}
1744
1745	Void TEncCavlc::xWriteUnaryMaxSymbol( UInt uiSymbol, UInt uiMaxSymbol )
1746	{
1747	if (uiMaxSymbol == 0)
1748	{
1749	return;
1750	}
1751	xWriteFlag( uiSymbol ? 1 : 0 );
1752	if ( uiSymbol == 0 )
1753	{
1754	return;
1755	}
1756
1757	Bool bCodeLast = ( uiMaxSymbol > uiSymbol );
1758
1759	while( --uiSymbol )
1760	{
1761	xWriteFlag( 1 );
1762	}
1763	if( bCodeLast )
1764	{
1765	xWriteFlag( 0 );
1766	}
1767	return;
1768	}
1769
1770	Void TEncCavlc::xWriteExGolombLevel( UInt uiSymbol )
1771	{
1772	if( uiSymbol )
1773	{
1774	xWriteFlag( 1 );
1775	UInt uiCount = 0;
1776	Bool bNoExGo = (uiSymbol < 13);
1777
1778	while( --uiSymbol && ++uiCount < 13 )
1779	{
1780	xWriteFlag( 1 );
1781	}
1782	if( bNoExGo )
1783	{
1784	xWriteFlag( 0 );
1785	}
1786	else
1787	{
1788	xWriteEpExGolomb( uiSymbol, 0 );
1789	}
1790	}
1791	else
1792	{
1793	xWriteFlag( 0 );
1794	}
1795	return;
1796	}
1797
1798	Void TEncCavlc::xWriteEpExGolomb( UInt uiSymbol, UInt uiCount )
1799	{
1800	while( uiSymbol >= (UInt)(1<<uiCount) )
1801	{
1802	xWriteFlag( 1 );
1803	uiSymbol -= 1<<uiCount;
1804	uiCount ++;
1805	}
1806	xWriteFlag( 0 );
1807	while( uiCount-- )
1808	{
1809	xWriteFlag( (uiSymbol>>uiCount) & 1 );
1810	}
1811	return;
1812	}
1813
1814	/** code explicit wp tables
1815	* \param TComSlice* pcSlice
1816	* \returns Void
1817	*/
1818	Void TEncCavlc::xCodePredWeightTable( TComSlice* pcSlice )
1819	{
1820	wpScalingParam *wp;
1821	Bool bChroma = true; // color always present in HEVC ?
1822	Int iNbRef = (pcSlice->getSliceType() == B_SLICE ) ? (2) : (1);
1823	Bool bDenomCoded = false;
1824
1825	UInt uiMode = 0;
1826	if ( (pcSlice->getSliceType()==P_SLICE && pcSlice->getPPS()->getUseWP()) \|\| (pcSlice->getSliceType()==B_SLICE && pcSlice->getPPS()->getWPBiPredIdc()==1 && pcSlice->getRefPicListCombinationFlag()==0 ) )
1827	uiMode = 1; // explicit
1828	else if ( pcSlice->getSliceType()==B_SLICE && pcSlice->getPPS()->getWPBiPredIdc()==2 )
1829	uiMode = 2; // implicit (does not use this mode in this syntax)
1830	if (pcSlice->getSliceType()==B_SLICE && pcSlice->getPPS()->getWPBiPredIdc()==1 && pcSlice->getRefPicListCombinationFlag())
1831	uiMode = 3; // combined explicit
1832	if(uiMode == 1)
1833	{
1834	for ( Int iNumRef=0 ; iNumRef<iNbRef ; iNumRef++ )
1835	{
1836	RefPicList eRefPicList = ( iNumRef ? REF_PIC_LIST_1 : REF_PIC_LIST_0 );
1837	for ( Int iRefIdx=0 ; iRefIdx<pcSlice->getNumRefIdx(eRefPicList) ; iRefIdx++ )
1838	{
1839	pcSlice->getWpScaling(eRefPicList, iRefIdx, wp);
1840	if ( !bDenomCoded )
1841	{
1842	Int iDeltaDenom;
1843	WRITE_UVLC( wp[0].uiLog2WeightDenom, "luma_log2_weight_denom" ); // ue(v): luma_log2_weight_denom
1844
1845	if( bChroma )
1846	{
1847	iDeltaDenom = (wp[1].uiLog2WeightDenom - wp[0].uiLog2WeightDenom);
1848	WRITE_SVLC( iDeltaDenom, "delta_chroma_log2_weight_denom" ); // se(v): delta_chroma_log2_weight_denom
1849	}
1850	bDenomCoded = true;
1851	}
1852
1853	WRITE_FLAG( wp[0].bPresentFlag, "luma_weight_lX_flag" ); // u(1): luma_weight_lX_flag
1854
1855	if ( wp[0].bPresentFlag )
1856	{
1857	Int iDeltaWeight = (wp[0].iWeight - (1<<wp[0].uiLog2WeightDenom));
1858	WRITE_SVLC( iDeltaWeight, "delta_luma_weight_lX" ); // se(v): delta_luma_weight_lX
1859	WRITE_SVLC( wp[0].iOffset, "luma_offset_lX" ); // se(v): luma_offset_lX
1860	}
1861
1862	if ( bChroma )
1863	{
1864	WRITE_FLAG( wp[1].bPresentFlag, "chroma_weight_lX_flag" ); // u(1): chroma_weight_lX_flag
1865
1866	if ( wp[1].bPresentFlag )
1867	{
1868	for ( Int j=1 ; j<3 ; j++ )
1869	{
1870	Int iDeltaWeight = (wp[j].iWeight - (1<<wp[1].uiLog2WeightDenom));
1871	WRITE_SVLC( iDeltaWeight, "delta_chroma_weight_lX" ); // se(v): delta_chroma_weight_lX
1872
1873	Int iDeltaChroma = (wp[j].iOffset + ( ( (g_uiIBDI_MAX>>1)*wp[j].iWeight)>>(wp[j].uiLog2WeightDenom) ) - (g_uiIBDI_MAX>>1));
1874	WRITE_SVLC( iDeltaChroma, "delta_chroma_offset_lX" ); // se(v): delta_chroma_offset_lX
1875	}
1876	}
1877	}
1878	}
1879	}
1880	}
1881	else if (uiMode == 3)
1882	{
1883	for ( Int iRefIdx=0 ; iRefIdx<pcSlice->getNumRefIdx(REF_PIC_LIST_C) ; iRefIdx++ )
1884	{
1885	RefPicList eRefPicList = (RefPicList)pcSlice->getListIdFromIdxOfLC(iRefIdx);
1886	Int iCombRefIdx = pcSlice->getRefIdxFromIdxOfLC(iRefIdx);
1887
1888	pcSlice->getWpScaling(eRefPicList, iCombRefIdx, wp);
1889	if ( !bDenomCoded )
1890	{
1891	Int iDeltaDenom;
1892	WRITE_UVLC( wp[0].uiLog2WeightDenom, "luma_log2_weight_denom" ); // ue(v): luma_log2_weight_denom
1893
1894	if( bChroma )
1895	{
1896	iDeltaDenom = (wp[1].uiLog2WeightDenom - wp[0].uiLog2WeightDenom);
1897	WRITE_SVLC( iDeltaDenom, "delta_chroma_log2_weight_denom" ); // se(v): delta_chroma_log2_weight_denom
1898	}
1899	bDenomCoded = true;
1900	}
1901
1902	WRITE_FLAG( wp[0].bPresentFlag, "luma_weight_lc_flag" ); // u(1): luma_weight_lc_flag
1903
1904	if ( wp[0].bPresentFlag )
1905	{
1906	Int iDeltaWeight = (wp[0].iWeight - (1<<wp[0].uiLog2WeightDenom));
1907	WRITE_SVLC( iDeltaWeight, "delta_luma_weight_lc" ); // se(v): delta_luma_weight_lc
1908	WRITE_SVLC( wp[0].iOffset, "luma_offset_lc" ); // se(v): luma_offset_lc
1909	}
1910	if ( bChroma )
1911	{
1912	WRITE_FLAG( wp[1].bPresentFlag, "chroma_weight_lc_flag" ); // u(1): luma_weight_lc_flag
1913
1914	if ( wp[1].bPresentFlag )
1915	{
1916	for ( Int j=1 ; j<3 ; j++ )
1917	{
1918	Int iDeltaWeight = (wp[j].iWeight - (1<<wp[1].uiLog2WeightDenom));
1919	WRITE_SVLC( iDeltaWeight, "delta_chroma_weight_lc" ); // se(v): delta_chroma_weight_lc
1920
1921	Int iDeltaChroma = (wp[j].iOffset + ( ( (g_uiIBDI_MAX>>1)*wp[j].iWeight)>>(wp[j].uiLog2WeightDenom) ) - (g_uiIBDI_MAX>>1));
1922	WRITE_SVLC( iDeltaChroma, "delta_chroma_offset_lc" ); // se(v): delta_chroma_offset_lc
1923	}
1924	}
1925	}
1926	}
1927	}
1928	}
1929
1930	/** code quantization matrix
1931	* \param scalingList quantization matrix information
1932	*/
1933	Void TEncCavlc::codeScalingList( TComScalingList* scalingList )
1934	{
1935	UInt listId,sizeId;
1936	Bool scalingListPredModeFlag;
1937
1938	#if SCALING_LIST_OUTPUT_RESULT
1939	Int startBit;
1940	Int startTotalBit;
1941	startBit = m_pcBitIf->getNumberOfWrittenBits();
1942	startTotalBit = m_pcBitIf->getNumberOfWrittenBits();
1943	#endif
1944
1945	WRITE_FLAG( scalingList->getScalingListPresentFlag (), "scaling_list_present_flag" );
1946
1947	if(scalingList->getScalingListPresentFlag () == false)
1948	{
1949	#if SCALING_LIST_OUTPUT_RESULT
1950	printf("Header Bit %d\n",m_pcBitIf->getNumberOfWrittenBits()-startBit);
1951	#endif
1952	//for each size
1953	for(sizeId = 0; sizeId < SCALING_LIST_SIZE_NUM; sizeId++)
1954	{
1955	for(listId = 0; listId < g_scalingListNum[sizeId]; listId++)
1956	{
1957	#if SCALING_LIST_OUTPUT_RESULT
1958	startBit = m_pcBitIf->getNumberOfWrittenBits();
1959	#endif
1960	scalingListPredModeFlag = scalingList->checkPredMode( sizeId, listId );
1961	WRITE_FLAG( scalingListPredModeFlag, "scaling_list_pred_mode_flag" );
1962	if(!scalingListPredModeFlag)// Copy Mode
1963	{
1964	WRITE_UVLC( (Int)listId - (Int)scalingList->getRefMatrixId (sizeId,listId) - 1, "scaling_list_pred_matrix_id_delta");
1965	}
1966	else// DPCM Mode
1967	{
1968	xCodeScalingList(scalingList, sizeId, listId);
1969	}
1970	#if SCALING_LIST_OUTPUT_RESULT
1971	printf("Matrix [%d][%d] Bit %d\n",sizeId,listId,m_pcBitIf->getNumberOfWrittenBits() - startBit);
1972	#endif
1973	}
1974	}
1975	}
1976	#if SCALING_LIST_OUTPUT_RESULT
1977	else
1978	{
1979	printf("Header Bit %d\n",m_pcBitIf->getNumberOfWrittenBits()-startTotalBit);
1980	}
1981	printf("Total Bit %d\n",m_pcBitIf->getNumberOfWrittenBits()-startTotalBit);
1982	#endif
1983	return;
1984	}
1985	/** code DPCM
1986	* \param scalingList quantization matrix information
1987	* \param sizeIdc size index
1988	* \param listIdc list index
1989	*/
1990	Void TEncCavlc::xCodeScalingList(TComScalingList* scalingList, UInt sizeId, UInt listId)
1991	{
1992	#if SCALING_LIST
1993	Int coefNum = min(MAX_MATRIX_COEF_NUM,(Int)g_scalingListSize[sizeId]);
1994	UInt* scan = g_auiFrameScanXY [ (sizeId == 0)? 1 : 2];
1995	#else
1996	Int coefNum = (Int)g_scalingListSize[sizeId];
1997	UInt* scan = g_auiFrameScanXY [ sizeId + 1];
1998	#endif
1999	Int nextCoef = SCALING_LIST_START_VALUE;
2000	Int data;
2001	Int *src = scalingList->getScalingListAddress(sizeId, listId);
2002	#if SCALING_LIST
2003	if(sizeId > SCALING_LIST_8x8 && scalingList->getUseDefaultScalingMatrixFlag(sizeId,listId))
2004	{
2005	WRITE_SVLC( -8, "scaling_list_dc_coef_minus8");
2006	}
2007	else if(sizeId < SCALING_LIST_16x16 && scalingList->getUseDefaultScalingMatrixFlag(sizeId,listId))
2008	{
2009	WRITE_SVLC( -8, "scaling_list_delta_coef");
2010	}
2011	else
2012	{
2013	if( sizeId > SCALING_LIST_8x8 )
2014	{
2015	WRITE_SVLC( scalingList->getScalingListDC(sizeId,listId) - 8, "scaling_list_dc_coef_minus8");
2016	}
2017	for(Int i=0;i<coefNum;i++)
2018	{
2019	data = src[scan[i]] - nextCoef;
2020	nextCoef = src[scan[i]];
2021	if(data > 127)
2022	{
2023	data = data - 256;
2024	}
2025	if(data < -128)
2026	{
2027	data = data + 256;
2028	}
2029
2030	WRITE_SVLC( data, "scaling_list_delta_coef");
2031	}
2032	}
2033	#else
2034	for(Int i=0;i<coefNum;i++)
2035	{
2036	data = src[scan[i]] - nextCoef;
2037	nextCoef = src[scan[i]];
2038	if(data > 127)
2039	{
2040	data = data - 256;
2041	}
2042	if(data < -128)
2043	{
2044	data = data + 256;
2045	}
2046
2047	WRITE_SVLC( data, "delta_coef");
2048	}
2049	#endif
2050	}
2051	Bool TComScalingList::checkPredMode(UInt sizeId, UInt listId)
2052	{
2053	for(Int predListIdx = (Int)listId -1 ; predListIdx >= 0; predListIdx--)
2054	{
2055	#if SCALING_LIST
2056	if( !memcmp(getScalingListAddress(sizeId,listId),getScalingListAddress(sizeId, predListIdx),sizeof(Int)*min(MAX_MATRIX_COEF_NUM,(Int)g_scalingListSize[sizeId])) // check value of matrix
2057	&& ((sizeId < SCALING_LIST_16x16) \|\| (getScalingListDC(sizeId,listId) == getScalingListDC(sizeId,predListIdx)))) // check DC value
2058	#else
2059	if( !memcmp(getScalingListAddress(sizeId,listId),getScalingListAddress(sizeId, predListIdx),sizeof(Int)*(Int)g_scalingListSize[sizeId])) // check value of matrix
2060	#endif
2061	{
2062	setRefMatrixId(sizeId, listId, predListIdx);
2063	return false;
2064	}
2065	}
2066	return true;
2067	}
2068	//! \}

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

JCT-3V 3D-HEVC

Context navigation

source: 3DVCSoftware/branches/HTM-4.1-dev2-HHI/source/Lib/TLibEncoder/TEncCavlc.cpp

Download in other formats: