Context navigation

TEncCavlc.cpp

Visit:

Last change on this file was 100, checked in by tech, 12 years ago

Adopted modifications:

disparity vector generation (A0097)
inter-view motion prediction modification (A0049)
simplification of disparity vector derivation (A0126)
region boundary chain coding (A0070)
residual skip intra (A0087)
VSO modification (A0033/A0093)

+ Clean ups + Bug fixes

Update of cfg files (A0033 modification 2)

Property svn:eol-style set to native

File size: 66.2 KB

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

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

JCT-3V 3D-HEVC

Context navigation

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

Download in other formats: