Context navigation

← Previous revision
Next revision →
Blame
Revision log

TEncCavlc.cpp

Visit:

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

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

JCT-3V 3D-HEVC

Context navigation

source: 3DVCSoftware/branches/HTM-6.2-dev3-Qualcomm/source/Lib/TLibEncoder/TEncCavlc.cpp

Download in other formats: