Context navigation

TEncCavlc.cpp @ 193

Visit:

Last change on this file since 193 was 193, checked in by mitsubishi-htm, 12 years ago

A second release, as planned

Migrate to HTM 4.1
Move VSP related switches to cfg file instead of #define in the source code
A few bug fixes
For VC project files, only VC9 file is updated

TODO

Migrate to HTM 5.0, to be used as anchor for CE1 toward Geneva meeting

Property svn:eol-style set to native

File size: 68.8 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	#if VSP_N
698	if( pcSPS->getViewId() )
699	{
700	WRITE_FLAG( pcSPS->getVspPresentFlag(), "vsp_present_flag" );
701	#if VSP_CFG
702	if( pcSPS->getVspPresentFlag() )
703	{
704	WRITE_FLAG( pcSPS->getVspDepthPresentFlag(), "vsp_depth_present_flag" );
705	}
706	#endif
707	}
708	#endif
709	WRITE_FLAG( 0, "sps_extension2_flag" );
710	}
711
712	Void TEncCavlc::writeTileMarker( UInt uiTileIdx, UInt uiBitsUsed )
713	{
714	xWriteCode( uiTileIdx, uiBitsUsed );
715	}
716
717	Void TEncCavlc::codeSliceHeader ( TComSlice* pcSlice )
718	{
719	#if ENC_DEC_TRACE
720	xTraceSliceHeader (pcSlice);
721	#endif
722
723	#if VSP_CFG
724	Int iNumOfVspRefsL0 = 0;
725	Int iNumOfVspRefsL1 = 0;
726	#endif
727
728	// if( nal_ref_idc != 0 )
729	// dec_ref_pic_marking( )
730	// if( entropy_coding_mode_flag && slice_type != I)
731	// cabac_init_idc
732	// first_slice_in_pic_flag
733	// if( first_slice_in_pic_flag == 0 )
734	// slice_address
735	//calculate number of bits required for slice address
736	Int maxAddrOuter = pcSlice->getPic()->getNumCUsInFrame();
737	Int reqBitsOuter = 0;
738	while(maxAddrOuter>(1<<reqBitsOuter))
739	{
740	reqBitsOuter++;
741	}
742	Int maxAddrInner = pcSlice->getPic()->getNumPartInCU()>>(2);
743	maxAddrInner = (1<<(pcSlice->getPPS()->getSliceGranularity()<<1));
744	Int reqBitsInner = 0;
745
746	while(maxAddrInner>(1<<reqBitsInner))
747	{
748	reqBitsInner++;
749	}
750	Int lCUAddress;
751	Int innerAddress;
752	if (pcSlice->isNextSlice())
753	{
754	// Calculate slice address
755	lCUAddress = (pcSlice->getSliceCurStartCUAddr()/pcSlice->getPic()->getNumPartInCU());
756	innerAddress = (pcSlice->getSliceCurStartCUAddr()%(pcSlice->getPic()->getNumPartInCU()))>>((pcSlice->getSPS()->getMaxCUDepth()-pcSlice->getPPS()->getSliceGranularity())<<1);
757	}
758	else
759	{
760	// Calculate slice address
761	lCUAddress = (pcSlice->getEntropySliceCurStartCUAddr()/pcSlice->getPic()->getNumPartInCU());
762	innerAddress = (pcSlice->getEntropySliceCurStartCUAddr()%(pcSlice->getPic()->getNumPartInCU()))>>((pcSlice->getSPS()->getMaxCUDepth()-pcSlice->getPPS()->getSliceGranularity())<<1);
763
764	}
765	//write slice address
766	Int address = (pcSlice->getPic()->getPicSym()->getCUOrderMap(lCUAddress) << reqBitsInner) + innerAddress;
767	WRITE_FLAG( address==0, "first_slice_in_pic_flag" );
768	if(address>0)
769	{
770	WRITE_CODE( address, reqBitsOuter+reqBitsInner, "slice_address" );
771	}
772
773	WRITE_UVLC( pcSlice->getSliceType(), "slice_type" );
774	Bool bEntropySlice = (!pcSlice->isNextSlice());
775	WRITE_FLAG( bEntropySlice ? 1 : 0, "lightweight_slice_flag" );
776
777	if (!bEntropySlice)
778	{
779	WRITE_UVLC( pcSlice->getPPS()->getPPSId(), "pic_parameter_set_id" );
780	#if H0388
781	if( pcSlice->getPPS()->getOutputFlagPresentFlag() )
782	{
783	WRITE_FLAG( pcSlice->getPicOutputFlag() ? 1 : 0, "pic_output_flag" );
784	}
785	#endif
786	if(pcSlice->getNalUnitType()==NAL_UNIT_CODED_SLICE_IDR)
787	{
788	WRITE_UVLC( 0, "idr_pic_id" );
789	WRITE_FLAG( 0, "no_output_of_prior_pics_flag" );
790	}
791	else
792	{
793	WRITE_CODE( (pcSlice->getPOC()-pcSlice->getLastIDR()+(1<<pcSlice->getSPS()->getBitsForPOC()))%(1<<pcSlice->getSPS()->getBitsForPOC()), pcSlice->getSPS()->getBitsForPOC(), "pic_order_cnt_lsb");
794	if( pcSlice->getPOC() == 0 && pcSlice->getNalUnitType() != NAL_UNIT_CODED_SLICE_IDV )
795	{
796	TComReferencePictureSet* rps = pcSlice->getRPS();
797	if(pcSlice->getRPSidx() < 0)
798	{
799	WRITE_FLAG( 0, "short_term_ref_pic_set_sps_flag");
800	#if RPS_IN_SPS
801	codeShortTermRefPicSet(pcSlice->getSPS(), rps);
802	#else
803	codeShortTermRefPicSet(pcSlice->getPPS(), rps);
804	#endif
805	}
806	else
807	{
808	WRITE_FLAG( 1, "short_term_ref_pic_set_sps_flag");
809	WRITE_UVLC( pcSlice->getRPSidx(), "short_term_ref_pic_set_idx" );
810	}
811	#if RPS_IN_SPS
812	if(pcSlice->getSPS()->getLongTermRefsPresent())
813	#else
814	if(pcSlice->getPPS()->getLongTermRefsPresent())
815	#endif
816	{
817	WRITE_UVLC( rps->getNumberOfLongtermPictures(), "num_long_term_pics");
818	Int maxPocLsb = 1<<pcSlice->getSPS()->getBitsForPOC();
819	Int prev = 0;
820	#if LTRP_MULT
821	Int prevDeltaPocLt=0;
822	Int currDeltaPocLt=0;
823	#endif
824	for(Int i=rps->getNumberOfPictures()-1 ; i > rps->getNumberOfPictures()-rps->getNumberOfLongtermPictures()-1; i--)
825	{
826	WRITE_UVLC((maxPocLsb-rps->getDeltaPOC(i)+prev)%maxPocLsb, "delta_poc_lsb_lt");
827
828	#if LTRP_MULT
829	currDeltaPocLt=((maxPocLsb-rps->getDeltaPOC(i)+prev)%maxPocLsb)+prevDeltaPocLt;
830
831	Int deltaMsbCycle=0;
832	if( (i==(rps->getNumberOfPictures()-1)) )
833	{
834	deltaMsbCycle=((-rps->getDeltaPOC(i))/maxPocLsb)-1;
835	}
836	else if( prevDeltaPocLt!=currDeltaPocLt )
837	{
838	deltaMsbCycle=((-rps->getDeltaPOC(i))/maxPocLsb)-1;
839	if( ((prevDeltaPocLt==maxPocLsb-1) && (currDeltaPocLt==maxPocLsb+1)) \|\| ((prevDeltaPocLt==maxPocLsb-2) && (currDeltaPocLt==maxPocLsb)))
840	{
841	deltaMsbCycle=deltaMsbCycle-1;
842	}
843	}
844	else
845	{
846	deltaMsbCycle=((rps->getDeltaPOC(i+1)-rps->getDeltaPOC(i))/maxPocLsb)-1;
847	}
848
849	if(deltaMsbCycle>=0)
850	{
851	WRITE_FLAG( 1, "delta_poc_msb_present_flag");
852	WRITE_UVLC(deltaMsbCycle, "delta_poc_msb_cycle_lt_minus1");
853	}
854	else
855	{
856	WRITE_FLAG( 0, "delta_poc_msb_present_flag");
857	}
858	prevDeltaPocLt=currDeltaPocLt;
859	#endif
860	prev = rps->getDeltaPOC(i);
861	WRITE_FLAG( rps->getUsed(i), "used_by_curr_pic_lt_flag");
862	}
863	}
864	}
865	if( pcSlice->getPOC() != 0 )
866	{
867	TComReferencePictureSet* rps = pcSlice->getRPS();
868	if(pcSlice->getRPSidx() < 0)
869	{
870	WRITE_FLAG( 0, "short_term_ref_pic_set_sps_flag");
871	#if RPS_IN_SPS
872	codeShortTermRefPicSet(pcSlice->getSPS(), rps);
873	#else
874	codeShortTermRefPicSet(pcSlice->getPPS(), rps);
875	#endif
876	}
877	else
878	{
879	WRITE_FLAG( 1, "short_term_ref_pic_set_sps_flag");
880	WRITE_UVLC( pcSlice->getRPSidx(), "short_term_ref_pic_set_idx" );
881	}
882	#if RPS_IN_SPS
883	if(pcSlice->getSPS()->getLongTermRefsPresent())
884	#else
885	if(pcSlice->getPPS()->getLongTermRefsPresent())
886	#endif
887	{
888	WRITE_UVLC( rps->getNumberOfLongtermPictures(), "num_long_term_pics");
889	Int maxPocLsb = 1<<pcSlice->getSPS()->getBitsForPOC();
890	Int prev = 0;
891	#if LTRP_MULT
892	Int prevDeltaPocLt=0;
893	Int currDeltaPocLt=0;
894	#endif
895	for(Int i=rps->getNumberOfPictures()-1 ; i > rps->getNumberOfPictures()-rps->getNumberOfLongtermPictures()-1; i--)
896	{
897	WRITE_UVLC((maxPocLsb-rps->getDeltaPOC(i)+prev)%maxPocLsb, "delta_poc_lsb_lt");
898
899	#if LTRP_MULT
900	currDeltaPocLt=((maxPocLsb-rps->getDeltaPOC(i)+prev)%maxPocLsb)+prevDeltaPocLt;
901
902	Int deltaMsbCycle=0;
903	if( (i==(rps->getNumberOfPictures()-1)) )
904	{
905	deltaMsbCycle=((-rps->getDeltaPOC(i))/maxPocLsb)-1;
906	}
907	else if( prevDeltaPocLt!=currDeltaPocLt )
908	{
909	deltaMsbCycle=((-rps->getDeltaPOC(i))/maxPocLsb)-1;
910	if( ((prevDeltaPocLt==maxPocLsb-1) && (currDeltaPocLt==maxPocLsb+1)) \|\| ((prevDeltaPocLt==maxPocLsb-2) && (currDeltaPocLt==maxPocLsb)))
911	{
912	deltaMsbCycle=deltaMsbCycle-1;
913	}
914	}
915	else
916	{
917	deltaMsbCycle=((rps->getDeltaPOC(i+1)-rps->getDeltaPOC(i))/maxPocLsb)-1;
918	}
919
920	if(deltaMsbCycle>=0)
921	{
922	WRITE_FLAG( 1, "delta_poc_msb_present_flag");
923	WRITE_UVLC(deltaMsbCycle, "delta_poc_msb_cycle_lt_minus1");
924	}
925	else
926	{
927	WRITE_FLAG( 0, "delta_poc_msb_present_flag");
928	}
929	prevDeltaPocLt=currDeltaPocLt;
930	#endif
931	prev = rps->getDeltaPOC(i);
932	WRITE_FLAG( rps->getUsed(i), "used_by_curr_pic_lt_flag");
933	}
934	}
935	}
936	}
937
938	if(pcSlice->getSPS()->getUseSAO() \|\| pcSlice->getSPS()->getUseALF()\|\| pcSlice->getSPS()->getScalingListFlag() \|\| pcSlice->getSPS()->getUseDF())
939	{
940	if (pcSlice->getSPS()->getUseALF())
941	{
942	#if !LCU_SYNTAX_ALF
943	if (pcSlice->getAlfEnabledFlag())
944	{
945	assert (pcSlice->getAPS()->getAlfEnabled());
946	}
947	#endif
948	WRITE_FLAG( pcSlice->getAlfEnabledFlag(), "ALF on/off flag in slice header" );
949	}
950	if (pcSlice->getSPS()->getUseSAO())
951	{
952	#if SAO_UNIT_INTERLEAVING
953	WRITE_FLAG( pcSlice->getSaoInterleavingFlag(), "SAO interleaving flag" );
954	#endif
955	assert (pcSlice->getSaoEnabledFlag() == pcSlice->getAPS()->getSaoEnabled());
956	WRITE_FLAG( pcSlice->getSaoEnabledFlag(), "SAO on/off flag in slice header" );
957	#if SAO_UNIT_INTERLEAVING
958	if (pcSlice->getSaoInterleavingFlag()&&pcSlice->getSaoEnabledFlag() )
959	{
960	WRITE_FLAG( pcSlice->getAPS()->getSaoParam()->bSaoFlag[1], "SAO on/off flag for Cb in slice header" );
961	WRITE_FLAG( pcSlice->getAPS()->getSaoParam()->bSaoFlag[2], "SAO on/off flag for Cr in slice header" );
962	}
963	#endif
964	}
965	WRITE_UVLC( pcSlice->getAPS()->getAPSID(), "aps_id");
966	}
967
968	#if VSP_SLICE_HEADER && VSP_CFG
969	if( pcSlice->getSPS()->getViewId()!=0
970	&& pcSlice->getSliceType() != I_SLICE
971	&& pcSlice->getSPS()->getVspPresentFlag()
972	)
973	{
974	if( !pcSlice->getSPS()->isDepth() \|\| pcSlice->getSPS()->getVspDepthPresentFlag() )
975	{
976	WRITE_UVLC( pcSlice->getNumVspRefPics(), "num_vsp_ref_pics");
977	for( UInt i = 0; i < pcSlice->getNumVspRefPics(); i++ )
978	{
979	WRITE_UVLC( pcSlice->getVspRefPos( REF_PIC_LIST_0, i ), "vsp_ref_list0_pos");
980	if( pcSlice->getSliceType() == B_SLICE )
981	{
982	WRITE_UVLC( pcSlice->getVspRefPos( REF_PIC_LIST_1, i ), "vsp_ref_list1_pos");
983	}
984	}
985	iNumOfVspRefsL0 = ( (pcSlice->getSPS()->getViewId()==0
986	\|\| (!pcSlice->getSPS()->getVspDepthPresentFlag() && pcSlice->getSPS()->isDepth())
987	\|\| !pcSlice->getVspFlag()
988	\|\| pcSlice->getVspRefPos(REF_PIC_LIST_0, 0) == 0 ) ? 0 : 1 );
989	iNumOfVspRefsL1 = ( (pcSlice->getSPS()->getViewId()==0
990	\|\| (!pcSlice->getSPS()->getVspDepthPresentFlag() && pcSlice->getSPS()->isDepth())
991	\|\| !pcSlice->getVspFlag()
992	\|\| pcSlice->getVspRefPos(REF_PIC_LIST_1, 0) == 0 ) ? 0 : 1 );
993	}
994	}
995	#endif
996
997	// we always set num_ref_idx_active_override_flag equal to one. this might be done in a more intelligent way
998	if (!pcSlice->isIntra())
999	{
1000	WRITE_FLAG( 1 , "num_ref_idx_active_override_flag");
1001	#if VSP_CFG
1002	WRITE_CODE( pcSlice->getNumRefIdx( REF_PIC_LIST_0 ) - 1 - iNumOfVspRefsL0, 3, "num_ref_idx_l0_active_minus1" );
1003	#else
1004	WRITE_CODE( pcSlice->getNumRefIdx( REF_PIC_LIST_0 ) - 1, 3, "num_ref_idx_l0_active_minus1" );
1005	#endif
1006	}
1007	else
1008	{
1009	pcSlice->setNumRefIdx(REF_PIC_LIST_0, 0);
1010	}
1011	if (pcSlice->isInterB())
1012	{
1013	#if VSP_CFG
1014	WRITE_CODE( pcSlice->getNumRefIdx( REF_PIC_LIST_1 ) - 1 - iNumOfVspRefsL1, 3, "num_ref_idx_l1_active_minus1" );
1015	#else
1016	WRITE_CODE( pcSlice->getNumRefIdx( REF_PIC_LIST_1 ) - 1, 3, "num_ref_idx_l1_active_minus1" );
1017	#endif
1018	}
1019	else
1020	{
1021	pcSlice->setNumRefIdx(REF_PIC_LIST_1, 0);
1022	}
1023	#if H0412_REF_PIC_LIST_RESTRICTION
1024	if( pcSlice->getSPS()->getListsModificationPresentFlag() )
1025	{
1026	#endif
1027	TComRefPicListModification* refPicListModification = pcSlice->getRefPicListModification();
1028	#if H0137_0138_LIST_MODIFICATION
1029	if( !pcSlice->isIntra() )
1030	{
1031	WRITE_FLAG(pcSlice->getRefPicListModification()->getRefPicListModificationFlagL0() ? 1 : 0, "ref_pic_list_modification_flag_l0" );
1032	if (pcSlice->getRefPicListModification()->getRefPicListModificationFlagL0())
1033	{
1034	Int NumPocTotalCurr = pcSlice->getNumPocTotalCurrMvc();
1035	if (NumPocTotalCurr > 1)
1036	{
1037	Int length = 1;
1038	NumPocTotalCurr --;
1039	while ( NumPocTotalCurr >>= 1)
1040	{
1041	length ++;
1042	}
1043	for(Int i = 0; i < pcSlice->getNumRefIdx( REF_PIC_LIST_0 ); i++)
1044	{
1045	WRITE_CODE( refPicListModification->getRefPicSetIdxL0(i), length, "list_entry_l0");
1046	}
1047	}
1048	}
1049	}
1050	if(pcSlice->isInterB())
1051	{
1052	WRITE_FLAG(pcSlice->getRefPicListModification()->getRefPicListModificationFlagL1() ? 1 : 0, "ref_pic_list_modification_flag_l1" );
1053	if (pcSlice->getRefPicListModification()->getRefPicListModificationFlagL1())
1054	{
1055	Int NumPocTotalCurr = pcSlice->getNumPocTotalCurrMvc();
1056	if ( NumPocTotalCurr > 1 )
1057	{
1058	Int length = 1;
1059	NumPocTotalCurr --;
1060	while ( NumPocTotalCurr >>= 1)
1061	{
1062	length ++;
1063	}
1064	for(Int i = 0; i < pcSlice->getNumRefIdx( REF_PIC_LIST_1 ); i++)
1065	{
1066	WRITE_CODE( refPicListModification->getRefPicSetIdxL1(i), length, "list_entry_l1");
1067	}
1068	}
1069	}
1070	}
1071	#else
1072	if(!pcSlice->isIntra())
1073	{
1074	WRITE_FLAG(pcSlice->getRefPicListModification()->getRefPicListModificationFlagL0() ? 1 : 0, "ref_pic_list_modification_flag" );
1075	for(Int i = 0; i < refPicListModification->getNumberOfRefPicListModificationsL0(); i++)
1076	{
1077	WRITE_UVLC( refPicListModification->getListIdcL0(i), "ref_pic_list_modification_idc");
1078	WRITE_UVLC( refPicListModification->getRefPicSetIdxL0(i), "ref_pic_set_idx");
1079	}
1080	if(pcSlice->getRefPicListModification()->getRefPicListModificationFlagL0())
1081	WRITE_UVLC( 3, "ref_pic_list_modification_idc");
1082	}
1083	if(pcSlice->isInterB())
1084	{
1085	WRITE_FLAG(pcSlice->getRefPicListModification()->getRefPicListModificationFlagL1() ? 1 : 0, "ref_pic_list_modification_flag" );
1086	for(Int i = 0; i < refPicListModification->getNumberOfRefPicListModificationsL1(); i++)
1087	{
1088	WRITE_UVLC( refPicListModification->getListIdcL1(i), "ref_pic_list_modification_idc");
1089	WRITE_UVLC( refPicListModification->getRefPicSetIdxL1(i), "ref_pic_set_idx");
1090	}
1091	if(pcSlice->getRefPicListModification()->getRefPicListModificationFlagL1())
1092	WRITE_UVLC( 3, "ref_pic_list_modification_idc");
1093	}
1094	#endif
1095	}
1096	#if H0412_REF_PIC_LIST_RESTRICTION
1097	}
1098	#endif
1099	// ref_pic_list_combination( )
1100	// maybe move to own function?
1101	if (pcSlice->isInterB())
1102	{
1103	WRITE_FLAG(pcSlice->getRefPicListCombinationFlag() ? 1 : 0, "ref_pic_list_combination_flag" );
1104	if(pcSlice->getRefPicListCombinationFlag())
1105	{
1106	#if VSP_CFG
1107	WRITE_UVLC( pcSlice->getNumRefIdx(REF_PIC_LIST_C) - 1 - iNumOfVspRefsL0, "num_ref_idx lc_active_minus1");
1108	#else
1109	WRITE_UVLC( pcSlice->getNumRefIdx(REF_PIC_LIST_C) - 1, "num_ref_idx lc_active_minus1");
1110	#endif
1111
1112	#if H0412_REF_PIC_LIST_RESTRICTION
1113	if( pcSlice->getSPS()->getListsModificationPresentFlag() )
1114	{
1115	#endif
1116	WRITE_FLAG( pcSlice->getRefPicListModificationFlagLC() ? 1 : 0, "ref_pic_list_modification_flag_lc" );
1117	if(pcSlice->getRefPicListModificationFlagLC())
1118	{
1119	for (UInt i=0;i<pcSlice->getNumRefIdx(REF_PIC_LIST_C);i++)
1120	{
1121	WRITE_FLAG( pcSlice->getListIdFromIdxOfLC(i), "pic_from_list_0_flag" );
1122	#if H0137_0138_LIST_MODIFICATION
1123	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 ) )
1124	{
1125	WRITE_UVLC( pcSlice->getRefIdxFromIdxOfLC(i), "ref_idx_list_curr" );
1126	}
1127	#else
1128	WRITE_UVLC( pcSlice->getRefIdxFromIdxOfLC(i), "ref_idx_list_curr" );
1129	#endif
1130	}
1131	}
1132	#if H0412_REF_PIC_LIST_RESTRICTION
1133	}
1134	#endif
1135	}
1136	}
1137
1138	#if H0111_MVD_L1_ZERO
1139	if (pcSlice->isInterB())
1140	{
1141	WRITE_FLAG( pcSlice->getMvdL1ZeroFlag() ? 1 : 0, "mvd_l1_zero_flag");
1142	}
1143	#endif
1144
1145	if(pcSlice->getPPS()->getEntropyCodingMode() && !pcSlice->isIntra())
1146	{
1147	#if CABAC_INIT_FLAG
1148	if (!pcSlice->isIntra() && pcSlice->getPPS()->getCabacInitPresentFlag())
1149	{
1150	SliceType sliceType = pcSlice->getSliceType();
1151	Int encCABACTableIdx = pcSlice->getPPS()->getEncCABACTableIdx();
1152	Bool encCabacInitFlag = (sliceType!=encCABACTableIdx && encCABACTableIdx!=0) ? true : false;
1153	pcSlice->setCabacInitFlag( encCabacInitFlag );
1154	WRITE_FLAG( encCabacInitFlag?1:0, "cabac_init_flag" );
1155	}
1156	#else
1157	WRITE_UVLC(pcSlice->getCABACinitIDC(), "cabac_init_idc");
1158	#endif
1159	}
1160
1161	// if( !lightweight_slice_flag ) {
1162	if (!bEntropySlice)
1163	{
1164	Int iCode = pcSlice->getSliceQp() - ( pcSlice->getPPS()->getPicInitQPMinus26() + 26 );
1165	WRITE_SVLC( iCode, "slice_qp_delta" );
1166	#if DBL_CONTROL
1167	if (pcSlice->getPPS()->getDeblockingFilterControlPresent())
1168	{
1169	if ( pcSlice->getSPS()->getUseDF() )
1170	{
1171	WRITE_FLAG(pcSlice->getInheritDblParamFromAPS(), "inherit_dbl_param_from_APS_flag");
1172	}
1173	#else
1174	WRITE_FLAG(pcSlice->getInheritDblParamFromAPS(), "inherit_dbl_param_from_APS_flag");
1175	#endif
1176	if (!pcSlice->getInheritDblParamFromAPS())
1177	{
1178	WRITE_FLAG(pcSlice->getLoopFilterDisable(), "loop_filter_disable"); // should be an IDC
1179	if(!pcSlice->getLoopFilterDisable())
1180	{
1181	WRITE_SVLC (pcSlice->getLoopFilterBetaOffset(), "beta_offset_div2");
1182	WRITE_SVLC (pcSlice->getLoopFilterTcOffset(), "tc_offset_div2");
1183	}
1184	}
1185	#if DBL_CONTROL
1186	}
1187	#endif
1188	if ( pcSlice->getSliceType() == B_SLICE )
1189	{
1190	WRITE_FLAG( pcSlice->getColDir(), "collocated_from_l0_flag" );
1191	}
1192
1193	#if COLLOCATED_REF_IDX
1194	if ( pcSlice->getSliceType() != I_SLICE &&
1195	((pcSlice->getColDir()==0 && pcSlice->getNumRefIdx(REF_PIC_LIST_0)>1)\|\|
1196	(pcSlice->getColDir()==1 && pcSlice->getNumRefIdx(REF_PIC_LIST_1)>1)))
1197	{
1198	WRITE_UVLC( pcSlice->getColRefIdx(), "collocated_ref_idx" );
1199	}
1200	#endif
1201
1202	if ( (pcSlice->getPPS()->getUseWP() && pcSlice->getSliceType()==P_SLICE) \|\| (pcSlice->getPPS()->getWPBiPredIdc()==1 && pcSlice->getSliceType()==B_SLICE) )
1203	{
1204	xCodePredWeightTable( pcSlice );
1205	}
1206	}
1207
1208	// !!!! sytnax elements not in the WD !!!!
1209	if (!bEntropySlice)
1210	{
1211	if( pcSlice->getSPS()->hasCamParInSliceHeader() )
1212	{
1213	for( UInt uiId = 0; uiId < pcSlice->getSPS()->getViewId(); uiId++ )
1214	{
1215	WRITE_SVLC( pcSlice->getCodedScale ()[ uiId ], "coded_scale" );
1216	WRITE_SVLC( pcSlice->getCodedOffset ()[ uiId ], "coded_offset" );
1217	WRITE_SVLC( pcSlice->getInvCodedScale ()[ uiId ] + pcSlice->getCodedScale ()[ uiId ], "inverse_coded_scale_plus_coded_scale" );
1218	WRITE_SVLC( pcSlice->getInvCodedOffset()[ uiId ] + pcSlice->getCodedOffset()[ uiId ], "inverse_coded_offset_plus_coded_offset" );
1219	}
1220	}
1221	}
1222
1223	#if ( HHI_MPI \|\| HHI_INTER_VIEW_MOTION_PRED )
1224	#if ( HHI_MPI && HHI_INTER_VIEW_MOTION_PRED )
1225	const int iExtraMergeCandidates = ( pcSlice->getSPS()->getUseMVI() \|\| pcSlice->getSPS()->getMultiviewMvPredMode() ) ? 1 : 0;
1226	#elif HHI_MPI
1227	const int iExtraMergeCandidates = pcSlice->getSPS()->getUseMVI() ? 1 : 0;
1228	#else
1229	const int iExtraMergeCandidates = pcSlice->getSPS()->getMultiviewMvPredMode() ? 1 : 0;
1230	#endif
1231	assert(pcSlice->getMaxNumMergeCand()<=(MRG_MAX_NUM_CANDS_SIGNALED+iExtraMergeCandidates));
1232	assert(MRG_MAX_NUM_CANDS_SIGNALED<=MRG_MAX_NUM_CANDS);
1233	WRITE_UVLC(MRG_MAX_NUM_CANDS + iExtraMergeCandidates - pcSlice->getMaxNumMergeCand(), "maxNumMergeCand");
1234	#else
1235	assert(pcSlice->getMaxNumMergeCand()<=MRG_MAX_NUM_CANDS_SIGNALED);
1236	assert(MRG_MAX_NUM_CANDS_SIGNALED<=MRG_MAX_NUM_CANDS);
1237	WRITE_UVLC(MRG_MAX_NUM_CANDS - pcSlice->getMaxNumMergeCand(), "maxNumMergeCand");
1238	#endif
1239
1240	#if !VSP_CFG
1241	#if VSP_SLICE_HEADER
1242	if( pcSlice->getSPS()->getViewId()!=0
1243	&& pcSlice->getSPS()->getVspPresentFlag()
1244	)
1245	{
1246	WRITE_FLAG( pcSlice->getVspFlag()?1:0, "vsp_flag" );
1247	// printf("[VSP: %d] ", pcSlice->getVspFlag()?1:0);
1248	if( pcSlice->getVspFlag() )
1249	{
1250	WRITE_FLAG( pcSlice->getVspDepthDisableFlag()?1:0 , "vsp_depth_disable_flag" );
1251	}
1252	}
1253	#endif
1254	#endif
1255	}
1256
1257
1258	Void TEncCavlc::codeTileMarkerFlag(TComSlice* pcSlice)
1259	{
1260	Bool bEntropySlice = (!pcSlice->isNextSlice());
1261	if (!bEntropySlice)
1262	{
1263	xWriteFlag (pcSlice->getTileMarkerFlag() ? 1 : 0 );
1264	}
1265	}
1266
1267	/**
1268	- write wavefront substreams sizes for the slice header.
1269	.
1270	\param pcSlice Where we find the substream size information.
1271	*/
1272	#if TILES_WPP_ENTRY_POINT_SIGNALLING
1273	Void TEncCavlc::codeTilesWPPEntryPoint( TComSlice* pSlice )
1274	{
1275	Int tilesOrEntropyCodingSyncIdc = pSlice->getSPS()->getTilesOrEntropyCodingSyncIdc();
1276
1277	if ( tilesOrEntropyCodingSyncIdc == 0 )
1278	{
1279	return;
1280	}
1281
1282	UInt numEntryPointOffsets = 0, offsetLenMinus1 = 0, maxOffset = 0;
1283	UInt *entryPointOffset = NULL;
1284	if (tilesOrEntropyCodingSyncIdc == 1) // tiles
1285	{
1286	numEntryPointOffsets = pSlice->getTileLocationCount();
1287	entryPointOffset = new UInt[numEntryPointOffsets];
1288	for (Int idx=0; idx<pSlice->getTileLocationCount(); idx++)
1289	{
1290	if ( idx == 0 )
1291	{
1292	entryPointOffset [ idx ] = pSlice->getTileLocation( 0 );
1293	}
1294	else
1295	{
1296	entryPointOffset [ idx ] = pSlice->getTileLocation( idx ) - pSlice->getTileLocation( idx-1 );
1297	}
1298
1299	if ( entryPointOffset[ idx ] > maxOffset )
1300	{
1301	maxOffset = entryPointOffset[ idx ];
1302	}
1303	}
1304	}
1305	else if (tilesOrEntropyCodingSyncIdc == 2) // wavefront
1306	{
1307	Int numZeroSubstreamsAtEndOfSlice = 0;
1308	UInt* pSubstreamSizes = pSlice->getSubstreamSizes();
1309	// Find number of zero substreams at the end of slice
1310	for (Int idx=pSlice->getPPS()->getNumSubstreams()-2; idx>=0; idx--)
1311	{
1312	if ( pSubstreamSizes[ idx ] == 0 )
1313	{
1314	numZeroSubstreamsAtEndOfSlice++;
1315	}
1316	else
1317	{
1318	break;
1319	}
1320	}
1321	numEntryPointOffsets = pSlice->getPPS()->getNumSubstreams() - 1 - numZeroSubstreamsAtEndOfSlice;
1322	entryPointOffset = new UInt[numEntryPointOffsets];
1323	for (Int idx=0; idx<numEntryPointOffsets; idx++)
1324	{
1325	entryPointOffset[ idx ] = ( pSubstreamSizes[ idx ] >> 3 ) ;
1326	if ( entryPointOffset[ idx ] > maxOffset )
1327	{
1328	maxOffset = entryPointOffset[ idx ];
1329	}
1330	}
1331	}
1332
1333	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"
1334
1335	// Determine number of bits "offsetLenMinus1+1" required for entry point information
1336	offsetLenMinus1 = 0;
1337	while (1)
1338	{
1339	if (maxOffset >= (1 << offsetLenMinus1) )
1340	{
1341	offsetLenMinus1++;
1342	if ( offsetLenMinus1 > 32 )
1343	{
1344	FATAL_ERROR_0("exceeded 32-bits", -1);
1345	}
1346	}
1347	else
1348	{
1349	break;
1350	}
1351	}
1352
1353	WRITE_UVLC(numEntryPointOffsets, "num_entry_point_offsets");
1354	if (numEntryPointOffsets>0)
1355	{
1356	WRITE_UVLC(offsetLenMinus1, "offset_len_minus1");
1357	}
1358
1359	for (UInt idx=0; idx<numEntryPointOffsets; idx++)
1360	{
1361	if ( idx == 0 )
1362	{
1363	// Adding sizes of NALU header and slice header information to entryPointOffset[ 0 ]
1364	Int bitDistFromNALUHdrStart = m_pcBitIf->getNumberOfWrittenBits() + 16;
1365	entryPointOffset[ idx ] += ( bitDistFromNALUHdrStart + numEntryPointOffsets*(offsetLenMinus1+1) ) >> 3;
1366	}
1367	WRITE_CODE(entryPointOffset[ idx ], offsetLenMinus1+1, "entry_point_offset");
1368	}
1369
1370	delete [] entryPointOffset;
1371	}
1372	#else
1373	Void TEncCavlc::codeSliceHeaderSubstreamTable( TComSlice* pcSlice )
1374	{
1375	UInt uiNumSubstreams = pcSlice->getPPS()->getNumSubstreams();
1376	UInt*puiSubstreamSizes = pcSlice->getSubstreamSizes();
1377
1378	// Write header information for all substreams except the last.
1379	for (UInt ui = 0; ui+1 < uiNumSubstreams; ui++)
1380	{
1381	UInt uiNumbits = puiSubstreamSizes[ui];
1382
1383	//the 2 first bits are used to give the size of the header
1384	if ( uiNumbits < (1<<8) )
1385	{
1386	xWriteCode(0, 2 );
1387	xWriteCode(uiNumbits, 8 );
1388	}
1389	else if ( uiNumbits < (1<<16) )
1390	{
1391	xWriteCode(1, 2 );
1392	xWriteCode(uiNumbits, 16 );
1393	}
1394	else if ( uiNumbits < (1<<24) )
1395	{
1396	xWriteCode(2, 2 );
1397	xWriteCode(uiNumbits, 24 );
1398	}
1399	else if ( uiNumbits < (1<<31) )
1400	{
1401	xWriteCode(3, 2 );
1402	xWriteCode(uiNumbits, 32 );
1403	}
1404	else
1405	{
1406	printf("Error in codeSliceHeaderTable\n");
1407	exit(-1);
1408	}
1409	}
1410	}
1411	#endif
1412
1413	Void TEncCavlc::codeTerminatingBit ( UInt uilsLast )
1414	{
1415	}
1416
1417	Void TEncCavlc::codeSliceFinish ()
1418	{
1419	}
1420
1421	#if HHI_INTER_VIEW_MOTION_PRED
1422	Void TEncCavlc::codeMVPIdx ( TComDataCU* pcCU, UInt uiAbsPartIdx, RefPicList eRefList, Int iNum )
1423	#else
1424	Void TEncCavlc::codeMVPIdx ( TComDataCU* pcCU, UInt uiAbsPartIdx, RefPicList eRefList )
1425	#endif
1426	{
1427	assert(0);
1428	}
1429
1430	Void TEncCavlc::codePartSize( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
1431	{
1432	assert(0);
1433	}
1434
1435	Void TEncCavlc::codePredMode( TComDataCU* pcCU, UInt uiAbsPartIdx )
1436	{
1437	assert(0);
1438	}
1439
1440	Void TEncCavlc::codeMergeFlag ( TComDataCU* pcCU, UInt uiAbsPartIdx )
1441	{
1442	assert(0);
1443	}
1444
1445	Void TEncCavlc::codeMergeIndex ( TComDataCU* pcCU, UInt uiAbsPartIdx )
1446	{
1447	assert(0);
1448	}
1449
1450	#if HHI_INTER_VIEW_RESIDUAL_PRED
1451	Void
1452	TEncCavlc::codeResPredFlag( TComDataCU* pcCU, UInt uiAbsPartIdx )
1453	{
1454	assert(0);
1455	}
1456	#endif
1457
1458	Void TEncCavlc::codeAlfCtrlFlag( TComDataCU* pcCU, UInt uiAbsPartIdx )
1459	{
1460	if (!m_bAlfCtrl)
1461	{
1462	return;
1463	}
1464
1465	if( pcCU->getDepth(uiAbsPartIdx) > m_uiMaxAlfCtrlDepth && !pcCU->isFirstAbsZorderIdxInDepth(uiAbsPartIdx, m_uiMaxAlfCtrlDepth))
1466	{
1467	return;
1468	}
1469
1470	// get context function is here
1471	UInt uiSymbol = pcCU->getAlfCtrlFlag( uiAbsPartIdx ) ? 1 : 0;
1472
1473	xWriteFlag( uiSymbol );
1474	}
1475
1476	Void TEncCavlc::codeApsExtensionFlag ()
1477	{
1478	WRITE_FLAG(0, "aps_extension_flag");
1479	}
1480
1481	Void TEncCavlc::codeAlfCtrlDepth()
1482	{
1483	if (!m_bAlfCtrl)
1484	{
1485	return;
1486	}
1487
1488	UInt uiDepth = m_uiMaxAlfCtrlDepth;
1489
1490	xWriteUvlc(uiDepth);
1491	}
1492
1493	Void TEncCavlc::codeInterModeFlag( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth, UInt uiEncMode )
1494	{
1495	assert(0);
1496	}
1497
1498	Void TEncCavlc::codeSkipFlag( TComDataCU* pcCU, UInt uiAbsPartIdx )
1499	{
1500	assert(0);
1501	}
1502
1503	#if FORCE_REF_VSP==1
1504	Void TEncCavlc::codeVspFlag( TComDataCU* pcCU, UInt uiAbsPartIdx )
1505	{
1506	assert(0);
1507	}
1508	#endif
1509
1510	Void TEncCavlc::codeSplitFlag ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
1511	{
1512	assert(0);
1513	}
1514
1515	Void TEncCavlc::codeTransformSubdivFlag( UInt uiSymbol, UInt uiCtx )
1516	{
1517	assert(0);
1518	}
1519
1520	Void TEncCavlc::codeQtCbf( TComDataCU* pcCU, UInt uiAbsPartIdx, TextType eType, UInt uiTrDepth )
1521	{
1522	assert(0);
1523	}
1524
1525	Void TEncCavlc::codeQtRootCbf( TComDataCU* pcCU, UInt uiAbsPartIdx )
1526	{
1527	assert(0);
1528	}
1529
1530	#if BURST_IPCM
1531	/** Code I_PCM information.
1532	* \param pcCU pointer to CU
1533	* \param uiAbsPartIdx CU index
1534	* \param numIPCM the number of succesive IPCM blocks with the same size
1535	* \param firstIPCMFlag
1536	* \returns Void
1537	*/
1538	Void TEncCavlc::codeIPCMInfo( TComDataCU* pcCU, UInt uiAbsPartIdx, Int numIPCM, Bool firstIPCMFlag)
1539	{
1540	assert(0);
1541	}
1542	#else
1543	/** Code I_PCM information.
1544	* \param pcCU pointer to CU
1545	* \param uiAbsPartIdx CU index
1546	* \returns Void
1547	*
1548	* If I_PCM flag indicates that the CU is I_PCM, code its PCM alignment bits and codes.
1549	*/
1550	Void TEncCavlc::codeIPCMInfo( TComDataCU* pcCU, UInt uiAbsPartIdx)
1551	{
1552	UInt uiIPCM = (pcCU->getIPCMFlag(uiAbsPartIdx) == true)? 1 : 0;
1553
1554	xWriteFlag(uiIPCM);
1555
1556	if (uiIPCM)
1557	{
1558	xWritePCMAlignZero();
1559
1560	UInt uiMinCoeffSize = pcCU->getPic()->getMinCUWidth()*pcCU->getPic()->getMinCUHeight();
1561	UInt uiLumaOffset = uiMinCoeffSize*uiAbsPartIdx;
1562	UInt uiChromaOffset = uiLumaOffset>>2;
1563
1564	Pel* piPCMSample;
1565	UInt uiWidth;
1566	UInt uiHeight;
1567	UInt uiSampleBits;
1568	UInt uiX, uiY;
1569
1570	piPCMSample = pcCU->getPCMSampleY() + uiLumaOffset;
1571	uiWidth = pcCU->getWidth(uiAbsPartIdx);
1572	uiHeight = pcCU->getHeight(uiAbsPartIdx);
1573	uiSampleBits = pcCU->getSlice()->getSPS()->getPCMBitDepthLuma();
1574
1575	for(uiY = 0; uiY < uiHeight; uiY++)
1576	{
1577	for(uiX = 0; uiX < uiWidth; uiX++)
1578	{
1579	UInt uiSample = piPCMSample[uiX];
1580
1581	xWriteCode(uiSample, uiSampleBits);
1582	}
1583	piPCMSample += uiWidth;
1584	}
1585
1586	piPCMSample = pcCU->getPCMSampleCb() + uiChromaOffset;
1587	uiWidth = pcCU->getWidth(uiAbsPartIdx)/2;
1588	uiHeight = pcCU->getHeight(uiAbsPartIdx)/2;
1589	uiSampleBits = pcCU->getSlice()->getSPS()->getPCMBitDepthChroma();
1590
1591	for(uiY = 0; uiY < uiHeight; uiY++)
1592	{
1593	for(uiX = 0; uiX < uiWidth; uiX++)
1594	{
1595	UInt uiSample = piPCMSample[uiX];
1596
1597	xWriteCode(uiSample, uiSampleBits);
1598	}
1599	piPCMSample += uiWidth;
1600	}
1601
1602	piPCMSample = pcCU->getPCMSampleCr() + uiChromaOffset;
1603	uiWidth = pcCU->getWidth(uiAbsPartIdx)/2;
1604	uiHeight = pcCU->getHeight(uiAbsPartIdx)/2;
1605	uiSampleBits = pcCU->getSlice()->getSPS()->getPCMBitDepthChroma();
1606
1607	for(uiY = 0; uiY < uiHeight; uiY++)
1608	{
1609	for(uiX = 0; uiX < uiWidth; uiX++)
1610	{
1611	UInt uiSample = piPCMSample[uiX];
1612
1613	xWriteCode(uiSample, uiSampleBits);
1614	}
1615	piPCMSample += uiWidth;
1616	}
1617	}
1618	}
1619	#endif
1620
1621	Void TEncCavlc::codeIntraDirLumaAng( TComDataCU* pcCU, UInt uiAbsPartIdx )
1622	{
1623	assert(0);
1624	}
1625
1626	Void TEncCavlc::codeIntraDirChroma( TComDataCU* pcCU, UInt uiAbsPartIdx )
1627	{
1628	assert(0);
1629	}
1630
1631	Void TEncCavlc::codeInterDir( TComDataCU* pcCU, UInt uiAbsPartIdx )
1632	{
1633	assert(0);
1634	}
1635
1636	Void TEncCavlc::codeRefFrmIdx( TComDataCU* pcCU, UInt uiAbsPartIdx, RefPicList eRefList )
1637	{
1638	assert(0);
1639	}
1640
1641	Void TEncCavlc::codeMvd( TComDataCU* pcCU, UInt uiAbsPartIdx, RefPicList eRefList )
1642	{
1643	assert(0);
1644	}
1645
1646	Void TEncCavlc::codeDeltaQP( TComDataCU* pcCU, UInt uiAbsPartIdx )
1647	{
1648	Int iDQp = pcCU->getQP( uiAbsPartIdx ) - pcCU->getRefQP( uiAbsPartIdx );
1649
1650	#if H0736_AVC_STYLE_QP_RANGE
1651	Int qpBdOffsetY = pcCU->getSlice()->getSPS()->getQpBDOffsetY();
1652	iDQp = (iDQp + 78 + qpBdOffsetY + (qpBdOffsetY/2)) % (52 + qpBdOffsetY) - 26 - (qpBdOffsetY/2);
1653	#endif
1654
1655	xWriteSvlc( iDQp );
1656
1657	return;
1658	}
1659
1660	Void TEncCavlc::codeCoeffNxN ( TComDataCU* pcCU, TCoeff* pcCoef, UInt uiAbsPartIdx, UInt uiWidth, UInt uiHeight, UInt uiDepth, TextType eTType )
1661	{
1662	assert(0);
1663	}
1664
1665	Void TEncCavlc::codeAlfFlag( UInt uiCode )
1666	{
1667	xWriteFlag( uiCode );
1668	}
1669
1670	Void TEncCavlc::codeAlfCtrlFlag( UInt uiSymbol )
1671	{
1672	xWriteFlag( uiSymbol );
1673	}
1674
1675	Void TEncCavlc::codeAlfUvlc( UInt uiCode )
1676	{
1677	xWriteUvlc( uiCode );
1678	}
1679
1680	Void TEncCavlc::codeAlfSvlc( Int iCode )
1681	{
1682	xWriteSvlc( iCode );
1683	}
1684	#if LCU_SYNTAX_ALF
1685	/** Code the fixed length code (smaller than one max value) in OSALF
1686	* \param idx: coded value
1687	* \param maxValue: max value
1688	*/
1689	Void TEncCavlc::codeAlfFixedLengthIdx( UInt idx, UInt maxValue)
1690	{
1691	UInt length = 0;
1692	assert(idx<=maxValue);
1693
1694	UInt temp = maxValue;
1695	for(UInt i=0; i<32; i++)
1696	{
1697	if(temp&0x1)
1698	{
1699	length = i+1;
1700	}
1701	temp = (temp >> 1);
1702	}
1703
1704	if(length)
1705	{
1706	xWriteCode( idx, length );
1707	}
1708	}
1709	#endif
1710
1711	Void TEncCavlc::codeSaoFlag( UInt uiCode )
1712	{
1713	xWriteFlag( uiCode );
1714	}
1715
1716	Void TEncCavlc::codeSaoUvlc( UInt uiCode )
1717	{
1718	xWriteUvlc( uiCode );
1719	}
1720
1721	Void TEncCavlc::codeSaoSvlc( Int iCode )
1722	{
1723	xWriteSvlc( iCode );
1724	}
1725	#if SAO_UNIT_INTERLEAVING
1726	/** Code SAO run.
1727	* \param uiCode
1728	* \param maxValue
1729	*/
1730	Void TEncCavlc::codeSaoRun( UInt uiCode, UInt maxValue)
1731	{
1732	UInt uiLength = 0;
1733	if (!maxValue)
1734	{
1735	return;
1736	}
1737	assert(uiCode<=maxValue);
1738
1739	for(UInt i=0; i<32; i++)
1740	{
1741	if(maxValue&0x1)
1742	{
1743	uiLength = i+1;
1744	}
1745	maxValue = (maxValue >> 1);
1746	}
1747	WRITE_CODE( uiCode, uiLength, "sao_run_diff");
1748	}
1749	#endif
1750
1751	Void TEncCavlc::estBit( estBitsSbacStruct* pcEstBitsCabac, Int width, Int height, TextType eTType )
1752	{
1753	// printf("error : no VLC mode support in this version\n");
1754	return;
1755	}
1756
1757	// ====================================================================================================================
1758	// Protected member functions
1759	// ====================================================================================================================
1760
1761	Void TEncCavlc::xWriteCode ( UInt uiCode, UInt uiLength )
1762	{
1763	assert ( uiLength > 0 );
1764	m_pcBitIf->write( uiCode, uiLength );
1765	}
1766
1767	Void TEncCavlc::xWriteUvlc ( UInt uiCode )
1768	{
1769	UInt uiLength = 1;
1770	UInt uiTemp = ++uiCode;
1771
1772	assert ( uiTemp );
1773
1774	while( 1 != uiTemp )
1775	{
1776	uiTemp >>= 1;
1777	uiLength += 2;
1778	}
1779
1780	//m_pcBitIf->write( uiCode, uiLength );
1781	// Take care of cases where uiLength > 32
1782	m_pcBitIf->write( 0, uiLength >> 1);
1783	m_pcBitIf->write( uiCode, (uiLength+1) >> 1);
1784	}
1785
1786	Void TEncCavlc::xWriteSvlc ( Int iCode )
1787	{
1788	UInt uiCode;
1789
1790	uiCode = xConvertToUInt( iCode );
1791	xWriteUvlc( uiCode );
1792	}
1793
1794	Void TEncCavlc::xWriteFlag( UInt uiCode )
1795	{
1796	m_pcBitIf->write( uiCode, 1 );
1797	}
1798
1799	/** Write PCM alignment bits.
1800	* \returns Void
1801	*/
1802	Void TEncCavlc::xWritePCMAlignZero ()
1803	{
1804	m_pcBitIf->writeAlignZero();
1805	}
1806
1807	Void TEncCavlc::xWriteUnaryMaxSymbol( UInt uiSymbol, UInt uiMaxSymbol )
1808	{
1809	if (uiMaxSymbol == 0)
1810	{
1811	return;
1812	}
1813	xWriteFlag( uiSymbol ? 1 : 0 );
1814	if ( uiSymbol == 0 )
1815	{
1816	return;
1817	}
1818
1819	Bool bCodeLast = ( uiMaxSymbol > uiSymbol );
1820
1821	while( --uiSymbol )
1822	{
1823	xWriteFlag( 1 );
1824	}
1825	if( bCodeLast )
1826	{
1827	xWriteFlag( 0 );
1828	}
1829	return;
1830	}
1831
1832	Void TEncCavlc::xWriteExGolombLevel( UInt uiSymbol )
1833	{
1834	if( uiSymbol )
1835	{
1836	xWriteFlag( 1 );
1837	UInt uiCount = 0;
1838	Bool bNoExGo = (uiSymbol < 13);
1839
1840	while( --uiSymbol && ++uiCount < 13 )
1841	{
1842	xWriteFlag( 1 );
1843	}
1844	if( bNoExGo )
1845	{
1846	xWriteFlag( 0 );
1847	}
1848	else
1849	{
1850	xWriteEpExGolomb( uiSymbol, 0 );
1851	}
1852	}
1853	else
1854	{
1855	xWriteFlag( 0 );
1856	}
1857	return;
1858	}
1859
1860	Void TEncCavlc::xWriteEpExGolomb( UInt uiSymbol, UInt uiCount )
1861	{
1862	while( uiSymbol >= (UInt)(1<<uiCount) )
1863	{
1864	xWriteFlag( 1 );
1865	uiSymbol -= 1<<uiCount;
1866	uiCount ++;
1867	}
1868	xWriteFlag( 0 );
1869	while( uiCount-- )
1870	{
1871	xWriteFlag( (uiSymbol>>uiCount) & 1 );
1872	}
1873	return;
1874	}
1875
1876	/** code explicit wp tables
1877	* \param TComSlice* pcSlice
1878	* \returns Void
1879	*/
1880	Void TEncCavlc::xCodePredWeightTable( TComSlice* pcSlice )
1881	{
1882	wpScalingParam *wp;
1883	Bool bChroma = true; // color always present in HEVC ?
1884	Int iNbRef = (pcSlice->getSliceType() == B_SLICE ) ? (2) : (1);
1885	Bool bDenomCoded = false;
1886
1887	UInt uiMode = 0;
1888	if ( (pcSlice->getSliceType()==P_SLICE && pcSlice->getPPS()->getUseWP()) \|\| (pcSlice->getSliceType()==B_SLICE && pcSlice->getPPS()->getWPBiPredIdc()==1 && pcSlice->getRefPicListCombinationFlag()==0 ) )
1889	uiMode = 1; // explicit
1890	else if ( pcSlice->getSliceType()==B_SLICE && pcSlice->getPPS()->getWPBiPredIdc()==2 )
1891	uiMode = 2; // implicit (does not use this mode in this syntax)
1892	if (pcSlice->getSliceType()==B_SLICE && pcSlice->getPPS()->getWPBiPredIdc()==1 && pcSlice->getRefPicListCombinationFlag())
1893	uiMode = 3; // combined explicit
1894	if(uiMode == 1)
1895	{
1896	for ( Int iNumRef=0 ; iNumRef<iNbRef ; iNumRef++ )
1897	{
1898	RefPicList eRefPicList = ( iNumRef ? REF_PIC_LIST_1 : REF_PIC_LIST_0 );
1899	for ( Int iRefIdx=0 ; iRefIdx<pcSlice->getNumRefIdx(eRefPicList) ; iRefIdx++ )
1900	{
1901	pcSlice->getWpScaling(eRefPicList, iRefIdx, wp);
1902	if ( !bDenomCoded )
1903	{
1904	Int iDeltaDenom;
1905	WRITE_UVLC( wp[0].uiLog2WeightDenom, "luma_log2_weight_denom" ); // ue(v): luma_log2_weight_denom
1906
1907	if( bChroma )
1908	{
1909	iDeltaDenom = (wp[1].uiLog2WeightDenom - wp[0].uiLog2WeightDenom);
1910	WRITE_SVLC( iDeltaDenom, "delta_chroma_log2_weight_denom" ); // se(v): delta_chroma_log2_weight_denom
1911	}
1912	bDenomCoded = true;
1913	}
1914
1915	WRITE_FLAG( wp[0].bPresentFlag, "luma_weight_lX_flag" ); // u(1): luma_weight_lX_flag
1916
1917	if ( wp[0].bPresentFlag )
1918	{
1919	Int iDeltaWeight = (wp[0].iWeight - (1<<wp[0].uiLog2WeightDenom));
1920	WRITE_SVLC( iDeltaWeight, "delta_luma_weight_lX" ); // se(v): delta_luma_weight_lX
1921	WRITE_SVLC( wp[0].iOffset, "luma_offset_lX" ); // se(v): luma_offset_lX
1922	}
1923
1924	if ( bChroma )
1925	{
1926	WRITE_FLAG( wp[1].bPresentFlag, "chroma_weight_lX_flag" ); // u(1): chroma_weight_lX_flag
1927
1928	if ( wp[1].bPresentFlag )
1929	{
1930	for ( Int j=1 ; j<3 ; j++ )
1931	{
1932	Int iDeltaWeight = (wp[j].iWeight - (1<<wp[1].uiLog2WeightDenom));
1933	WRITE_SVLC( iDeltaWeight, "delta_chroma_weight_lX" ); // se(v): delta_chroma_weight_lX
1934
1935	Int iDeltaChroma = (wp[j].iOffset + ( ( (g_uiIBDI_MAX>>1)*wp[j].iWeight)>>(wp[j].uiLog2WeightDenom) ) - (g_uiIBDI_MAX>>1));
1936	WRITE_SVLC( iDeltaChroma, "delta_chroma_offset_lX" ); // se(v): delta_chroma_offset_lX
1937	}
1938	}
1939	}
1940	}
1941	}
1942	}
1943	else if (uiMode == 3)
1944	{
1945	for ( Int iRefIdx=0 ; iRefIdx<pcSlice->getNumRefIdx(REF_PIC_LIST_C) ; iRefIdx++ )
1946	{
1947	RefPicList eRefPicList = (RefPicList)pcSlice->getListIdFromIdxOfLC(iRefIdx);
1948	Int iCombRefIdx = pcSlice->getRefIdxFromIdxOfLC(iRefIdx);
1949
1950	pcSlice->getWpScaling(eRefPicList, iCombRefIdx, wp);
1951	if ( !bDenomCoded )
1952	{
1953	Int iDeltaDenom;
1954	WRITE_UVLC( wp[0].uiLog2WeightDenom, "luma_log2_weight_denom" ); // ue(v): luma_log2_weight_denom
1955
1956	if( bChroma )
1957	{
1958	iDeltaDenom = (wp[1].uiLog2WeightDenom - wp[0].uiLog2WeightDenom);
1959	WRITE_SVLC( iDeltaDenom, "delta_chroma_log2_weight_denom" ); // se(v): delta_chroma_log2_weight_denom
1960	}
1961	bDenomCoded = true;
1962	}
1963
1964	WRITE_FLAG( wp[0].bPresentFlag, "luma_weight_lc_flag" ); // u(1): luma_weight_lc_flag
1965
1966	if ( wp[0].bPresentFlag )
1967	{
1968	Int iDeltaWeight = (wp[0].iWeight - (1<<wp[0].uiLog2WeightDenom));
1969	WRITE_SVLC( iDeltaWeight, "delta_luma_weight_lc" ); // se(v): delta_luma_weight_lc
1970	WRITE_SVLC( wp[0].iOffset, "luma_offset_lc" ); // se(v): luma_offset_lc
1971	}
1972	if ( bChroma )
1973	{
1974	WRITE_FLAG( wp[1].bPresentFlag, "chroma_weight_lc_flag" ); // u(1): luma_weight_lc_flag
1975
1976	if ( wp[1].bPresentFlag )
1977	{
1978	for ( Int j=1 ; j<3 ; j++ )
1979	{
1980	Int iDeltaWeight = (wp[j].iWeight - (1<<wp[1].uiLog2WeightDenom));
1981	WRITE_SVLC( iDeltaWeight, "delta_chroma_weight_lc" ); // se(v): delta_chroma_weight_lc
1982
1983	Int iDeltaChroma = (wp[j].iOffset + ( ( (g_uiIBDI_MAX>>1)*wp[j].iWeight)>>(wp[j].uiLog2WeightDenom) ) - (g_uiIBDI_MAX>>1));
1984	WRITE_SVLC( iDeltaChroma, "delta_chroma_offset_lc" ); // se(v): delta_chroma_offset_lc
1985	}
1986	}
1987	}
1988	}
1989	}
1990	}
1991
1992	/** code quantization matrix
1993	* \param scalingList quantization matrix information
1994	*/
1995	Void TEncCavlc::codeScalingList( TComScalingList* scalingList )
1996	{
1997	UInt listId,sizeId;
1998	Bool scalingListPredModeFlag;
1999
2000	#if SCALING_LIST_OUTPUT_RESULT
2001	Int startBit;
2002	Int startTotalBit;
2003	startBit = m_pcBitIf->getNumberOfWrittenBits();
2004	startTotalBit = m_pcBitIf->getNumberOfWrittenBits();
2005	#endif
2006
2007	WRITE_FLAG( scalingList->getScalingListPresentFlag (), "scaling_list_present_flag" );
2008
2009	if(scalingList->getScalingListPresentFlag () == false)
2010	{
2011	#if SCALING_LIST_OUTPUT_RESULT
2012	printf("Header Bit %d\n",m_pcBitIf->getNumberOfWrittenBits()-startBit);
2013	#endif
2014	//for each size
2015	for(sizeId = 0; sizeId < SCALING_LIST_SIZE_NUM; sizeId++)
2016	{
2017	for(listId = 0; listId < g_scalingListNum[sizeId]; listId++)
2018	{
2019	#if SCALING_LIST_OUTPUT_RESULT
2020	startBit = m_pcBitIf->getNumberOfWrittenBits();
2021	#endif
2022	scalingListPredModeFlag = scalingList->checkPredMode( sizeId, listId );
2023	WRITE_FLAG( scalingListPredModeFlag, "scaling_list_pred_mode_flag" );
2024	if(!scalingListPredModeFlag)// Copy Mode
2025	{
2026	WRITE_UVLC( (Int)listId - (Int)scalingList->getRefMatrixId (sizeId,listId) - 1, "scaling_list_pred_matrix_id_delta");
2027	}
2028	else// DPCM Mode
2029	{
2030	xCodeScalingList(scalingList, sizeId, listId);
2031	}
2032	#if SCALING_LIST_OUTPUT_RESULT
2033	printf("Matrix [%d][%d] Bit %d\n",sizeId,listId,m_pcBitIf->getNumberOfWrittenBits() - startBit);
2034	#endif
2035	}
2036	}
2037	}
2038	#if SCALING_LIST_OUTPUT_RESULT
2039	else
2040	{
2041	printf("Header Bit %d\n",m_pcBitIf->getNumberOfWrittenBits()-startTotalBit);
2042	}
2043	printf("Total Bit %d\n",m_pcBitIf->getNumberOfWrittenBits()-startTotalBit);
2044	#endif
2045	return;
2046	}
2047	/** code DPCM
2048	* \param scalingList quantization matrix information
2049	* \param sizeIdc size index
2050	* \param listIdc list index
2051	*/
2052	Void TEncCavlc::xCodeScalingList(TComScalingList* scalingList, UInt sizeId, UInt listId)
2053	{
2054	#if SCALING_LIST
2055	Int coefNum = min(MAX_MATRIX_COEF_NUM,(Int)g_scalingListSize[sizeId]);
2056	UInt* scan = g_auiFrameScanXY [ (sizeId == 0)? 1 : 2];
2057	#else
2058	Int coefNum = (Int)g_scalingListSize[sizeId];
2059	UInt* scan = g_auiFrameScanXY [ sizeId + 1];
2060	#endif
2061	Int nextCoef = SCALING_LIST_START_VALUE;
2062	Int data;
2063	Int *src = scalingList->getScalingListAddress(sizeId, listId);
2064	#if SCALING_LIST
2065	if(sizeId > SCALING_LIST_8x8 && scalingList->getUseDefaultScalingMatrixFlag(sizeId,listId))
2066	{
2067	WRITE_SVLC( -8, "scaling_list_dc_coef_minus8");
2068	}
2069	else if(sizeId < SCALING_LIST_16x16 && scalingList->getUseDefaultScalingMatrixFlag(sizeId,listId))
2070	{
2071	WRITE_SVLC( -8, "scaling_list_delta_coef");
2072	}
2073	else
2074	{
2075	if( sizeId > SCALING_LIST_8x8 )
2076	{
2077	WRITE_SVLC( scalingList->getScalingListDC(sizeId,listId) - 8, "scaling_list_dc_coef_minus8");
2078	}
2079	for(Int i=0;i<coefNum;i++)
2080	{
2081	data = src[scan[i]] - nextCoef;
2082	nextCoef = src[scan[i]];
2083	if(data > 127)
2084	{
2085	data = data - 256;
2086	}
2087	if(data < -128)
2088	{
2089	data = data + 256;
2090	}
2091
2092	WRITE_SVLC( data, "scaling_list_delta_coef");
2093	}
2094	}
2095	#else
2096	for(Int i=0;i<coefNum;i++)
2097	{
2098	data = src[scan[i]] - nextCoef;
2099	nextCoef = src[scan[i]];
2100	if(data > 127)
2101	{
2102	data = data - 256;
2103	}
2104	if(data < -128)
2105	{
2106	data = data + 256;
2107	}
2108
2109	WRITE_SVLC( data, "delta_coef");
2110	}
2111	#endif
2112	}
2113	Bool TComScalingList::checkPredMode(UInt sizeId, UInt listId)
2114	{
2115	for(Int predListIdx = (Int)listId -1 ; predListIdx >= 0; predListIdx--)
2116	{
2117	#if SCALING_LIST
2118	if( !memcmp(getScalingListAddress(sizeId,listId),getScalingListAddress(sizeId, predListIdx),sizeof(Int)*min(MAX_MATRIX_COEF_NUM,(Int)g_scalingListSize[sizeId])) // check value of matrix
2119	&& ((sizeId < SCALING_LIST_16x16) \|\| (getScalingListDC(sizeId,listId) == getScalingListDC(sizeId,predListIdx)))) // check DC value
2120	#else
2121	if( !memcmp(getScalingListAddress(sizeId,listId),getScalingListAddress(sizeId, predListIdx),sizeof(Int)*(Int)g_scalingListSize[sizeId])) // check value of matrix
2122	#endif
2123	{
2124	setRefMatrixId(sizeId, listId, predListIdx);
2125	return false;
2126	}
2127	}
2128	return true;
2129	}
2130	//! \}

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

JCT-3V 3D-HEVC

Context navigation

source: 3DVCSoftware/branches/HTM-4.0.1-VSP-dev0/source/Lib/TLibEncoder/TEncCavlc.cpp @ 193

Download in other formats: