Context navigation

source: SHVCSoftware/branches/SHM-dev/source/Lib/TLibDecoder/SEIread.cpp @ 1267

Visit:

Last change on this file since 1267 was 1259, checked in by seregin, 9 years ago
port rev 4256
Property svn:eol-style set to `native`
File size: 86.7 KB

Line
1	/* The copyright in this software is being made available under the BSD
2	* License, included below. This software may be subject to other third party
3	* and contributor rights, including patent rights, and no such rights are
4	* granted under this license.
5	*
6	* Copyright (c) 2010-2015, 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	/**
35	\file SEIread.cpp
36	\brief reading funtionality for SEI messages
37	*/
38
39	#include "TLibCommon/CommonDef.h"
40	#include "TLibCommon/TComBitStream.h"
41	#include "TLibCommon/SEI.h"
42	#include "TLibCommon/TComSlice.h"
43	#include "SyntaxElementParser.h"
44	#include "SEIread.h"
45	#include "TLibCommon/TComPicYuv.h"
46	#include <iomanip>
47
48
49	//! \ingroup TLibDecoder
50	//! \{
51
52
53	#if ENC_DEC_TRACE
54	Void xTraceSEIHeader()
55	{
56	fprintf( g_hTrace, "=========== SEI message ===========\n");
57	}
58
59	Void xTraceSEIMessageType(SEI::PayloadType payloadType)
60	{
61	fprintf( g_hTrace, "=========== %s SEI message ===========\n", SEI::getSEIMessageString(payloadType));
62	}
63	#endif
64
65	Void SEIReader::sei_read_code(std::ostream pOS, UInt uiLength, UInt& ruiCode, const Char pSymbolName)
66	{
67	READ_CODE(uiLength, ruiCode, pSymbolName);
68	if (pOS)
69	{
70	(*pOS) << " " << std::setw(55) << pSymbolName << ": " << ruiCode << "\n";
71	}
72	}
73
74	Void SEIReader::sei_read_uvlc(std::ostream pOS, UInt& ruiCode, const Char pSymbolName)
75	{
76	READ_UVLC(ruiCode, pSymbolName);
77	if (pOS)
78	{
79	(*pOS) << " " << std::setw(55) << pSymbolName << ": " << ruiCode << "\n";
80	}
81	}
82
83	Void SEIReader::sei_read_svlc(std::ostream pOS, Int& ruiCode, const Char pSymbolName)
84	{
85	READ_SVLC(ruiCode, pSymbolName);
86	if (pOS)
87	{
88	(*pOS) << " " << std::setw(55) << pSymbolName << ": " << ruiCode << "\n";
89	}
90	}
91
92	Void SEIReader::sei_read_flag(std::ostream pOS, UInt& ruiCode, const Char pSymbolName)
93	{
94	READ_FLAG(ruiCode, pSymbolName);
95	if (pOS)
96	{
97	(*pOS) << " " << std::setw(55) << pSymbolName << ": " << (ruiCode?1:0) << "\n";
98	}
99	}
100
101	static inline Void output_sei_message_header(SEI &sei, std::ostream *pDecodedMessageOutputStream, UInt payloadSize)
102	{
103	if (pDecodedMessageOutputStream)
104	{
105	std::string seiMessageHdr(SEI::getSEIMessageString(sei.payloadType())); seiMessageHdr+=" SEI message";
106	(*pDecodedMessageOutputStream) << std::setfill('-') << std::setw(seiMessageHdr.size()) << "-" << std::setfill(' ') << "\n" << seiMessageHdr << "\n";
107	}
108	}
109
110	#undef READ_CODE
111	#undef READ_SVLC
112	#undef READ_UVLC
113	#undef READ_FLAG
114
115
116	/**
117	* unmarshal a single SEI message from bitstream bs
118	*/
119	#if LAYERS_NOT_PRESENT_SEI
120	Void SEIReader::parseSEImessage(TComInputBitstream* bs, SEIMessages& seis, const NalUnitType nalUnitType, const TComVPS vps, const TComSPS sps, std::ostream *pDecodedMessageOutputStream)
121	#else
122	Void SEIReader::parseSEImessage(TComInputBitstream* bs, SEIMessages& seis, const NalUnitType nalUnitType, const TComSPS sps, std::ostream pDecodedMessageOutputStream)
123	#endif
124	{
125	setBitstream(bs);
126
127	assert(!m_pcBitstream->getNumBitsUntilByteAligned());
128	do
129	{
130	#if LAYERS_NOT_PRESENT_SEI
131	xReadSEImessage(seis, nalUnitType, vps, sps, pDecodedMessageOutputStream);
132	#else
133	xReadSEImessage(seis, nalUnitType, sps, pDecodedMessageOutputStream);
134	#endif
135	/* SEI messages are an integer number of bytes, something has failed
136	* in the parsing if bitstream not byte-aligned */
137	assert(!m_pcBitstream->getNumBitsUntilByteAligned());
138	}
139	while (m_pcBitstream->getNumBitsLeft() > 8);
140
141	UInt rbspTrailingBits;
142	sei_read_code(NULL, 8, rbspTrailingBits, "rbsp_trailing_bits");
143	assert(rbspTrailingBits == 0x80);
144	}
145
146	#if O0164_MULTI_LAYER_HRD
147	#if LAYERS_NOT_PRESENT_SEI
148	Void SEIReader::xReadSEImessage(SEIMessages& seis, const NalUnitType nalUnitType, const TComVPS vps, const TComSPS sps, std::ostream pDecodedMessageOutputStream, const SEIScalableNesting nestingSei, const SEIBspNesting *bspNestingSei)
149	#else
150	Void SEIReader::xReadSEImessage(SEIMessages& seis, const NalUnitType nalUnitType, const TComSPS sps, std::ostream pDecodedMessageOutputStream, const SEIScalableNesting *nestingSei)
151	#endif
152	#else
153	#if LAYERS_NOT_PRESENT_SEI
154	Void SEIReader::xReadSEImessage(SEIMessages& seis, const NalUnitType nalUnitType, const TComVPS vps, const TComSPS sps, std::ostream *pDecodedMessageOutputStream)
155	#else
156	Void SEIReader::xReadSEImessage(SEIMessages& seis, const NalUnitType nalUnitType, const TComSPS sps, std::ostream pDecodedMessageOutputStream)
157	#endif
158	#endif
159	{
160	#if ENC_DEC_TRACE
161	xTraceSEIHeader();
162	#endif
163	Int payloadType = 0;
164	UInt val = 0;
165
166	do
167	{
168	sei_read_code(NULL, 8, val, "payload_type");
169	payloadType += val;
170	} while (val==0xFF);
171
172	UInt payloadSize = 0;
173	do
174	{
175	sei_read_code(NULL, 8, val, "payload_size");
176	payloadSize += val;
177	} while (val==0xFF);
178
179	#if ENC_DEC_TRACE
180	xTraceSEIMessageType((SEI::PayloadType)payloadType);
181	#endif
182
183	/* extract the payload for this single SEI message.
184	* This allows greater safety in erroneous parsing of an SEI message
185	* from affecting subsequent messages.
186	* After parsing the payload, bs needs to be restored as the primary
187	* bitstream.
188	*/
189	TComInputBitstream *bs = getBitstream();
190	setBitstream(bs->extractSubstream(payloadSize * 8));
191
192	SEI *sei = NULL;
193
194	if(nalUnitType == NAL_UNIT_PREFIX_SEI)
195	{
196	switch (payloadType)
197	{
198	case SEI::USER_DATA_UNREGISTERED:
199	sei = new SEIuserDataUnregistered;
200	xParseSEIuserDataUnregistered((SEIuserDataUnregistered&) *sei, payloadSize, pDecodedMessageOutputStream);
201	break;
202	case SEI::ACTIVE_PARAMETER_SETS:
203	sei = new SEIActiveParameterSets;
204	xParseSEIActiveParameterSets((SEIActiveParameterSets&) *sei, payloadSize, pDecodedMessageOutputStream);
205	break;
206	case SEI::DECODING_UNIT_INFO:
207	if (!sps)
208	{
209	printf ("Warning: Found Decoding unit SEI message, but no active SPS is available. Ignoring.");
210	}
211	else
212	{
213	sei = new SEIDecodingUnitInfo;
214	#if SVC_EXTENSION
215	xParseSEIDecodingUnitInfo((SEIDecodingUnitInfo&) *sei, payloadSize, sps, nestingSei, bspNestingSei, vps, pDecodedMessageOutputStream);
216	#else
217	xParseSEIDecodingUnitInfo((SEIDecodingUnitInfo&) *sei, payloadSize, sps, pDecodedMessageOutputStream);
218	#endif
219	}
220	break;
221	case SEI::BUFFERING_PERIOD:
222	if (!sps)
223	{
224	printf ("Warning: Found Buffering period SEI message, but no active SPS is available. Ignoring.");
225	}
226	else
227	{
228	sei = new SEIBufferingPeriod;
229	#if SVC_EXTENSION
230	xParseSEIBufferingPeriod((SEIBufferingPeriod&) *sei, payloadSize, sps, nestingSei, bspNestingSei, vps, pDecodedMessageOutputStream);
231	#else
232	xParseSEIBufferingPeriod((SEIBufferingPeriod&) *sei, payloadSize, sps, pDecodedMessageOutputStream);
233	#endif
234	}
235	break;
236	case SEI::PICTURE_TIMING:
237	if (!sps)
238	{
239	printf ("Warning: Found Picture timing SEI message, but no active SPS is available. Ignoring.");
240	}
241	else
242	{
243	sei = new SEIPictureTiming;
244	#if SVC_EXTENSION
245	xParseSEIPictureTiming((SEIPictureTiming&)*sei, payloadSize, sps, nestingSei, bspNestingSei, vps, pDecodedMessageOutputStream);
246	#else
247	xParseSEIPictureTiming((SEIPictureTiming&)*sei, payloadSize, sps, pDecodedMessageOutputStream);
248	#endif
249	}
250	break;
251	case SEI::RECOVERY_POINT:
252	sei = new SEIRecoveryPoint;
253	xParseSEIRecoveryPoint((SEIRecoveryPoint&) *sei, payloadSize, pDecodedMessageOutputStream);
254	break;
255	case SEI::FRAME_PACKING:
256	sei = new SEIFramePacking;
257	xParseSEIFramePacking((SEIFramePacking&) *sei, payloadSize, pDecodedMessageOutputStream);
258	break;
259	case SEI::SEGM_RECT_FRAME_PACKING:
260	sei = new SEISegmentedRectFramePacking;
261	xParseSEISegmentedRectFramePacking((SEISegmentedRectFramePacking&) *sei, payloadSize, pDecodedMessageOutputStream);
262	break;
263	case SEI::DISPLAY_ORIENTATION:
264	sei = new SEIDisplayOrientation;
265	xParseSEIDisplayOrientation((SEIDisplayOrientation&) *sei, payloadSize, pDecodedMessageOutputStream);
266	break;
267	case SEI::TEMPORAL_LEVEL0_INDEX:
268	sei = new SEITemporalLevel0Index;
269	xParseSEITemporalLevel0Index((SEITemporalLevel0Index&) *sei, payloadSize, pDecodedMessageOutputStream);
270	break;
271	case SEI::REGION_REFRESH_INFO:
272	sei = new SEIGradualDecodingRefreshInfo;
273	xParseSEIRegionRefreshInfo((SEIGradualDecodingRefreshInfo&) *sei, payloadSize, pDecodedMessageOutputStream);
274	break;
275	case SEI::NO_DISPLAY:
276	sei = new SEINoDisplay;
277	xParseSEINoDisplay((SEINoDisplay&) *sei, payloadSize, pDecodedMessageOutputStream);
278	break;
279	case SEI::TONE_MAPPING_INFO:
280	sei = new SEIToneMappingInfo;
281	xParseSEIToneMappingInfo((SEIToneMappingInfo&) *sei, payloadSize, pDecodedMessageOutputStream);
282	break;
283	case SEI::SOP_DESCRIPTION:
284	sei = new SEISOPDescription;
285	xParseSEISOPDescription((SEISOPDescription&) *sei, payloadSize, pDecodedMessageOutputStream);
286	break;
287	case SEI::SCALABLE_NESTING:
288	sei = new SEIScalableNesting;
289	#if LAYERS_NOT_PRESENT_SEI
290	xParseSEIScalableNesting((SEIScalableNesting&) *sei, nalUnitType, payloadSize, vps, sps, pDecodedMessageOutputStream);
291	#else
292	xParseSEIScalableNesting((SEIScalableNesting&) *sei, nalUnitType, payloadSize, sps, pDecodedMessageOutputStream);
293	#endif
294	break;
295	case SEI::TEMP_MOTION_CONSTRAINED_TILE_SETS:
296	sei = new SEITempMotionConstrainedTileSets;
297	xParseSEITempMotionConstraintsTileSets((SEITempMotionConstrainedTileSets&) *sei, payloadSize, pDecodedMessageOutputStream);
298	break;
299	case SEI::TIME_CODE:
300	sei = new SEITimeCode;
301	xParseSEITimeCode((SEITimeCode&) *sei, payloadSize, pDecodedMessageOutputStream);
302	break;
303	case SEI::CHROMA_SAMPLING_FILTER_HINT:
304	sei = new SEIChromaSamplingFilterHint;
305	xParseSEIChromaSamplingFilterHint((SEIChromaSamplingFilterHint&) sei, payloadSize/, sps*/, pDecodedMessageOutputStream);
306	//}
307	break;
308	case SEI::KNEE_FUNCTION_INFO:
309	sei = new SEIKneeFunctionInfo;
310	xParseSEIKneeFunctionInfo((SEIKneeFunctionInfo&) *sei, payloadSize, pDecodedMessageOutputStream);
311	break;
312	case SEI::MASTERING_DISPLAY_COLOUR_VOLUME:
313	sei = new SEIMasteringDisplayColourVolume;
314	xParseSEIMasteringDisplayColourVolume((SEIMasteringDisplayColourVolume&) *sei, payloadSize, pDecodedMessageOutputStream);
315	break;
316	#if Q0074_COLOUR_REMAPPING_SEI
317	case SEI::COLOUR_REMAPPING_INFO:
318	sei = new SEIColourRemappingInfo;
319	xParseSEIColourRemappingInfo((SEIColourRemappingInfo&) *sei, payloadSize, pDecodedMessageOutputStream);
320	break;
321	#endif
322	#if SVC_EXTENSION
323	#if LAYERS_NOT_PRESENT_SEI
324	case SEI::LAYERS_NOT_PRESENT:
325	if (!vps)
326	{
327	printf ("Warning: Found Layers not present SEI message, but no active VPS is available. Ignoring.");
328	}
329	else
330	{
331	sei = new SEILayersNotPresent;
332	xParseSEILayersNotPresent((SEILayersNotPresent&) *sei, payloadSize, vps, pDecodedMessageOutputStream);
333	}
334	break;
335	#endif
336	#if N0383_IL_CONSTRAINED_TILE_SETS_SEI
337	case SEI::INTER_LAYER_CONSTRAINED_TILE_SETS:
338	sei = new SEIInterLayerConstrainedTileSets;
339	xParseSEIInterLayerConstrainedTileSets((SEIInterLayerConstrainedTileSets&) *sei, payloadSize, pDecodedMessageOutputStream);
340	break;
341	#endif
342	#if SUB_BITSTREAM_PROPERTY_SEI
343	case SEI::SUB_BITSTREAM_PROPERTY:
344	sei = new SEISubBitstreamProperty;
345	xParseSEISubBitstreamProperty((SEISubBitstreamProperty&) *sei, vps, pDecodedMessageOutputStream);
346	break;
347	#endif
348	#if O0164_MULTI_LAYER_HRD
349	case SEI::BSP_NESTING:
350	sei = new SEIBspNesting;
351	#if LAYERS_NOT_PRESENT_SEI
352	xParseSEIBspNesting((SEIBspNesting&) sei, nalUnitType, vps, sps, nestingSei, pDecodedMessageOutputStream);
353	#else
354	xParseSEIBspNesting((SEIBspNesting&) sei, nalUnitType, sps, nestingSei, pDecodedMessageOutputStream);
355	#endif
356	break;
357	case SEI::BSP_INITIAL_ARRIVAL_TIME:
358	sei = new SEIBspInitialArrivalTime;
359	xParseSEIBspInitialArrivalTime((SEIBspInitialArrivalTime&) sei, vps, sps, nestingSei, *bspNestingSei, pDecodedMessageOutputStream);
360	break;
361	#endif
362	#if Q0189_TMVP_CONSTRAINTS
363	case SEI::TMVP_CONSTRAINTS:
364	sei = new SEITMVPConstrains;
365	xParseSEITMVPConstraints((SEITMVPConstrains&) *sei, payloadSize, pDecodedMessageOutputStream);
366	break;
367	#endif
368	#if Q0247_FRAME_FIELD_INFO
369	case SEI::FRAME_FIELD_INFO:
370	sei = new SEIFrameFieldInfo;
371	xParseSEIFrameFieldInfo ((SEIFrameFieldInfo&) *sei, payloadSize, pDecodedMessageOutputStream);
372	break;
373	#endif
374	#if P0123_ALPHA_CHANNEL_SEI
375	case SEI::ALPHA_CHANNEL_INFO:
376	sei = new SEIAlphaChannelInfo;
377	xParseSEIAlphaChannelInfo((SEIAlphaChannelInfo &) *sei, payloadSize, pDecodedMessageOutputStream);
378	break;
379	#endif
380	#if Q0096_OVERLAY_SEI
381	case SEI::OVERLAY_INFO:
382	sei = new SEIOverlayInfo;
383	xParseSEIOverlayInfo((SEIOverlayInfo&) *sei, payloadSize, pDecodedMessageOutputStream);
384	break;
385	#endif
386	#endif //SVC_EXTENSION
387	default:
388	for (UInt i = 0; i < payloadSize; i++)
389	{
390	UInt seiByte;
391	sei_read_code (NULL, 8, seiByte, "unknown prefix SEI payload byte");
392	}
393	printf ("Unknown prefix SEI message (payloadType = %d) was found!\n", payloadType);
394	if (pDecodedMessageOutputStream)
395	{
396	(*pDecodedMessageOutputStream) << "Unknown prefix SEI message (payloadType = " << payloadType << ") was found!\n";
397	}
398	break;
399	}
400	}
401	else
402	{
403	switch (payloadType)
404	{
405	case SEI::USER_DATA_UNREGISTERED:
406	sei = new SEIuserDataUnregistered;
407	xParseSEIuserDataUnregistered((SEIuserDataUnregistered&) *sei, payloadSize, pDecodedMessageOutputStream);
408	break;
409	case SEI::DECODED_PICTURE_HASH:
410	sei = new SEIDecodedPictureHash;
411	xParseSEIDecodedPictureHash((SEIDecodedPictureHash&) *sei, payloadSize, pDecodedMessageOutputStream);
412	break;
413	default:
414	for (UInt i = 0; i < payloadSize; i++)
415	{
416	UInt seiByte;
417	sei_read_code( NULL, 8, seiByte, "unknown suffix SEI payload byte");
418	}
419	printf ("Unknown suffix SEI message (payloadType = %d) was found!\n", payloadType);
420	if (pDecodedMessageOutputStream)
421	{
422	(*pDecodedMessageOutputStream) << "Unknown suffix SEI message (payloadType = " << payloadType << ") was found!\n";
423	}
424	break;
425	}
426	}
427
428	if (sei != NULL)
429	{
430	seis.push_back(sei);
431	}
432
433	/* By definition the underlying bitstream terminates in a byte-aligned manner.
434	* 1. Extract all bar the last MIN(bitsremaining,nine) bits as reserved_payload_extension_data
435	* 2. Examine the final 8 bits to determine the payload_bit_equal_to_one marker
436	* 3. Extract the remainingreserved_payload_extension_data bits.
437	*
438	* If there are fewer than 9 bits available, extract them.
439	*/
440	Int payloadBitsRemaining = getBitstream()->getNumBitsLeft();
441	if (payloadBitsRemaining) /* more_data_in_payload() */
442	{
443	for (; payloadBitsRemaining > 9; payloadBitsRemaining--)
444	{
445	UInt reservedPayloadExtensionData;
446	sei_read_code ( pDecodedMessageOutputStream, 1, reservedPayloadExtensionData, "reserved_payload_extension_data");
447	}
448
449	/* 2 */
450	Int finalBits = getBitstream()->peekBits(payloadBitsRemaining);
451	Int finalPayloadBits = 0;
452	for (Int mask = 0xff; finalBits & (mask >> finalPayloadBits); finalPayloadBits++)
453	{
454	continue;
455	}
456
457	/* 3 */
458	for (; payloadBitsRemaining > 9 - finalPayloadBits; payloadBitsRemaining--)
459	{
460	UInt reservedPayloadExtensionData;
461	sei_read_flag ( 0, reservedPayloadExtensionData, "reserved_payload_extension_data");
462	}
463
464	UInt dummy;
465	sei_read_flag( 0, dummy, "payload_bit_equal_to_one"); payloadBitsRemaining--;
466	while (payloadBitsRemaining)
467	{
468	sei_read_flag( 0, dummy, "payload_bit_equal_to_zero"); payloadBitsRemaining--;
469	}
470	}
471
472	/* restore primary bitstream for sei_message */
473	getBitstream()->deleteFifo();
474	delete getBitstream();
475	setBitstream(bs);
476	}
477
478	/**
479	* parse bitstream bs and unpack a user_data_unregistered SEI message
480	* of payloasSize bytes into sei.
481	*/
482
483	Void SEIReader::xParseSEIuserDataUnregistered(SEIuserDataUnregistered &sei, UInt payloadSize, std::ostream *pDecodedMessageOutputStream)
484	{
485	assert(payloadSize >= ISO_IEC_11578_LEN);
486	UInt val;
487	output_sei_message_header(sei, pDecodedMessageOutputStream, payloadSize);
488
489	for (UInt i = 0; i < ISO_IEC_11578_LEN; i++)
490	{
491	sei_read_code( pDecodedMessageOutputStream, 8, val, "uuid_iso_iec_11578");
492	sei.uuid_iso_iec_11578[i] = val;
493	}
494
495	sei.userDataLength = payloadSize - ISO_IEC_11578_LEN;
496	if (!sei.userDataLength)
497	{
498	sei.userData = 0;
499	return;
500	}
501
502	sei.userData = new UChar[sei.userDataLength];
503	for (UInt i = 0; i < sei.userDataLength; i++)
504	{
505	sei_read_code( NULL, 8, val, "user_data_payload_byte" );
506	sei.userData[i] = val;
507	}
508	if (pDecodedMessageOutputStream)
509	{
510	(*pDecodedMessageOutputStream) << " User data payload size: " << sei.userDataLength << "\n";
511	}
512	}
513
514	/**
515	* parse bitstream bs and unpack a decoded picture hash SEI message
516	* of payloadSize bytes into sei.
517	*/
518	Void SEIReader::xParseSEIDecodedPictureHash(SEIDecodedPictureHash& sei, UInt payloadSize, std::ostream *pDecodedMessageOutputStream)
519	{
520	UInt bytesRead = 0;
521	output_sei_message_header(sei, pDecodedMessageOutputStream, payloadSize);
522
523	UInt val;
524	sei_read_code( pDecodedMessageOutputStream, 8, val, "hash_type");
525	sei.method = static_cast<SEIDecodedPictureHash::Method>(val); bytesRead++;
526
527	const Char *traceString="\0";
528	switch (sei.method)
529	{
530	case SEIDecodedPictureHash::MD5: traceString="picture_md5"; break;
531	case SEIDecodedPictureHash::CRC: traceString="picture_crc"; break;
532	case SEIDecodedPictureHash::CHECKSUM: traceString="picture_checksum"; break;
533	default: assert(false); break;
534	}
535
536	if (pDecodedMessageOutputStream)
537	{
538	(*pDecodedMessageOutputStream) << " " << std::setw(55) << traceString << ": " << std::hex << std::setfill('0');
539	}
540
541	sei.m_digest.hash.clear();
542	for(;bytesRead < payloadSize; bytesRead++)
543	{
544	sei_read_code( NULL, 8, val, traceString);
545	sei.m_digest.hash.push_back((UChar)val);
546	if (pDecodedMessageOutputStream)
547	{
548	(*pDecodedMessageOutputStream) << std::setw(2) << val;
549	}
550	}
551
552	if (pDecodedMessageOutputStream)
553	{
554	(*pDecodedMessageOutputStream) << std::dec << std::setfill(' ') << "\n";
555	}
556	}
557
558	Void SEIReader::xParseSEIActiveParameterSets(SEIActiveParameterSets& sei, UInt payloadSize, std::ostream *pDecodedMessageOutputStream)
559	{
560	UInt val;
561	output_sei_message_header(sei, pDecodedMessageOutputStream, payloadSize);
562
563	sei_read_code( pDecodedMessageOutputStream, 4, val, "active_video_parameter_set_id"); sei.activeVPSId = val;
564	sei_read_flag( pDecodedMessageOutputStream, val, "self_contained_cvs_flag"); sei.m_selfContainedCvsFlag = (val != 0);
565	sei_read_flag( pDecodedMessageOutputStream, val, "no_parameter_set_update_flag"); sei.m_noParameterSetUpdateFlag = (val != 0);
566	sei_read_uvlc( pDecodedMessageOutputStream, val, "num_sps_ids_minus1"); sei.numSpsIdsMinus1 = val;
567
568	sei.activeSeqParameterSetId.resize(sei.numSpsIdsMinus1 + 1);
569	#if R0247_SEI_ACTIVE
570	sei.layerSpsIdx.resize(sei.numSpsIdsMinus1 + 1);
571	#endif
572	for (Int i=0; i < (sei.numSpsIdsMinus1 + 1); i++)
573	{
574	sei_read_uvlc( pDecodedMessageOutputStream, val, "active_seq_parameter_set_id[i]"); sei.activeSeqParameterSetId[i] = val;
575	}
576	#if R0247_SEI_ACTIVE
577	for (Int i=1; i < (sei.numSpsIdsMinus1 + 1); i++)
578	{
579	sei_read_uvlc( pDecodedMessageOutputStream, val, "layer_sps_idx"); sei.layerSpsIdx[i] = val;
580	}
581	#endif
582	}
583
584	#if SVC_EXTENSION
585	Void SEIReader::xParseSEIDecodingUnitInfo(SEIDecodingUnitInfo& sei, UInt payloadSize, const TComSPS sps, const SEIScalableNesting nestingSei, const SEIBspNesting* bspNestingSei, const TComVPS vps, std::ostream pDecodedMessageOutputStream)
586	#else
587	Void SEIReader::xParseSEIDecodingUnitInfo(SEIDecodingUnitInfo& sei, UInt payloadSize, const TComSPS sps, std::ostream pDecodedMessageOutputStream)
588	#endif
589	{
590	UInt val;
591	output_sei_message_header(sei, pDecodedMessageOutputStream, payloadSize);
592	sei_read_uvlc( pDecodedMessageOutputStream, val, "decoding_unit_idx");
593	sei.m_decodingUnitIdx = val;
594
595	#if SVC_EXTENSION
596	const TComHRD *hrd;
597	if( bspNestingSei ) // If DU info SEI contained inside a BSP nesting SEI message
598	{
599	assert( nestingSei );
600	Int psIdx = bspNestingSei->m_seiPartitioningSchemeIdx;
601	Int seiOlsIdx = bspNestingSei->m_seiOlsIdx;
602	Int maxTemporalId = nestingSei->m_nestingMaxTemporalIdPlus1[0] - 1;
603	Int maxValues = vps->getNumBspSchedulesMinus1(seiOlsIdx, psIdx, maxTemporalId) + 1;
604	std::vector<Int> hrdIdx(maxValues, 0);
605	std::vector<const TComHRD*> hrdVec;
606	std::vector<Int> syntaxElemLen(maxValues, 0);
607	for(Int i = 0; i < maxValues; i++)
608	{
609	hrdIdx[i] = vps->getBspHrdIdx( seiOlsIdx, psIdx, maxTemporalId, i, bspNestingSei->m_bspIdx);
610	hrdVec.push_back(vps->getBspHrd(hrdIdx[i]));
611
612	syntaxElemLen[i] = hrdVec[i]->getInitialCpbRemovalDelayLengthMinus1() + 1;
613	if ( !(hrdVec[i]->getNalHrdParametersPresentFlag() \|\| hrdVec[i]->getVclHrdParametersPresentFlag()) )
614	{
615	assert( syntaxElemLen[i] == 24 ); // Default of value init_cpb_removal_delay_length_minus1 is 23
616	}
617	if( i > 0 )
618	{
619	assert( hrdVec[i]->getSubPicCpbParamsPresentFlag() == hrdVec[i-1]->getSubPicCpbParamsPresentFlag() );
620	assert( hrdVec[i]->getSubPicCpbParamsInPicTimingSEIFlag() == hrdVec[i-1]->getSubPicCpbParamsInPicTimingSEIFlag() );
621	assert( hrdVec[i]->getDpbOutputDelayDuLengthMinus1() == hrdVec[i-1]->getDpbOutputDelayDuLengthMinus1() );
622	// To be done: Check CpbDpbDelaysPresentFlag
623	}
624	}
625	hrd = hrdVec[0];
626	}
627	else
628	{
629	const TComVUI *vui = sps->getVuiParameters();
630	hrd = vui->getHrdParameters();
631	}
632
633	if(hrd->getSubPicCpbParamsInPicTimingSEIFlag())
634	{
635	sei_read_code( pDecodedMessageOutputStream, ( hrd->getDuCpbRemovalDelayLengthMinus1() + 1 ), val, "du_spt_cpb_removal_delay_increment");
636	sei.m_duSptCpbRemovalDelay = val;
637	}
638	else
639	{
640	sei.m_duSptCpbRemovalDelay = 0;
641	}
642	sei_read_flag( pDecodedMessageOutputStream, val, "dpb_output_du_delay_present_flag"); sei.m_dpbOutputDuDelayPresentFlag = (val != 0);
643	if(sei.m_dpbOutputDuDelayPresentFlag)
644	{
645	sei_read_code( pDecodedMessageOutputStream, hrd->getDpbOutputDelayDuLengthMinus1() + 1, val, "pic_spt_dpb_output_du_delay");
646	sei.m_picSptDpbOutputDuDelay = val;
647	}
648	#else
649	const TComVUI *vui = sps->getVuiParameters();
650
651	if(vui->getHrdParameters()->getSubPicCpbParamsInPicTimingSEIFlag())
652	{
653	sei_read_code( pDecodedMessageOutputStream, ( vui->getHrdParameters()->getDuCpbRemovalDelayLengthMinus1() + 1 ), val, "du_spt_cpb_removal_delay_increment");
654	sei.m_duSptCpbRemovalDelay = val;
655	}
656	else
657	{
658	sei.m_duSptCpbRemovalDelay = 0;
659	}
660	sei_read_flag( pDecodedMessageOutputStream, val, "dpb_output_du_delay_present_flag"); sei.m_dpbOutputDuDelayPresentFlag = (val != 0);
661	if(sei.m_dpbOutputDuDelayPresentFlag)
662	{
663	sei_read_code( pDecodedMessageOutputStream, vui->getHrdParameters()->getDpbOutputDelayDuLengthMinus1() + 1, val, "pic_spt_dpb_output_du_delay");
664	sei.m_picSptDpbOutputDuDelay = val;
665	}
666	#endif
667	}
668
669	#if SVC_EXTENSION
670	Void SEIReader::xParseSEIBufferingPeriod(SEIBufferingPeriod& sei, UInt payloadSize, const TComSPS sps, const SEIScalableNesting nestingSei, const SEIBspNesting* bspNestingSei, const TComVPS vps, std::ostream pDecodedMessageOutputStream)
671	#else
672	Void SEIReader::xParseSEIBufferingPeriod(SEIBufferingPeriod& sei, UInt payloadSize, const TComSPS sps, std::ostream pDecodedMessageOutputStream)
673	#endif
674	{
675	Int i, nalOrVcl;
676	UInt code;
677
678	#if SVC_EXTENSION
679	const TComHRD *pHRD;
680	if( bspNestingSei ) // If BP SEI contained inside a BSP nesting SEI message
681	{
682	assert( nestingSei );
683	Int psIdx = bspNestingSei->m_seiPartitioningSchemeIdx;
684	Int seiOlsIdx = bspNestingSei->m_seiOlsIdx;
685	Int maxTemporalId = nestingSei->m_nestingMaxTemporalIdPlus1[0] - 1;
686	Int maxValues = vps->getNumBspSchedulesMinus1(seiOlsIdx, psIdx, maxTemporalId) + 1;
687	std::vector<Int> hrdIdx(maxValues, 0);
688	std::vector<const TComHRD*> hrdVec;
689	std::vector<Int> syntaxElemLen(maxValues, 0);
690	for(i = 0; i < maxValues; i++)
691	{
692	hrdIdx[i] = vps->getBspHrdIdx( seiOlsIdx, psIdx, maxTemporalId, i, bspNestingSei->m_bspIdx);
693	hrdVec.push_back(vps->getBspHrd(hrdIdx[i]));
694
695	syntaxElemLen[i] = hrdVec[i]->getInitialCpbRemovalDelayLengthMinus1() + 1;
696	if ( !(hrdVec[i]->getNalHrdParametersPresentFlag() \|\| hrdVec[i]->getVclHrdParametersPresentFlag()) )
697	{
698	assert( syntaxElemLen[i] == 24 ); // Default of value init_cpb_removal_delay_length_minus1 is 23
699	}
700	if( i > 0 )
701	{
702	assert( hrdVec[i]->getCpbRemovalDelayLengthMinus1() == hrdVec[i-1]->getCpbRemovalDelayLengthMinus1() );
703	assert( hrdVec[i]->getDpbOutputDelayDuLengthMinus1() == hrdVec[i-1]->getDpbOutputDelayDuLengthMinus1() );
704	assert( hrdVec[i]->getSubPicCpbParamsPresentFlag() == hrdVec[i-1]->getSubPicCpbParamsPresentFlag() );
705	}
706	}
707	pHRD = hrdVec[i];
708	}
709	else
710	{
711	const TComVUI *vui = sps->getVuiParameters();
712	pHRD = vui->getHrdParameters();
713	}
714	// To be done: When contained in an BSP HRD SEI message, the hrd structure is to be chosen differently.
715	#else
716	const TComVUI *pVUI = sps->getVuiParameters();
717	const TComHRD *pHRD = pVUI->getHrdParameters();
718	#endif
719
720	output_sei_message_header(sei, pDecodedMessageOutputStream, payloadSize);
721
722	sei_read_uvlc( pDecodedMessageOutputStream, code, "bp_seq_parameter_set_id" ); sei.m_bpSeqParameterSetId = code;
723	if( !pHRD->getSubPicCpbParamsPresentFlag() )
724	{
725	sei_read_flag( pDecodedMessageOutputStream, code, "irap_cpb_params_present_flag" ); sei.m_rapCpbParamsPresentFlag = code;
726	}
727	if( sei.m_rapCpbParamsPresentFlag )
728	{
729	sei_read_code( pDecodedMessageOutputStream, pHRD->getCpbRemovalDelayLengthMinus1() + 1, code, "cpb_delay_offset" ); sei.m_cpbDelayOffset = code;
730	sei_read_code( pDecodedMessageOutputStream, pHRD->getDpbOutputDelayLengthMinus1() + 1, code, "dpb_delay_offset" ); sei.m_dpbDelayOffset = code;
731	}
732
733	//read splicing flag and cpb_removal_delay_delta
734	sei_read_flag( pDecodedMessageOutputStream, code, "concatenation_flag");
735	sei.m_concatenationFlag = code;
736	sei_read_code( pDecodedMessageOutputStream, ( pHRD->getCpbRemovalDelayLengthMinus1() + 1 ), code, "au_cpb_removal_delay_delta_minus1" );
737	sei.m_auCpbRemovalDelayDelta = code + 1;
738
739	for( nalOrVcl = 0; nalOrVcl < 2; nalOrVcl ++ )
740	{
741	if( ( ( nalOrVcl == 0 ) && ( pHRD->getNalHrdParametersPresentFlag() ) ) \|\|
742	( ( nalOrVcl == 1 ) && ( pHRD->getVclHrdParametersPresentFlag() ) ) )
743	{
744	for( i = 0; i < ( pHRD->getCpbCntMinus1( 0 ) + 1 ); i ++ )
745	{
746	sei_read_code( pDecodedMessageOutputStream, ( pHRD->getInitialCpbRemovalDelayLengthMinus1() + 1 ) , code, nalOrVcl?"vcl_initial_cpb_removal_delay":"nal_initial_cpb_removal_delay" );
747	sei.m_initialCpbRemovalDelay[i][nalOrVcl] = code;
748	sei_read_code( pDecodedMessageOutputStream, ( pHRD->getInitialCpbRemovalDelayLengthMinus1() + 1 ) , code, nalOrVcl?"vcl_initial_cpb_removal_offset":"vcl_initial_cpb_removal_offset" );
749	sei.m_initialCpbRemovalDelayOffset[i][nalOrVcl] = code;
750	if( pHRD->getSubPicCpbParamsPresentFlag() \|\| sei.m_rapCpbParamsPresentFlag )
751	{
752	sei_read_code( pDecodedMessageOutputStream, ( pHRD->getInitialCpbRemovalDelayLengthMinus1() + 1 ) , code, nalOrVcl?"vcl_initial_alt_cpb_removal_delay":"vcl_initial_alt_cpb_removal_delay" );
753	sei.m_initialAltCpbRemovalDelay[i][nalOrVcl] = code;
754	sei_read_code( pDecodedMessageOutputStream, ( pHRD->getInitialCpbRemovalDelayLengthMinus1() + 1 ) , code, nalOrVcl?"vcl_initial_alt_cpb_removal_offset":"vcl_initial_alt_cpb_removal_offset" );
755	sei.m_initialAltCpbRemovalDelayOffset[i][nalOrVcl] = code;
756	}
757	}
758	}
759	}
760
761	#if P0138_USE_ALT_CPB_PARAMS_FLAG
762	sei.m_useAltCpbParamsFlag = false;
763	sei.m_useAltCpbParamsFlagPresent = false;
764	if (xPayloadExtensionPresent())
765	{
766	sei_read_flag( pDecodedMessageOutputStream, code, "use_alt_cpb_params_flag");
767	sei.m_useAltCpbParamsFlag = code;
768	sei.m_useAltCpbParamsFlagPresent = true;
769	}
770	#endif
771	}
772
773	#if SVC_EXTENSION
774	Void SEIReader::xParseSEIPictureTiming(SEIPictureTiming& sei, UInt payloadSize, const TComSPS sps, const SEIScalableNesting nestingSei, const SEIBspNesting* bspNestingSei, const TComVPS vps, std::ostream pDecodedMessageOutputStream)
775	#else
776	Void SEIReader::xParseSEIPictureTiming(SEIPictureTiming& sei, UInt payloadSize, const TComSPS sps, std::ostream pDecodedMessageOutputStream)
777	#endif
778	{
779	Int i;
780	UInt code;
781
782	#if SVC_EXTENSION
783	const TComHRD *hrd;
784	const TComVUI *vui = sps->getVuiParameters();
785	if( bspNestingSei ) // If BP SEI contained inside a BSP nesting SEI message
786	{
787	assert( nestingSei );
788	Int psIdx = bspNestingSei->m_seiPartitioningSchemeIdx;
789	Int seiOlsIdx = bspNestingSei->m_seiOlsIdx;
790	Int maxTemporalId = nestingSei->m_nestingMaxTemporalIdPlus1[0] - 1;
791	Int maxValues = vps->getNumBspSchedulesMinus1(seiOlsIdx, psIdx, maxTemporalId) + 1;
792	std::vector<Int> hrdIdx(maxValues, 0);
793	std::vector<const TComHRD*> hrdVec;
794	std::vector<Int> syntaxElemLen(maxValues, 0);
795	for(i = 0; i < maxValues; i++)
796	{
797	hrdIdx[i] = vps->getBspHrdIdx( seiOlsIdx, psIdx, maxTemporalId, i, bspNestingSei->m_bspIdx);
798	hrdVec.push_back(vps->getBspHrd(hrdIdx[i]));
799
800	syntaxElemLen[i] = hrdVec[i]->getInitialCpbRemovalDelayLengthMinus1() + 1;
801	if ( !(hrdVec[i]->getNalHrdParametersPresentFlag() \|\| hrdVec[i]->getVclHrdParametersPresentFlag()) )
802	{
803	assert( syntaxElemLen[i] == 24 ); // Default of value init_cpb_removal_delay_length_minus1 is 23
804	}
805	if( i > 0 )
806	{
807	assert( hrdVec[i]->getSubPicCpbParamsPresentFlag() == hrdVec[i-1]->getSubPicCpbParamsPresentFlag() );
808	assert( hrdVec[i]->getSubPicCpbParamsInPicTimingSEIFlag() == hrdVec[i-1]->getSubPicCpbParamsInPicTimingSEIFlag() );
809	assert( hrdVec[i]->getCpbRemovalDelayLengthMinus1() == hrdVec[i-1]->getCpbRemovalDelayLengthMinus1() );
810	assert( hrdVec[i]->getDpbOutputDelayLengthMinus1() == hrdVec[i-1]->getDpbOutputDelayLengthMinus1() );
811	assert( hrdVec[i]->getDpbOutputDelayDuLengthMinus1() == hrdVec[i-1]->getDpbOutputDelayDuLengthMinus1() );
812	assert( hrdVec[i]->getDuCpbRemovalDelayLengthMinus1() == hrdVec[i-1]->getDuCpbRemovalDelayLengthMinus1() );
813	// To be done: Check CpbDpbDelaysPresentFlag
814	}
815	}
816	hrd = hrdVec[0];
817	}
818	else
819	{
820	hrd = vui->getHrdParameters();
821	}
822	// To be done: When contained in an BSP HRD SEI message, the hrd structure is to be chosen differently.
823	#else
824	const TComVUI *vui = sps->getVuiParameters();
825	const TComHRD *hrd = vui->getHrdParameters();
826	#endif
827	output_sei_message_header(sei, pDecodedMessageOutputStream, payloadSize);
828
829	if( vui->getFrameFieldInfoPresentFlag() )
830	{
831	sei_read_code( pDecodedMessageOutputStream, 4, code, "pic_struct" ); sei.m_picStruct = code;
832	sei_read_code( pDecodedMessageOutputStream, 2, code, "source_scan_type" ); sei.m_sourceScanType = code;
833	sei_read_flag( pDecodedMessageOutputStream, code, "duplicate_flag" ); sei.m_duplicateFlag = (code == 1);
834	}
835
836	if( hrd->getCpbDpbDelaysPresentFlag())
837	{
838	sei_read_code( pDecodedMessageOutputStream, ( hrd->getCpbRemovalDelayLengthMinus1() + 1 ), code, "au_cpb_removal_delay_minus1" );
839	sei.m_auCpbRemovalDelay = code + 1;
840	sei_read_code( pDecodedMessageOutputStream, ( hrd->getDpbOutputDelayLengthMinus1() + 1 ), code, "pic_dpb_output_delay" );
841	sei.m_picDpbOutputDelay = code;
842
843	if(hrd->getSubPicCpbParamsPresentFlag())
844	{
845	sei_read_code( pDecodedMessageOutputStream, hrd->getDpbOutputDelayDuLengthMinus1()+1, code, "pic_dpb_output_du_delay" );
846	sei.m_picDpbOutputDuDelay = code;
847	}
848
849	if( hrd->getSubPicCpbParamsPresentFlag() && hrd->getSubPicCpbParamsInPicTimingSEIFlag() )
850	{
851	sei_read_uvlc( pDecodedMessageOutputStream, code, "num_decoding_units_minus1");
852	sei.m_numDecodingUnitsMinus1 = code;
853	sei_read_flag( pDecodedMessageOutputStream, code, "du_common_cpb_removal_delay_flag" );
854	sei.m_duCommonCpbRemovalDelayFlag = code;
855	if( sei.m_duCommonCpbRemovalDelayFlag )
856	{
857	sei_read_code( pDecodedMessageOutputStream, ( hrd->getDuCpbRemovalDelayLengthMinus1() + 1 ), code, "du_common_cpb_removal_delay_increment_minus1" );
858	sei.m_duCommonCpbRemovalDelayMinus1 = code;
859	}
860	if( sei.m_numNalusInDuMinus1 != NULL )
861	{
862	delete sei.m_numNalusInDuMinus1;
863	}
864	sei.m_numNalusInDuMinus1 = new UInt[ ( sei.m_numDecodingUnitsMinus1 + 1 ) ];
865	if( sei.m_duCpbRemovalDelayMinus1 != NULL )
866	{
867	delete sei.m_duCpbRemovalDelayMinus1;
868	}
869	sei.m_duCpbRemovalDelayMinus1 = new UInt[ ( sei.m_numDecodingUnitsMinus1 + 1 ) ];
870
871	for( i = 0; i <= sei.m_numDecodingUnitsMinus1; i ++ )
872	{
873	sei_read_uvlc( pDecodedMessageOutputStream, code, "num_nalus_in_du_minus1[i]");
874	sei.m_numNalusInDuMinus1[ i ] = code;
875	if( ( !sei.m_duCommonCpbRemovalDelayFlag ) && ( i < sei.m_numDecodingUnitsMinus1 ) )
876	{
877	sei_read_code( pDecodedMessageOutputStream, ( hrd->getDuCpbRemovalDelayLengthMinus1() + 1 ), code, "du_cpb_removal_delay_minus1[i]" );
878	sei.m_duCpbRemovalDelayMinus1[ i ] = code;
879	}
880	}
881	}
882	}
883	}
884
885	Void SEIReader::xParseSEIRecoveryPoint(SEIRecoveryPoint& sei, UInt payloadSize, std::ostream *pDecodedMessageOutputStream)
886	{
887	Int iCode;
888	UInt uiCode;
889	output_sei_message_header(sei, pDecodedMessageOutputStream, payloadSize);
890
891	sei_read_svlc( pDecodedMessageOutputStream, iCode, "recovery_poc_cnt" ); sei.m_recoveryPocCnt = iCode;
892	sei_read_flag( pDecodedMessageOutputStream, uiCode, "exact_matching_flag" ); sei.m_exactMatchingFlag = uiCode;
893	sei_read_flag( pDecodedMessageOutputStream, uiCode, "broken_link_flag" ); sei.m_brokenLinkFlag = uiCode;
894	}
895
896	Void SEIReader::xParseSEIFramePacking(SEIFramePacking& sei, UInt payloadSize, std::ostream *pDecodedMessageOutputStream)
897	{
898	UInt val;
899	output_sei_message_header(sei, pDecodedMessageOutputStream, payloadSize);
900
901	sei_read_uvlc( pDecodedMessageOutputStream, val, "frame_packing_arrangement_id" ); sei.m_arrangementId = val;
902	sei_read_flag( pDecodedMessageOutputStream, val, "frame_packing_arrangement_cancel_flag" ); sei.m_arrangementCancelFlag = val;
903
904	if ( !sei.m_arrangementCancelFlag )
905	{
906	sei_read_code( pDecodedMessageOutputStream, 7, val, "frame_packing_arrangement_type" ); sei.m_arrangementType = val;
907	assert((sei.m_arrangementType > 2) && (sei.m_arrangementType < 6) );
908
909	sei_read_flag( pDecodedMessageOutputStream, val, "quincunx_sampling_flag" ); sei.m_quincunxSamplingFlag = val;
910
911	sei_read_code( pDecodedMessageOutputStream, 6, val, "content_interpretation_type" ); sei.m_contentInterpretationType = val;
912	sei_read_flag( pDecodedMessageOutputStream, val, "spatial_flipping_flag" ); sei.m_spatialFlippingFlag = val;
913	sei_read_flag( pDecodedMessageOutputStream, val, "frame0_flipped_flag" ); sei.m_frame0FlippedFlag = val;
914	sei_read_flag( pDecodedMessageOutputStream, val, "field_views_flag" ); sei.m_fieldViewsFlag = val;
915	sei_read_flag( pDecodedMessageOutputStream, val, "current_frame_is_frame0_flag" ); sei.m_currentFrameIsFrame0Flag = val;
916	sei_read_flag( pDecodedMessageOutputStream, val, "frame0_self_contained_flag" ); sei.m_frame0SelfContainedFlag = val;
917	sei_read_flag( pDecodedMessageOutputStream, val, "frame1_self_contained_flag" ); sei.m_frame1SelfContainedFlag = val;
918
919	if ( sei.m_quincunxSamplingFlag == 0 && sei.m_arrangementType != 5)
920	{
921	sei_read_code( pDecodedMessageOutputStream, 4, val, "frame0_grid_position_x" ); sei.m_frame0GridPositionX = val;
922	sei_read_code( pDecodedMessageOutputStream, 4, val, "frame0_grid_position_y" ); sei.m_frame0GridPositionY = val;
923	sei_read_code( pDecodedMessageOutputStream, 4, val, "frame1_grid_position_x" ); sei.m_frame1GridPositionX = val;
924	sei_read_code( pDecodedMessageOutputStream, 4, val, "frame1_grid_position_y" ); sei.m_frame1GridPositionY = val;
925	}
926
927	sei_read_code( pDecodedMessageOutputStream, 8, val, "frame_packing_arrangement_reserved_byte" ); sei.m_arrangementReservedByte = val;
928	sei_read_flag( pDecodedMessageOutputStream, val, "frame_packing_arrangement_persistence_flag" ); sei.m_arrangementPersistenceFlag = (val != 0);
929	}
930	sei_read_flag( pDecodedMessageOutputStream, val, "upsampled_aspect_ratio_flag" ); sei.m_upsampledAspectRatio = val;
931	}
932
933	Void SEIReader::xParseSEISegmentedRectFramePacking(SEISegmentedRectFramePacking& sei, UInt payloadSize, std::ostream *pDecodedMessageOutputStream)
934	{
935	UInt val;
936	output_sei_message_header(sei, pDecodedMessageOutputStream, payloadSize);
937	sei_read_flag( pDecodedMessageOutputStream, val, "segmented_rect_frame_packing_arrangement_cancel_flag" ); sei.m_arrangementCancelFlag = val;
938	if( !sei.m_arrangementCancelFlag )
939	{
940	sei_read_code( pDecodedMessageOutputStream, 2, val, "segmented_rect_content_interpretation_type" ); sei.m_contentInterpretationType = val;
941	sei_read_flag( pDecodedMessageOutputStream, val, "segmented_rect_frame_packing_arrangement_persistence" ); sei.m_arrangementPersistenceFlag = val;
942	}
943	}
944
945	Void SEIReader::xParseSEIDisplayOrientation(SEIDisplayOrientation& sei, UInt payloadSize, std::ostream *pDecodedMessageOutputStream)
946	{
947	UInt val;
948	output_sei_message_header(sei, pDecodedMessageOutputStream, payloadSize);
949	sei_read_flag( pDecodedMessageOutputStream, val, "display_orientation_cancel_flag" ); sei.cancelFlag = val;
950	if( !sei.cancelFlag )
951	{
952	sei_read_flag( pDecodedMessageOutputStream, val, "hor_flip" ); sei.horFlip = val;
953	sei_read_flag( pDecodedMessageOutputStream, val, "ver_flip" ); sei.verFlip = val;
954	sei_read_code( pDecodedMessageOutputStream, 16, val, "anticlockwise_rotation" ); sei.anticlockwiseRotation = val;
955	sei_read_flag( pDecodedMessageOutputStream, val, "display_orientation_persistence_flag" ); sei.persistenceFlag = val;
956	}
957	}
958
959	Void SEIReader::xParseSEITemporalLevel0Index(SEITemporalLevel0Index& sei, UInt payloadSize, std::ostream *pDecodedMessageOutputStream)
960	{
961	UInt val;
962	output_sei_message_header(sei, pDecodedMessageOutputStream, payloadSize);
963	sei_read_code( pDecodedMessageOutputStream, 8, val, "temporal_sub_layer_zero_idx" ); sei.tl0Idx = val;
964	sei_read_code( pDecodedMessageOutputStream, 8, val, "irap_pic_id" ); sei.rapIdx = val;
965	}
966
967	Void SEIReader::xParseSEIRegionRefreshInfo(SEIGradualDecodingRefreshInfo& sei, UInt payloadSize, std::ostream *pDecodedMessageOutputStream)
968	{
969	UInt val;
970	output_sei_message_header(sei, pDecodedMessageOutputStream, payloadSize);
971	sei_read_flag( pDecodedMessageOutputStream, val, "refreshed_region_flag" ); sei.m_gdrForegroundFlag = val ? 1 : 0;
972	}
973
974	Void SEIReader::xParseSEINoDisplay(SEINoDisplay& sei, UInt payloadSize, std::ostream *pDecodedMessageOutputStream)
975	{
976	output_sei_message_header(sei, pDecodedMessageOutputStream, payloadSize);
977	sei.m_noDisplay = true;
978	}
979
980	Void SEIReader::xParseSEIToneMappingInfo(SEIToneMappingInfo& sei, UInt payloadSize, std::ostream *pDecodedMessageOutputStream)
981	{
982	Int i;
983	UInt val;
984	output_sei_message_header(sei, pDecodedMessageOutputStream, payloadSize);
985	sei_read_uvlc( pDecodedMessageOutputStream, val, "tone_map_id" ); sei.m_toneMapId = val;
986	sei_read_flag( pDecodedMessageOutputStream, val, "tone_map_cancel_flag" ); sei.m_toneMapCancelFlag = val;
987
988	if ( !sei.m_toneMapCancelFlag )
989	{
990	sei_read_flag( pDecodedMessageOutputStream, val, "tone_map_persistence_flag" ); sei.m_toneMapPersistenceFlag = val;
991	sei_read_code( pDecodedMessageOutputStream, 8, val, "coded_data_bit_depth" ); sei.m_codedDataBitDepth = val;
992	sei_read_code( pDecodedMessageOutputStream, 8, val, "target_bit_depth" ); sei.m_targetBitDepth = val;
993	sei_read_uvlc( pDecodedMessageOutputStream, val, "tone_map_model_id" ); sei.m_modelId = val;
994	switch(sei.m_modelId)
995	{
996	case 0:
997	{
998	sei_read_code( pDecodedMessageOutputStream, 32, val, "min_value" ); sei.m_minValue = val;
999	sei_read_code( pDecodedMessageOutputStream, 32, val, "max_value" ); sei.m_maxValue = val;
1000	break;
1001	}
1002	case 1:
1003	{
1004	sei_read_code( pDecodedMessageOutputStream, 32, val, "sigmoid_midpoint" ); sei.m_sigmoidMidpoint = val;
1005	sei_read_code( pDecodedMessageOutputStream, 32, val, "sigmoid_width" ); sei.m_sigmoidWidth = val;
1006	break;
1007	}
1008	case 2:
1009	{
1010	UInt num = 1u << sei.m_targetBitDepth;
1011	sei.m_startOfCodedInterval.resize(num+1);
1012	for(i = 0; i < num; i++)
1013	{
1014	sei_read_code( pDecodedMessageOutputStream, ((( sei.m_codedDataBitDepth + 7 ) >> 3 ) << 3), val, "start_of_coded_interval[i]" );
1015	sei.m_startOfCodedInterval[i] = val;
1016	}
1017	sei.m_startOfCodedInterval[num] = 1u << sei.m_codedDataBitDepth;
1018	break;
1019	}
1020	case 3:
1021	{
1022	sei_read_code( pDecodedMessageOutputStream, 16, val, "num_pivots" ); sei.m_numPivots = val;
1023	sei.m_codedPivotValue.resize(sei.m_numPivots);
1024	sei.m_targetPivotValue.resize(sei.m_numPivots);
1025	for(i = 0; i < sei.m_numPivots; i++ )
1026	{
1027	sei_read_code( pDecodedMessageOutputStream, ((( sei.m_codedDataBitDepth + 7 ) >> 3 ) << 3), val, "coded_pivot_value[i]" );
1028	sei.m_codedPivotValue[i] = val;
1029	sei_read_code( pDecodedMessageOutputStream, ((( sei.m_targetBitDepth + 7 ) >> 3 ) << 3), val, "target_pivot_value[i]" );
1030	sei.m_targetPivotValue[i] = val;
1031	}
1032	break;
1033	}
1034	case 4:
1035	{
1036	sei_read_code( pDecodedMessageOutputStream, 8, val, "camera_iso_speed_idc" ); sei.m_cameraIsoSpeedIdc = val;
1037	if( sei.m_cameraIsoSpeedIdc == 255) //Extended_ISO
1038	{
1039	sei_read_code( pDecodedMessageOutputStream, 32, val, "camera_iso_speed_value" ); sei.m_cameraIsoSpeedValue = val;
1040	}
1041	sei_read_code( pDecodedMessageOutputStream, 8, val, "exposure_index_idc" ); sei.m_exposureIndexIdc = val;
1042	if( sei.m_exposureIndexIdc == 255) //Extended_ISO
1043	{
1044	sei_read_code( pDecodedMessageOutputStream, 32, val, "exposure_index_value" ); sei.m_exposureIndexValue = val;
1045	}
1046	sei_read_flag( pDecodedMessageOutputStream, val, "exposure_compensation_value_sign_flag" ); sei.m_exposureCompensationValueSignFlag = val;
1047	sei_read_code( pDecodedMessageOutputStream, 16, val, "exposure_compensation_value_numerator" ); sei.m_exposureCompensationValueNumerator = val;
1048	sei_read_code( pDecodedMessageOutputStream, 16, val, "exposure_compensation_value_denom_idc" ); sei.m_exposureCompensationValueDenomIdc = val;
1049	sei_read_code( pDecodedMessageOutputStream, 32, val, "ref_screen_luminance_white" ); sei.m_refScreenLuminanceWhite = val;
1050	sei_read_code( pDecodedMessageOutputStream, 32, val, "extended_range_white_level" ); sei.m_extendedRangeWhiteLevel = val;
1051	sei_read_code( pDecodedMessageOutputStream, 16, val, "nominal_black_level_code_value" ); sei.m_nominalBlackLevelLumaCodeValue = val;
1052	sei_read_code( pDecodedMessageOutputStream, 16, val, "nominal_white_level_code_value" ); sei.m_nominalWhiteLevelLumaCodeValue= val;
1053	sei_read_code( pDecodedMessageOutputStream, 16, val, "extended_white_level_code_value" ); sei.m_extendedWhiteLevelLumaCodeValue = val;
1054	break;
1055	}
1056	default:
1057	{
1058	assert(!"Undefined SEIToneMapModelId");
1059	break;
1060	}
1061	}//switch model id
1062	}// if(!sei.m_toneMapCancelFlag)
1063	}
1064
1065	Void SEIReader::xParseSEISOPDescription(SEISOPDescription &sei, UInt payloadSize, std::ostream *pDecodedMessageOutputStream)
1066	{
1067	Int iCode;
1068	UInt uiCode;
1069	output_sei_message_header(sei, pDecodedMessageOutputStream, payloadSize);
1070
1071	sei_read_uvlc( pDecodedMessageOutputStream, uiCode, "sop_seq_parameter_set_id" ); sei.m_sopSeqParameterSetId = uiCode;
1072	sei_read_uvlc( pDecodedMessageOutputStream, uiCode, "num_pics_in_sop_minus1" ); sei.m_numPicsInSopMinus1 = uiCode;
1073	for (UInt i = 0; i <= sei.m_numPicsInSopMinus1; i++)
1074	{
1075	sei_read_code( pDecodedMessageOutputStream, 6, uiCode, "sop_vcl_nut[i]" ); sei.m_sopDescVclNaluType[i] = uiCode;
1076	sei_read_code( pDecodedMessageOutputStream, 3, sei.m_sopDescTemporalId[i], "sop_temporal_id[i]" ); sei.m_sopDescTemporalId[i] = uiCode;
1077	if (sei.m_sopDescVclNaluType[i] != NAL_UNIT_CODED_SLICE_IDR_W_RADL && sei.m_sopDescVclNaluType[i] != NAL_UNIT_CODED_SLICE_IDR_N_LP)
1078	{
1079	sei_read_uvlc( pDecodedMessageOutputStream, sei.m_sopDescStRpsIdx[i], "sop_short_term_rps_idx[i]" ); sei.m_sopDescStRpsIdx[i] = uiCode;
1080	}
1081	if (i > 0)
1082	{
1083	sei_read_svlc( pDecodedMessageOutputStream, iCode, "sop_poc_delta[i]" ); sei.m_sopDescPocDelta[i] = iCode;
1084	}
1085	}
1086	}
1087
1088	#if LAYERS_NOT_PRESENT_SEI
1089	Void SEIReader::xParseSEIScalableNesting(SEIScalableNesting& sei, const NalUnitType nalUnitType, UInt payloadSize, const TComVPS vps, const TComSPS sps, std::ostream *pDecodedMessageOutputStream)
1090	#else
1091	Void SEIReader::xParseSEIScalableNesting(SEIScalableNesting& sei, const NalUnitType nalUnitType, UInt payloadSize, const TComSPS sps, std::ostream pDecodedMessageOutputStream)
1092	#endif
1093	{
1094	UInt uiCode;
1095	SEIMessages seis;
1096	output_sei_message_header(sei, pDecodedMessageOutputStream, payloadSize);
1097
1098	sei_read_flag( pDecodedMessageOutputStream, uiCode, "bitstream_subset_flag" ); sei.m_bitStreamSubsetFlag = uiCode;
1099	sei_read_flag( pDecodedMessageOutputStream, uiCode, "nesting_op_flag" ); sei.m_nestingOpFlag = uiCode;
1100	if (sei.m_nestingOpFlag)
1101	{
1102	sei_read_flag( pDecodedMessageOutputStream, uiCode, "default_op_flag" ); sei.m_defaultOpFlag = uiCode;
1103	sei_read_uvlc( pDecodedMessageOutputStream, uiCode, "nesting_num_ops_minus1" ); sei.m_nestingNumOpsMinus1 = uiCode;
1104	for (UInt i = sei.m_defaultOpFlag; i <= sei.m_nestingNumOpsMinus1; i++)
1105	{
1106	sei_read_code( pDecodedMessageOutputStream, 3, uiCode, "nesting_max_temporal_id_plus1[i]" ); sei.m_nestingMaxTemporalIdPlus1[i] = uiCode;
1107	sei_read_uvlc( pDecodedMessageOutputStream, uiCode, "nesting_op_idx[i]" ); sei.m_nestingOpIdx[i] = uiCode;
1108	}
1109	}
1110	else
1111	{
1112	sei_read_flag( pDecodedMessageOutputStream, uiCode, "all_layers_flag" ); sei.m_allLayersFlag = uiCode;
1113	if (!sei.m_allLayersFlag)
1114	{
1115	sei_read_code( pDecodedMessageOutputStream, 3, uiCode, "nesting_no_op_max_temporal_id_plus1" ); sei.m_nestingNoOpMaxTemporalIdPlus1 = uiCode;
1116	sei_read_uvlc( pDecodedMessageOutputStream, uiCode, "nesting_num_layers_minus1" ); sei.m_nestingNumLayersMinus1 = uiCode;
1117	for (UInt i = 0; i <= sei.m_nestingNumLayersMinus1; i++)
1118	{
1119	sei_read_code( pDecodedMessageOutputStream, 6, uiCode, "nesting_layer_id[i]" ); sei.m_nestingLayerId[i] = uiCode;
1120	}
1121	}
1122	}
1123
1124	// byte alignment
1125	while ( m_pcBitstream->getNumBitsRead() % 8 != 0 )
1126	{
1127	UInt code;
1128	sei_read_flag( pDecodedMessageOutputStream, code, "nesting_zero_bit" );
1129	}
1130
1131	sei.m_callerOwnsSEIs = false;
1132
1133	// read nested SEI messages
1134	do
1135	{
1136	#if O0164_MULTI_LAYER_HRD
1137	#if LAYERS_NOT_PRESENT_SEI
1138	xReadSEImessage(sei.m_nestedSEIs, nalUnitType, vps, sps, pDecodedMessageOutputStream, &sei);
1139	#else
1140	xReadSEImessage(sei.m_nestedSEIs, nalUnitType, sps, pDecodedMessageOutputStream, &sei);
1141	#endif
1142	#else
1143	#if LAYERS_NOT_PRESENT_SEI
1144	xReadSEImessage(sei.m_nestedSEIs, nalUnitType, vps, sps, pDecodedMessageOutputStream);
1145	#else
1146	xReadSEImessage(sei.m_nestedSEIs, nalUnitType, sps, pDecodedMessageOutputStream);
1147	#endif
1148	#endif
1149	} while (m_pcBitstream->getNumBitsLeft() > 8);
1150
1151	if (pDecodedMessageOutputStream)
1152	{
1153	(*pDecodedMessageOutputStream) << "End of scalable nesting SEI message\n";
1154	}
1155	}
1156
1157	Void SEIReader::xParseSEITempMotionConstraintsTileSets(SEITempMotionConstrainedTileSets& sei, UInt payloadSize, std::ostream *pDecodedMessageOutputStream)
1158	{
1159	UInt code;
1160	output_sei_message_header(sei, pDecodedMessageOutputStream, payloadSize);
1161	sei_read_flag( pDecodedMessageOutputStream, code, "mc_all_tiles_exact_sample_value_match_flag"); sei.m_mc_all_tiles_exact_sample_value_match_flag = (code != 0);
1162	sei_read_flag( pDecodedMessageOutputStream, code, "each_tile_one_tile_set_flag"); sei.m_each_tile_one_tile_set_flag = (code != 0);
1163
1164	if(!sei.m_each_tile_one_tile_set_flag)
1165	{
1166	sei_read_flag( pDecodedMessageOutputStream, code, "limited_tile_set_display_flag"); sei.m_limited_tile_set_display_flag = (code != 0);
1167	sei_read_uvlc( pDecodedMessageOutputStream, code, "num_sets_in_message_minus1"); sei.setNumberOfTileSets(code + 1);
1168
1169	if(sei.getNumberOfTileSets() != 0)
1170	{
1171	for(Int i = 0; i < sei.getNumberOfTileSets(); i++)
1172	{
1173	sei_read_uvlc( pDecodedMessageOutputStream, code, "mcts_id"); sei.tileSetData(i).m_mcts_id = code;
1174
1175	if(sei.m_limited_tile_set_display_flag)
1176	{
1177	sei_read_flag( pDecodedMessageOutputStream, code, "display_tile_set_flag"); sei.tileSetData(i).m_display_tile_set_flag = (code != 1);
1178	}
1179
1180	sei_read_uvlc( pDecodedMessageOutputStream, code, "num_tile_rects_in_set_minus1"); sei.tileSetData(i).setNumberOfTileRects(code + 1);
1181
1182	for(Int j=0; j<sei.tileSetData(i).getNumberOfTileRects(); j++)
1183	{
1184	sei_read_uvlc( pDecodedMessageOutputStream, code, "top_left_tile_index"); sei.tileSetData(i).topLeftTileIndex(j) = code;
1185	sei_read_uvlc( pDecodedMessageOutputStream, code, "bottom_right_tile_index"); sei.tileSetData(i).bottomRightTileIndex(j) = code;
1186	}
1187
1188	if(!sei.m_mc_all_tiles_exact_sample_value_match_flag)
1189	{
1190	sei_read_flag( pDecodedMessageOutputStream, code, "exact_sample_value_match_flag"); sei.tileSetData(i).m_exact_sample_value_match_flag = (code != 0);
1191	}
1192	sei_read_flag( pDecodedMessageOutputStream, code, "mcts_tier_level_idc_present_flag"); sei.tileSetData(i).m_mcts_tier_level_idc_present_flag = (code != 0);
1193
1194	if(sei.tileSetData(i).m_mcts_tier_level_idc_present_flag)
1195	{
1196	sei_read_flag( pDecodedMessageOutputStream, code, "mcts_tier_flag"); sei.tileSetData(i).m_mcts_tier_flag = (code != 0);
1197	sei_read_code( pDecodedMessageOutputStream, 8, code, "mcts_level_idc"); sei.tileSetData(i).m_mcts_level_idc = code;
1198	}
1199	}
1200	}
1201	}
1202	else
1203	{
1204	sei_read_flag( pDecodedMessageOutputStream, code, "max_mcs_tier_level_idc_present_flag"); sei.m_max_mcs_tier_level_idc_present_flag = code;
1205	if(sei.m_max_mcs_tier_level_idc_present_flag)
1206	{
1207	sei_read_flag( pDecodedMessageOutputStream, code, "max_mcts_tier_flag"); sei.m_max_mcts_tier_flag = code;
1208	sei_read_code( pDecodedMessageOutputStream, 8, code, "max_mcts_level_idc"); sei.m_max_mcts_level_idc = code;
1209	}
1210	}
1211	}
1212
1213	Void SEIReader::xParseSEITimeCode(SEITimeCode& sei, UInt payloadSize, std::ostream *pDecodedMessageOutputStream)
1214	{
1215	UInt code;
1216	output_sei_message_header(sei, pDecodedMessageOutputStream, payloadSize);
1217	sei_read_code( pDecodedMessageOutputStream, 2, code, "num_clock_ts"); sei.numClockTs = code;
1218	for(Int i = 0; i < sei.numClockTs; i++)
1219	{
1220	TComSEITimeSet currentTimeSet;
1221	sei_read_flag( pDecodedMessageOutputStream, code, "clock_time_stamp_flag[i]"); currentTimeSet.clockTimeStampFlag = code;
1222	if(currentTimeSet.clockTimeStampFlag)
1223	{
1224	sei_read_flag( pDecodedMessageOutputStream, code, "nuit_field_based_flag"); currentTimeSet.numUnitFieldBasedFlag = code;
1225	sei_read_code( pDecodedMessageOutputStream, 5, code, "counting_type"); currentTimeSet.countingType = code;
1226	sei_read_flag( pDecodedMessageOutputStream, code, "full_timestamp_flag"); currentTimeSet.fullTimeStampFlag = code;
1227	sei_read_flag( pDecodedMessageOutputStream, code, "discontinuity_flag"); currentTimeSet.discontinuityFlag = code;
1228	sei_read_flag( pDecodedMessageOutputStream, code, "cnt_dropped_flag"); currentTimeSet.cntDroppedFlag = code;
1229	sei_read_code( pDecodedMessageOutputStream, 9, code, "n_frames"); currentTimeSet.numberOfFrames = code;
1230	if(currentTimeSet.fullTimeStampFlag)
1231	{
1232	sei_read_code( pDecodedMessageOutputStream, 6, code, "seconds_value"); currentTimeSet.secondsValue = code;
1233	sei_read_code( pDecodedMessageOutputStream, 6, code, "minutes_value"); currentTimeSet.minutesValue = code;
1234	sei_read_code( pDecodedMessageOutputStream, 5, code, "hours_value"); currentTimeSet.hoursValue = code;
1235	}
1236	else
1237	{
1238	sei_read_flag( pDecodedMessageOutputStream, code, "seconds_flag"); currentTimeSet.secondsFlag = code;
1239	if(currentTimeSet.secondsFlag)
1240	{
1241	sei_read_code( pDecodedMessageOutputStream, 6, code, "seconds_value"); currentTimeSet.secondsValue = code;
1242	sei_read_flag( pDecodedMessageOutputStream, code, "minutes_flag"); currentTimeSet.minutesFlag = code;
1243	if(currentTimeSet.minutesFlag)
1244	{
1245	sei_read_code( pDecodedMessageOutputStream, 6, code, "minutes_value"); currentTimeSet.minutesValue = code;
1246	sei_read_flag( pDecodedMessageOutputStream, code, "hours_flag"); currentTimeSet.hoursFlag = code;
1247	if(currentTimeSet.hoursFlag)
1248	{
1249	sei_read_code( pDecodedMessageOutputStream, 5, code, "hours_value"); currentTimeSet.hoursValue = code;
1250	}
1251	}
1252	}
1253	}
1254	sei_read_code( pDecodedMessageOutputStream, 5, code, "time_offset_length"); currentTimeSet.timeOffsetLength = code;
1255	if(currentTimeSet.timeOffsetLength > 0)
1256	{
1257	sei_read_code( pDecodedMessageOutputStream, currentTimeSet.timeOffsetLength, code, "time_offset_value");
1258	if((code & (1 << (currentTimeSet.timeOffsetLength-1))) == 0)
1259	{
1260	currentTimeSet.timeOffsetValue = code;
1261	}
1262	else
1263	{
1264	code &= (1<< (currentTimeSet.timeOffsetLength-1)) - 1;
1265	currentTimeSet.timeOffsetValue = ~code + 1;
1266	}
1267	}
1268	}
1269	sei.timeSetArray[i] = currentTimeSet;
1270	}
1271	}
1272
1273	Void SEIReader::xParseSEIChromaSamplingFilterHint(SEIChromaSamplingFilterHint& sei, UInt payloadSize/, TComSPS sps/, std::ostream pDecodedMessageOutputStream)
1274	{
1275	UInt uiCode;
1276	output_sei_message_header(sei, pDecodedMessageOutputStream, payloadSize);
1277
1278	sei_read_code( pDecodedMessageOutputStream, 8, uiCode, "ver_chroma_filter_idc"); sei.m_verChromaFilterIdc = uiCode;
1279	sei_read_code( pDecodedMessageOutputStream, 8, uiCode, "hor_chroma_filter_idc"); sei.m_horChromaFilterIdc = uiCode;
1280	sei_read_flag( pDecodedMessageOutputStream, uiCode, "ver_filtering_process_flag"); sei.m_verFilteringProcessFlag = uiCode;
1281	if(sei.m_verChromaFilterIdc == 1 \|\| sei.m_horChromaFilterIdc == 1)
1282	{
1283	sei_read_uvlc( pDecodedMessageOutputStream, uiCode, "target_format_idc"); sei.m_targetFormatIdc = uiCode;
1284	if(sei.m_verChromaFilterIdc == 1)
1285	{
1286	sei_read_uvlc( pDecodedMessageOutputStream, uiCode, "num_vertical_filters"); sei.m_numVerticalFilters = uiCode;
1287	if(sei.m_numVerticalFilters > 0)
1288	{
1289	sei.m_verTapLengthMinus1 = (Int)malloc(sei.m_numVerticalFilters sizeof(Int));
1290	sei.m_verFilterCoeff = (Int*)malloc(sei.m_numVerticalFilters sizeof(Int*));
1291	for(Int i = 0; i < sei.m_numVerticalFilters; i ++)
1292	{
1293	sei_read_uvlc( pDecodedMessageOutputStream, uiCode, "ver_tap_length_minus_1"); sei.m_verTapLengthMinus1[i] = uiCode;
1294	sei.m_verFilterCoeff[i] = (Int)malloc(sei.m_verTapLengthMinus1[i] sizeof(Int));
1295	for(Int j = 0; j < sei.m_verTapLengthMinus1[i]; j ++)
1296	{
1297	sei_read_svlc( pDecodedMessageOutputStream, sei.m_verFilterCoeff[i][j], "ver_filter_coeff");
1298	}
1299	}
1300	}
1301	}
1302	if(sei.m_horChromaFilterIdc == 1)
1303	{
1304	sei_read_uvlc( pDecodedMessageOutputStream, uiCode, "num_horizontal_filters"); sei.m_numHorizontalFilters = uiCode;
1305	if(sei.m_numHorizontalFilters > 0)
1306	{
1307	sei.m_horTapLengthMinus1 = (Int)malloc(sei.m_numHorizontalFilters sizeof(Int));
1308	sei.m_horFilterCoeff = (Int*)malloc(sei.m_numHorizontalFilters sizeof(Int*));
1309	for(Int i = 0; i < sei.m_numHorizontalFilters; i ++)
1310	{
1311	sei_read_uvlc( pDecodedMessageOutputStream, uiCode, "hor_tap_length_minus_1"); sei.m_horTapLengthMinus1[i] = uiCode;
1312	sei.m_horFilterCoeff[i] = (Int)malloc(sei.m_horTapLengthMinus1[i] sizeof(Int));
1313	for(Int j = 0; j < sei.m_horTapLengthMinus1[i]; j ++)
1314	{
1315	sei_read_svlc( pDecodedMessageOutputStream, sei.m_horFilterCoeff[i][j], "hor_filter_coeff");
1316	}
1317	}
1318	}
1319	}
1320	}
1321	}
1322
1323	Void SEIReader::xParseSEIKneeFunctionInfo(SEIKneeFunctionInfo& sei, UInt payloadSize, std::ostream *pDecodedMessageOutputStream)
1324	{
1325	Int i;
1326	UInt val;
1327	output_sei_message_header(sei, pDecodedMessageOutputStream, payloadSize);
1328
1329	sei_read_uvlc( pDecodedMessageOutputStream, val, "knee_function_id" ); sei.m_kneeId = val;
1330	sei_read_flag( pDecodedMessageOutputStream, val, "knee_function_cancel_flag" ); sei.m_kneeCancelFlag = val;
1331	if ( !sei.m_kneeCancelFlag )
1332	{
1333	sei_read_flag( pDecodedMessageOutputStream, val, "knee_function_persistence_flag" ); sei.m_kneePersistenceFlag = val;
1334	sei_read_code( pDecodedMessageOutputStream, 32, val, "input_d_range" ); sei.m_kneeInputDrange = val;
1335	sei_read_code( pDecodedMessageOutputStream, 32, val, "input_disp_luminance" ); sei.m_kneeInputDispLuminance = val;
1336	sei_read_code( pDecodedMessageOutputStream, 32, val, "output_d_range" ); sei.m_kneeOutputDrange = val;
1337	sei_read_code( pDecodedMessageOutputStream, 32, val, "output_disp_luminance" ); sei.m_kneeOutputDispLuminance = val;
1338	sei_read_uvlc( pDecodedMessageOutputStream, val, "num_knee_points_minus1" ); sei.m_kneeNumKneePointsMinus1 = val;
1339	assert( sei.m_kneeNumKneePointsMinus1 > 0 );
1340	sei.m_kneeInputKneePoint.resize(sei.m_kneeNumKneePointsMinus1+1);
1341	sei.m_kneeOutputKneePoint.resize(sei.m_kneeNumKneePointsMinus1+1);
1342	for(i = 0; i <= sei.m_kneeNumKneePointsMinus1; i++ )
1343	{
1344	sei_read_code( pDecodedMessageOutputStream, 10, val, "input_knee_point" ); sei.m_kneeInputKneePoint[i] = val;
1345	sei_read_code( pDecodedMessageOutputStream, 10, val, "output_knee_point" ); sei.m_kneeOutputKneePoint[i] = val;
1346	}
1347	}
1348	}
1349
1350	Void SEIReader::xParseSEIMasteringDisplayColourVolume(SEIMasteringDisplayColourVolume& sei, UInt payloadSize, std::ostream *pDecodedMessageOutputStream)
1351	{
1352	UInt code;
1353	output_sei_message_header(sei, pDecodedMessageOutputStream, payloadSize);
1354
1355	sei_read_code( pDecodedMessageOutputStream, 16, code, "display_primaries_x[0]" ); sei.values.primaries[0][0] = code;
1356	sei_read_code( pDecodedMessageOutputStream, 16, code, "display_primaries_y[0]" ); sei.values.primaries[0][1] = code;
1357
1358	sei_read_code( pDecodedMessageOutputStream, 16, code, "display_primaries_x[1]" ); sei.values.primaries[1][0] = code;
1359	sei_read_code( pDecodedMessageOutputStream, 16, code, "display_primaries_y[1]" ); sei.values.primaries[1][1] = code;
1360
1361	sei_read_code( pDecodedMessageOutputStream, 16, code, "display_primaries_x[2]" ); sei.values.primaries[2][0] = code;
1362	sei_read_code( pDecodedMessageOutputStream, 16, code, "display_primaries_y[2]" ); sei.values.primaries[2][1] = code;
1363
1364
1365	sei_read_code( pDecodedMessageOutputStream, 16, code, "white_point_x" ); sei.values.whitePoint[0] = code;
1366	sei_read_code( pDecodedMessageOutputStream, 16, code, "white_point_y" ); sei.values.whitePoint[1] = code;
1367
1368	sei_read_code( pDecodedMessageOutputStream, 32, code, "max_display_mastering_luminance" ); sei.values.maxLuminance = code;
1369	sei_read_code( pDecodedMessageOutputStream, 32, code, "min_display_mastering_luminance" ); sei.values.minLuminance = code;
1370	}
1371
1372	#if Q0074_COLOUR_REMAPPING_SEI
1373	Void SEIReader::xParseSEIColourRemappingInfo(SEIColourRemappingInfo& sei, UInt /payloadSize/, std::ostream *pDecodedMessageOutputStream)
1374	{
1375	UInt uiVal;
1376	Int iVal;
1377
1378	sei_read_uvlc( pDecodedMessageOutputStream, uiVal, "colour_remap_id" ); sei.m_colourRemapId = uiVal;
1379	sei_read_flag( pDecodedMessageOutputStream, uiVal, "colour_remap_cancel_flag" ); sei.m_colourRemapCancelFlag = uiVal;
1380	if( !sei.m_colourRemapCancelFlag )
1381	{
1382	sei_read_flag( pDecodedMessageOutputStream, uiVal, "colour_remap_persistence_flag" ); sei.m_colourRemapPersistenceFlag = uiVal;
1383	sei_read_flag( pDecodedMessageOutputStream, uiVal, "colour_remap_video_signal_info_present_flag" ); sei.m_colourRemapVideoSignalInfoPresentFlag = uiVal;
1384	if ( sei.m_colourRemapVideoSignalInfoPresentFlag )
1385	{
1386	sei_read_flag( pDecodedMessageOutputStream, uiVal, "colour_remap_full_range_flag" ); sei.m_colourRemapFullRangeFlag = uiVal;
1387	sei_read_code( pDecodedMessageOutputStream, 8, uiVal, "colour_remap_primaries" ); sei.m_colourRemapPrimaries = uiVal;
1388	sei_read_code( pDecodedMessageOutputStream, 8, uiVal, "colour_remap_transfer_function" ); sei.m_colourRemapTransferFunction = uiVal;
1389	sei_read_code( pDecodedMessageOutputStream, 8, uiVal, "colour_remap_matrix_coefficients" ); sei.m_colourRemapMatrixCoefficients = uiVal;
1390	}
1391	sei_read_code( pDecodedMessageOutputStream, 8, uiVal, "colour_remap_input_bit_depth" ); sei.m_colourRemapInputBitDepth = uiVal;
1392	sei_read_code( pDecodedMessageOutputStream, 8, uiVal, "colour_remap_bit_depth" ); sei.m_colourRemapBitDepth = uiVal;
1393
1394	for( Int c=0 ; c<3 ; c++ )
1395	{
1396	sei_read_code( pDecodedMessageOutputStream, 8, uiVal, "pre_lut_num_val_minus1[c]" ); sei.m_preLutNumValMinus1[c] = (uiVal==0) ? 1 : uiVal;
1397	sei.m_preLutCodedValue[c].resize(sei.m_preLutNumValMinus1[c]+1);
1398	sei.m_preLutTargetValue[c].resize(sei.m_preLutNumValMinus1[c]+1);
1399	if( uiVal> 0 )
1400	for ( Int i=0 ; i<=sei.m_preLutNumValMinus1[c] ; i++ )
1401	{
1402	sei_read_code( pDecodedMessageOutputStream, (( sei.m_colourRemapInputBitDepth + 7 ) >> 3 ) << 3, uiVal, "pre_lut_coded_value[c][i]" ); sei.m_preLutCodedValue[c][i] = uiVal;
1403	sei_read_code( pDecodedMessageOutputStream, (( sei.m_colourRemapBitDepth + 7 ) >> 3 ) << 3, uiVal, "pre_lut_target_value[c][i]" ); sei.m_preLutTargetValue[c][i] = uiVal;
1404	}
1405	else // pre_lut_num_val_minus1[c] == 0
1406	{
1407	sei.m_preLutCodedValue[c][0] = 0;
1408	sei.m_preLutTargetValue[c][0] = 0;
1409	sei.m_preLutCodedValue[c][1] = (1 << sei.m_colourRemapInputBitDepth) - 1 ;
1410	sei.m_preLutTargetValue[c][1] = (1 << sei.m_colourRemapBitDepth) - 1 ;
1411	}
1412	}
1413
1414	sei_read_flag( pDecodedMessageOutputStream, uiVal, "colour_remap_matrix_present_flag" ); sei.m_colourRemapMatrixPresentFlag = uiVal;
1415	if( sei.m_colourRemapMatrixPresentFlag )
1416	{
1417	sei_read_code( pDecodedMessageOutputStream, 4, uiVal, "log2_matrix_denom" ); sei.m_log2MatrixDenom = uiVal;
1418	for ( Int c=0 ; c<3 ; c++ )
1419	for ( Int i=0 ; i<3 ; i++ )
1420	{
1421	sei_read_svlc( pDecodedMessageOutputStream, iVal, "colour_remap_coeffs[c][i]" ); sei.m_colourRemapCoeffs[c][i] = iVal;
1422	}
1423	}
1424	else // setting default matrix (I3)
1425	{
1426	sei.m_log2MatrixDenom = 0;
1427	for ( Int c=0 ; c<3 ; c++ )
1428	for ( Int i=0 ; i<3 ; i++ )
1429	sei.m_colourRemapCoeffs[c][i] = (c==i) ? 1 : 0;
1430	}
1431	for( Int c=0 ; c<3 ; c++ )
1432	{
1433	sei_read_code( pDecodedMessageOutputStream, 8, uiVal, "post_lut_num_val_minus1[c]" ); sei.m_postLutNumValMinus1[c] = (uiVal==0) ? 1 : uiVal;
1434	sei.m_postLutCodedValue[c].resize(sei.m_postLutNumValMinus1[c]+1);
1435	sei.m_postLutTargetValue[c].resize(sei.m_postLutNumValMinus1[c]+1);
1436	if( uiVal > 0 )
1437	for ( Int i=0 ; i<=sei.m_postLutNumValMinus1[c] ; i++ )
1438	{
1439	sei_read_code( pDecodedMessageOutputStream, (( sei.m_colourRemapBitDepth + 7 ) >> 3 ) << 3, uiVal, "post_lut_coded_value[c][i]" ); sei.m_postLutCodedValue[c][i] = uiVal;
1440	sei_read_code( pDecodedMessageOutputStream, (( sei.m_colourRemapBitDepth + 7 ) >> 3 ) << 3, uiVal, "post_lut_target_value[c][i]" ); sei.m_postLutTargetValue[c][i] = uiVal;
1441	}
1442	else
1443	{
1444	sei.m_postLutCodedValue[c][0] = 0;
1445	sei.m_postLutTargetValue[c][0] = 0;
1446	sei.m_postLutTargetValue[c][1] = (1 << sei.m_colourRemapBitDepth) - 1;
1447	sei.m_postLutCodedValue[c][1] = (1 << sei.m_colourRemapBitDepth) - 1;
1448	}
1449	}
1450	}
1451	}
1452	#endif
1453
1454
1455	#if SVC_EXTENSION
1456	#if LAYERS_NOT_PRESENT_SEI
1457	Void SEIReader::xParseSEILayersNotPresent(SEILayersNotPresent &sei, UInt payloadSize, const TComVPS vps, std::ostream pDecodedMessageOutputStream)
1458	{
1459	UInt uiCode;
1460	UInt i = 0;
1461
1462	sei_read_uvlc( pDecodedMessageOutputStream, uiCode, "lp_sei_active_vps_id" ); sei.m_activeVpsId = uiCode;
1463	assert(vps->getVPSId() == sei.m_activeVpsId);
1464	sei.m_vpsMaxLayers = vps->getMaxLayers();
1465	for (; i < sei.m_vpsMaxLayers; i++)
1466	{
1467	sei_read_flag( pDecodedMessageOutputStream, uiCode, "layer_not_present_flag" ); sei.m_layerNotPresentFlag[i] = uiCode ? true : false;
1468	}
1469	for (; i < MAX_LAYERS; i++)
1470	{
1471	sei.m_layerNotPresentFlag[i] = false;
1472	}
1473	}
1474	#endif
1475
1476	#if N0383_IL_CONSTRAINED_TILE_SETS_SEI
1477	Void SEIReader::xParseSEIInterLayerConstrainedTileSets (SEIInterLayerConstrainedTileSets &sei, UInt payloadSize, std::ostream *pDecodedMessageOutputStream)
1478	{
1479	UInt uiCode;
1480
1481	sei_read_flag( pDecodedMessageOutputStream, uiCode, "il_all_tiles_exact_sample_value_match_flag" ); sei.m_ilAllTilesExactSampleValueMatchFlag = uiCode;
1482	sei_read_flag( pDecodedMessageOutputStream, uiCode, "il_one_tile_per_tile_set_flag" ); sei.m_ilOneTilePerTileSetFlag = uiCode;
1483	if( !sei.m_ilOneTilePerTileSetFlag )
1484	{
1485	sei_read_uvlc( pDecodedMessageOutputStream, uiCode, "il_num_sets_in_message_minus1" ); sei.m_ilNumSetsInMessageMinus1 = uiCode;
1486	if( sei.m_ilNumSetsInMessageMinus1 )
1487	{
1488	sei_read_flag( pDecodedMessageOutputStream, uiCode, "skipped_tile_set_present_flag" ); sei.m_skippedTileSetPresentFlag = uiCode;
1489	}
1490	else
1491	{
1492	sei.m_skippedTileSetPresentFlag = false;
1493	}
1494	UInt numSignificantSets = sei.m_ilNumSetsInMessageMinus1 - (sei.m_skippedTileSetPresentFlag ? 1 : 0) + 1;
1495	for( UInt i = 0; i < numSignificantSets; i++ )
1496	{
1497	sei_read_uvlc( pDecodedMessageOutputStream, uiCode, "ilcts_id" ); sei.m_ilctsId[i] = uiCode;
1498	sei_read_uvlc( pDecodedMessageOutputStream, uiCode, "il_num_tile_rects_in_set_minus1" ) ;sei.m_ilNumTileRectsInSetMinus1[i] = uiCode;
1499	for( UInt j = 0; j <= sei.m_ilNumTileRectsInSetMinus1[i]; j++ )
1500	{
1501	sei_read_uvlc( pDecodedMessageOutputStream, uiCode, "il_top_left_tile_index" ); sei.m_ilTopLeftTileIndex[i][j] = uiCode;
1502	sei_read_uvlc( pDecodedMessageOutputStream, uiCode, "il_bottom_right_tile_index" ); sei.m_ilBottomRightTileIndex[i][j] = uiCode;
1503	}
1504	sei_read_code( pDecodedMessageOutputStream, 2, uiCode, "ilc_idc" ); sei.m_ilcIdc[i] = uiCode;
1505	if( sei.m_ilAllTilesExactSampleValueMatchFlag )
1506	{
1507	sei_read_flag( pDecodedMessageOutputStream, uiCode, "il_exact_sample_value_match_flag" ); sei.m_ilExactSampleValueMatchFlag[i] = uiCode;
1508	}
1509	}
1510	}
1511	else
1512	{
1513	sei_read_code( pDecodedMessageOutputStream, 2, uiCode, "all_tiles_ilc_idc" ); sei.m_allTilesIlcIdc = uiCode;
1514	}
1515	}
1516	#endif
1517
1518	#if SUB_BITSTREAM_PROPERTY_SEI
1519	Void SEIReader::xParseSEISubBitstreamProperty(SEISubBitstreamProperty &sei, const TComVPS vps, std::ostream pDecodedMessageOutputStream)
1520	{
1521	UInt uiCode;
1522	sei_read_code( pDecodedMessageOutputStream, 4, uiCode, "active_vps_id" ); sei.m_activeVpsId = uiCode;
1523	sei_read_uvlc( pDecodedMessageOutputStream, uiCode, "num_additional_sub_streams_minus1" ); sei.m_numAdditionalSubStreams = uiCode + 1;
1524
1525	for( Int i = 0; i < sei.m_numAdditionalSubStreams; i++ )
1526	{
1527	sei_read_code( pDecodedMessageOutputStream, 2, uiCode, "sub_bitstream_mode[i]" ); sei.m_subBitstreamMode[i] = uiCode;
1528	sei_read_uvlc( pDecodedMessageOutputStream, uiCode, "output_layer_set_idx_to_vps[i]" );
1529
1530	// The value of output_layer_set_idx_to_vps[ i ] shall be in the range of 0 to NumOutputLayerSets − 1, inclusive.
1531	assert(uiCode > 0 && uiCode <= vps->getNumOutputLayerSets()-1);
1532
1533	sei.m_outputLayerSetIdxToVps[i] = uiCode;
1534
1535	sei_read_code( pDecodedMessageOutputStream, 3, uiCode, "highest_sub_layer_id[i]" ); sei.m_highestSublayerId[i] = uiCode;
1536	sei_read_code( pDecodedMessageOutputStream, 16, uiCode, "avg_bit_rate[i]" ); sei.m_avgBitRate[i] = uiCode;
1537	sei_read_code( pDecodedMessageOutputStream, 16, uiCode, "max_bit_rate[i]" ); sei.m_maxBitRate[i] = uiCode;
1538	}
1539	}
1540	#endif
1541
1542	#if O0164_MULTI_LAYER_HRD
1543	#if LAYERS_NOT_PRESENT_SEI
1544	Void SEIReader::xParseSEIBspNesting(SEIBspNesting &sei, const NalUnitType nalUnitType, const TComVPS vps, const TComSPS sps, const SEIScalableNesting &nestingSei, std::ostream *pDecodedMessageOutputStream)
1545	#else
1546	Void SEIReader::xParseSEIBspNesting(SEIBspNesting &sei, const NalUnitType nalUnitType, const TComSPS sps, const SEIScalableNesting &nestingSei, std::ostream pDecodedMessageOutputStream)
1547	#endif
1548	{
1549	UInt uiCode;
1550	sei_read_uvlc( pDecodedMessageOutputStream, uiCode, "bsp_idx" ); sei.m_bspIdx = uiCode;
1551
1552	// byte alignment
1553	while ( m_pcBitstream->getNumBitsRead() % 8 != 0 )
1554	{
1555	UInt code;
1556	sei_read_flag( pDecodedMessageOutputStream, code, "bsp_nesting_zero_bit" );
1557	}
1558
1559	sei.m_callerOwnsSEIs = false;
1560
1561	// read nested SEI messages
1562	Int numSeiMessages = 0;
1563	sei_read_uvlc( pDecodedMessageOutputStream, uiCode, "num_seis_in_bsp_minus1" ); assert( uiCode <= MAX_SEIS_IN_BSP_NESTING );
1564	numSeiMessages = uiCode;
1565	for(Int i = 0; i < numSeiMessages; i++)
1566	{
1567	xReadSEImessage(sei.m_nestedSEIs, nalUnitType, vps, sps, pDecodedMessageOutputStream, &nestingSei, &sei);
1568	}
1569	}
1570
1571	Void SEIReader::xParseSEIBspInitialArrivalTime(SEIBspInitialArrivalTime &sei, const TComVPS vps, const TComSPS sps, const SEIScalableNesting &nestingSei, const SEIBspNesting &bspNestingSei, std::ostream *pDecodedMessageOutputStream)
1572	{
1573	assert(vps->getVpsVuiPresentFlag());
1574
1575	UInt uiCode;
1576	Int psIdx = bspNestingSei.m_seiPartitioningSchemeIdx;
1577	Int seiOlsIdx = bspNestingSei.m_seiOlsIdx;
1578	Int maxTemporalId = nestingSei.m_nestingMaxTemporalIdPlus1[0];
1579	Int maxValues = vps->getNumBspSchedulesMinus1(seiOlsIdx, psIdx, maxTemporalId) + 1;
1580	std::vector<Int> hrdIdx(0, maxValues);
1581	std::vector<const TComHRD*> hrdVec;
1582	std::vector<Int> syntaxElemLen;
1583	for(Int i = 0; i < maxValues; i++)
1584	{
1585	hrdIdx[i] = vps->getBspHrdIdx( seiOlsIdx, psIdx, maxTemporalId, i, bspNestingSei.m_bspIdx);
1586	hrdVec[i] = vps->getBspHrd(hrdIdx[i]);
1587
1588	syntaxElemLen[i] = hrdVec[i]->getInitialCpbRemovalDelayLengthMinus1() + 1;
1589	if ( !(hrdVec[i]->getNalHrdParametersPresentFlag() \|\| hrdVec[i]->getVclHrdParametersPresentFlag()) )
1590	{
1591	assert( syntaxElemLen[i] == 24 ); // Default value of init_cpb_removal_delay_length_minus1 is 23
1592	}
1593	if( i > 0 )
1594	{
1595	assert( hrdVec[i]->getNalHrdParametersPresentFlag() == hrdVec[i-1]->getNalHrdParametersPresentFlag() );
1596	assert( hrdVec[i]->getVclHrdParametersPresentFlag() == hrdVec[i-1]->getVclHrdParametersPresentFlag() );
1597	}
1598	}
1599	if (hrdVec[0]->getNalHrdParametersPresentFlag())
1600	{
1601	for(UInt i = 0; i < maxValues; i++)
1602	{
1603	sei_read_code( pDecodedMessageOutputStream, syntaxElemLen[i], uiCode, "nal_initial_arrival_delay[i]" ); sei.m_nalInitialArrivalDelay[i] = uiCode;
1604	}
1605	}
1606	if( hrdVec[0]->getVclHrdParametersPresentFlag() )
1607	{
1608	for(UInt i = 0; i < maxValues; i++)
1609	{
1610	sei_read_code( pDecodedMessageOutputStream, syntaxElemLen[i], uiCode, "vcl_initial_arrival_delay[i]" ); sei.m_vclInitialArrivalDelay[i] = uiCode;
1611	}
1612	}
1613	}
1614
1615	Void SEIReader::xParseHrdParameters(TComHRD hrd, Bool commonInfPresentFlag, UInt maxNumSubLayersMinus1, std::ostream pDecodedMessageOutputStream)
1616	{
1617	UInt uiCode;
1618	if( commonInfPresentFlag )
1619	{
1620	sei_read_flag( pDecodedMessageOutputStream, uiCode, "nal_hrd_parameters_present_flag" ); hrd->setNalHrdParametersPresentFlag( uiCode == 1 ? true : false );
1621	sei_read_flag( pDecodedMessageOutputStream, uiCode, "vcl_hrd_parameters_present_flag" ); hrd->setVclHrdParametersPresentFlag( uiCode == 1 ? true : false );
1622	if( hrd->getNalHrdParametersPresentFlag() \|\| hrd->getVclHrdParametersPresentFlag() )
1623	{
1624	sei_read_flag( pDecodedMessageOutputStream, uiCode, "sub_pic_cpb_params_present_flag" ); hrd->setSubPicCpbParamsPresentFlag( uiCode == 1 ? true : false );
1625	if( hrd->getSubPicCpbParamsPresentFlag() )
1626	{
1627	sei_read_code( pDecodedMessageOutputStream, 8, uiCode, "tick_divisor_minus2" ); hrd->setTickDivisorMinus2( uiCode );
1628	sei_read_code( pDecodedMessageOutputStream, 5, uiCode, "du_cpb_removal_delay_length_minus1" ); hrd->setDuCpbRemovalDelayLengthMinus1( uiCode );
1629	sei_read_flag( pDecodedMessageOutputStream, uiCode, "sub_pic_cpb_params_in_pic_timing_sei_flag" ); hrd->setSubPicCpbParamsInPicTimingSEIFlag( uiCode == 1 ? true : false );
1630	sei_read_code( pDecodedMessageOutputStream, 5, uiCode, "dpb_output_delay_du_length_minus1" ); hrd->setDpbOutputDelayDuLengthMinus1( uiCode );
1631	}
1632	sei_read_code( pDecodedMessageOutputStream, 4, uiCode, "bit_rate_scale" ); hrd->setBitRateScale( uiCode );
1633	sei_read_code( pDecodedMessageOutputStream, 4, uiCode, "cpb_size_scale" ); hrd->setCpbSizeScale( uiCode );
1634	if( hrd->getSubPicCpbParamsPresentFlag() )
1635	{
1636	sei_read_code( pDecodedMessageOutputStream, 4, uiCode, "cpb_size_du_scale" ); hrd->setDuCpbSizeScale( uiCode );
1637	}
1638	sei_read_code( pDecodedMessageOutputStream, 5, uiCode, "initial_cpb_removal_delay_length_minus1" ); hrd->setInitialCpbRemovalDelayLengthMinus1( uiCode );
1639	sei_read_code( pDecodedMessageOutputStream, 5, uiCode, "au_cpb_removal_delay_length_minus1" ); hrd->setCpbRemovalDelayLengthMinus1( uiCode );
1640	sei_read_code( pDecodedMessageOutputStream, 5, uiCode, "dpb_output_delay_length_minus1" ); hrd->setDpbOutputDelayLengthMinus1( uiCode );
1641	}
1642	}
1643	Int i, j, nalOrVcl;
1644	for( i = 0; i <= maxNumSubLayersMinus1; i ++ )
1645	{
1646	sei_read_flag( pDecodedMessageOutputStream, uiCode, "fixed_pic_rate_general_flag" ); hrd->setFixedPicRateFlag( i, uiCode == 1 ? true : false );
1647	if( !hrd->getFixedPicRateFlag( i ) )
1648	{
1649	sei_read_flag( pDecodedMessageOutputStream, uiCode, "fixed_pic_rate_within_cvs_flag" ); hrd->setFixedPicRateWithinCvsFlag( i, uiCode == 1 ? true : false );
1650	}
1651	else
1652	{
1653	hrd->setFixedPicRateWithinCvsFlag( i, true );
1654	}
1655	hrd->setLowDelayHrdFlag( i, 0 ); // Infered to be 0 when not present
1656	hrd->setCpbCntMinus1 ( i, 0 ); // Infered to be 0 when not present
1657	if( hrd->getFixedPicRateWithinCvsFlag( i ) )
1658	{
1659	sei_read_uvlc( pDecodedMessageOutputStream, uiCode, "elemental_duration_in_tc_minus1" ); hrd->setPicDurationInTcMinus1( i, uiCode );
1660	}
1661	else
1662	{
1663	sei_read_flag( pDecodedMessageOutputStream, uiCode, "low_delay_hrd_flag" ); hrd->setLowDelayHrdFlag( i, uiCode == 1 ? true : false );
1664	}
1665	if (!hrd->getLowDelayHrdFlag( i ))
1666	{
1667	sei_read_uvlc( pDecodedMessageOutputStream, uiCode, "cpb_cnt_minus1" ); hrd->setCpbCntMinus1( i, uiCode );
1668	}
1669	for( nalOrVcl = 0; nalOrVcl < 2; nalOrVcl ++ )
1670	{
1671	if( ( ( nalOrVcl == 0 ) && ( hrd->getNalHrdParametersPresentFlag() ) ) \|\|
1672	( ( nalOrVcl == 1 ) && ( hrd->getVclHrdParametersPresentFlag() ) ) )
1673	{
1674	for( j = 0; j <= ( hrd->getCpbCntMinus1( i ) ); j ++ )
1675	{
1676	sei_read_uvlc( pDecodedMessageOutputStream, uiCode, "bit_rate_value_minus1" ); hrd->setBitRateValueMinus1( i, j, nalOrVcl, uiCode );
1677	sei_read_uvlc( pDecodedMessageOutputStream, uiCode, "cpb_size_value_minus1" ); hrd->setCpbSizeValueMinus1( i, j, nalOrVcl, uiCode );
1678	if( hrd->getSubPicCpbParamsPresentFlag() )
1679	{
1680	sei_read_uvlc( pDecodedMessageOutputStream, uiCode, "cpb_size_du_value_minus1" ); hrd->setDuCpbSizeValueMinus1( i, j, nalOrVcl, uiCode );
1681	sei_read_uvlc( pDecodedMessageOutputStream, uiCode, "bit_rate_du_value_minus1" ); hrd->setDuBitRateValueMinus1( i, j, nalOrVcl, uiCode );
1682	}
1683	sei_read_flag( pDecodedMessageOutputStream, uiCode, "cbr_flag" ); hrd->setCbrFlag( i, j, nalOrVcl, uiCode == 1 ? true : false );
1684	}
1685	}
1686	}
1687	}
1688	}
1689	#endif
1690
1691	#if P0123_ALPHA_CHANNEL_SEI
1692	void SEIReader::xParseSEIAlphaChannelInfo(SEIAlphaChannelInfo &sei, UInt payloadSize, std::ostream *pDecodedMessageOutputStream)
1693	{
1694	UInt value;
1695	sei_read_flag(pDecodedMessageOutputStream, value, "alpha_channel_cancel_flag"); sei.m_alphaChannelCancelFlag = value;
1696	if(!sei.m_alphaChannelCancelFlag)
1697	{
1698	sei_read_code(pDecodedMessageOutputStream, 3, value, "alpha_channel_use_idc"); sei.m_alphaChannelUseIdc = value;
1699	sei_read_code(pDecodedMessageOutputStream, 3, value, "alpha_channel_bit_depth_minus8"); sei.m_alphaChannelBitDepthMinus8 = value;
1700	sei_read_code(pDecodedMessageOutputStream, sei.m_alphaChannelBitDepthMinus8 + 9, value, "alpha_transparent_value"); sei.m_alphaTransparentValue = value;
1701	sei_read_code(pDecodedMessageOutputStream, sei.m_alphaChannelBitDepthMinus8 + 9, value, "alpha_opaque_value"); sei.m_alphaOpaqueValue = value;
1702	sei_read_flag(pDecodedMessageOutputStream, value, "alpha_channel_incr_flag"); sei.m_alphaChannelIncrFlag = value;
1703	sei_read_flag(pDecodedMessageOutputStream, value, "alpha_channel_clip_flag"); sei.m_alphaChannelClipFlag = value;
1704	if(sei.m_alphaChannelClipFlag)
1705	{
1706	sei_read_flag(pDecodedMessageOutputStream, value, "alpha_channel_clip_type_flag"); sei.m_alphaChannelClipTypeFlag = value;
1707	}
1708	}
1709	}
1710	#endif
1711
1712	#if Q0096_OVERLAY_SEI
1713	Void SEIReader::xParseSEIOverlayInfo(SEIOverlayInfo& sei, UInt /payloadSize/, std::ostream *pDecodedMessageOutputStream)
1714	{
1715	Int i, j;
1716	UInt val;
1717	sei_read_flag( pDecodedMessageOutputStream, val, "overlay_info_cancel_flag" ); sei.m_overlayInfoCancelFlag = val;
1718	if ( !sei.m_overlayInfoCancelFlag )
1719	{
1720	sei_read_uvlc( pDecodedMessageOutputStream, val, "overlay_content_aux_id_minus128" ); sei.m_overlayContentAuxIdMinus128 = val;
1721	sei_read_uvlc( pDecodedMessageOutputStream, val, "overlay_label_aux_id_minus128" ); sei.m_overlayLabelAuxIdMinus128 = val;
1722	sei_read_uvlc( pDecodedMessageOutputStream, val, "overlay_alpha_aux_id_minus128" ); sei.m_overlayAlphaAuxIdMinus128 = val;
1723	sei_read_uvlc( pDecodedMessageOutputStream, val, "overlay_element_label_value_length_minus8" ); sei.m_overlayElementLabelValueLengthMinus8 = val;
1724	sei_read_uvlc( pDecodedMessageOutputStream, val, "num_overlays_minus1" ); sei.m_numOverlaysMinus1 = val;
1725
1726	assert( sei.m_numOverlaysMinus1 < MAX_OVERLAYS );
1727	sei.m_overlayIdx.resize( sei.m_numOverlaysMinus1+1 );
1728	sei.m_languageOverlayPresentFlag.resize( sei.m_numOverlaysMinus1+1 );
1729	sei.m_overlayContentLayerId.resize( sei.m_numOverlaysMinus1+1 );
1730	sei.m_overlayLabelPresentFlag.resize( sei.m_numOverlaysMinus1+1 );
1731	sei.m_overlayLabelLayerId.resize( sei.m_numOverlaysMinus1+1 );
1732	sei.m_overlayAlphaPresentFlag.resize( sei.m_numOverlaysMinus1+1 );
1733	sei.m_overlayAlphaLayerId.resize( sei.m_numOverlaysMinus1+1 );
1734	sei.m_numOverlayElementsMinus1.resize( sei.m_numOverlaysMinus1+1 );
1735	sei.m_overlayElementLabelMin.resize( sei.m_numOverlaysMinus1+1 );
1736	sei.m_overlayElementLabelMax.resize( sei.m_numOverlaysMinus1+1 );
1737	for ( i=0 ; i<=sei.m_numOverlaysMinus1 ; i++ )
1738	{
1739	sei_read_uvlc( pDecodedMessageOutputStream, val, "overlay_idx" ); sei.m_overlayIdx[i] = val;
1740	sei_read_flag( pDecodedMessageOutputStream, val, "language_overlay_present_flag" ); sei.m_languageOverlayPresentFlag[i] = val;
1741	sei_read_code( pDecodedMessageOutputStream, 6, val, "overlay_content_layer_id"); sei.m_overlayContentLayerId[i] = val;
1742	sei_read_flag( pDecodedMessageOutputStream, val, "overlay_label_present_flag" ); sei.m_overlayLabelPresentFlag[i] = val;
1743	if ( sei.m_overlayLabelPresentFlag[i] )
1744	{
1745	sei_read_code( pDecodedMessageOutputStream, 6, val, "overlay_label_layer_id"); sei.m_overlayLabelLayerId[i] = val;
1746	}
1747	sei_read_flag( pDecodedMessageOutputStream, val, "overlay_alpha_present_flag" ); sei.m_overlayAlphaPresentFlag[i] = val;
1748	if ( sei.m_overlayAlphaPresentFlag[i] )
1749	{
1750	sei_read_code( pDecodedMessageOutputStream, 6, val, "overlay_alpha_layer_id"); sei.m_overlayAlphaLayerId[i] = val;
1751	}
1752	if ( sei.m_overlayLabelPresentFlag[i] )
1753	{
1754	sei_read_uvlc( pDecodedMessageOutputStream, val, "num_overlay_elements_minus1"); sei.m_numOverlayElementsMinus1[i] = val;
1755	assert( sei.m_numOverlayElementsMinus1[i] < MAX_OVERLAY_ELEMENTS );
1756	sei.m_overlayElementLabelMin[i].resize( sei.m_numOverlayElementsMinus1[i]+1 );
1757	sei.m_overlayElementLabelMax[i].resize( sei.m_numOverlayElementsMinus1[i]+1 );
1758	for ( j=0 ; j<=sei.m_numOverlayElementsMinus1[i] ; j++ )
1759	{
1760	sei_read_code( pDecodedMessageOutputStream, sei.m_overlayElementLabelValueLengthMinus8 + 8, val, "overlay_element_label_min"); sei.m_overlayElementLabelMin[i][j] = val;
1761	sei_read_code( pDecodedMessageOutputStream, sei.m_overlayElementLabelValueLengthMinus8 + 8, val, "overlay_element_label_max"); sei.m_overlayElementLabelMax[i][j] = val;
1762	}
1763	}
1764	else
1765	{
1766	sei.m_numOverlayElementsMinus1[i] = 0;
1767	}
1768	}
1769
1770	// byte alignment
1771	while ( m_pcBitstream->getNumBitsRead() % 8 != 0 )
1772	{
1773	sei_read_flag( pDecodedMessageOutputStream, val, "overlay_zero_bit" );
1774	assert( val==0 );
1775	}
1776
1777	UChar* sval = new UChar[MAX_OVERLAY_STRING_BYTES];
1778	UInt slen;
1779	sei.m_overlayLanguage.resize( sei.m_numOverlaysMinus1+1, NULL );
1780	sei.m_overlayLanguageLength.resize( sei.m_numOverlaysMinus1+1 );
1781	sei.m_overlayName.resize( sei.m_numOverlaysMinus1+1, NULL );
1782	sei.m_overlayNameLength.resize( sei.m_numOverlaysMinus1+1 );
1783	sei.m_overlayElementName.resize( sei.m_numOverlaysMinus1+1 );
1784	sei.m_overlayElementNameLength.resize( sei.m_numOverlaysMinus1+1 );
1785	for ( i=0 ; i<=sei.m_numOverlaysMinus1 ; i++ )
1786	{
1787	if ( sei.m_languageOverlayPresentFlag[i] )
1788	{
1789	READ_STRING( MAX_OVERLAY_STRING_BYTES, sval, slen, "overlay_language" );
1790	sei.m_overlayLanguage[i] = new UChar[slen];
1791	memcpy(sei.m_overlayLanguage[i], sval, slen);
1792	sei.m_overlayLanguageLength[i] = slen;
1793	}
1794	READ_STRING( MAX_OVERLAY_STRING_BYTES, sval, slen, "overlay_name" );
1795	sei.m_overlayName[i] = new UChar[slen];
1796	memcpy(sei.m_overlayName[i], sval, slen);
1797	sei.m_overlayNameLength[i] = slen;
1798	if ( sei.m_overlayLabelPresentFlag[i] )
1799	{
1800	sei.m_overlayElementName[i].resize( sei.m_numOverlayElementsMinus1[i]+1, NULL );
1801	sei.m_overlayElementNameLength[i].resize( sei.m_numOverlayElementsMinus1[i]+1 );
1802	for ( j=0 ; j<=sei.m_numOverlayElementsMinus1[i] ; j++)
1803	{
1804	READ_STRING( MAX_OVERLAY_STRING_BYTES, sval, slen, "overlay_element_name" );
1805	sei.m_overlayElementName[i][j] = new UChar[slen];
1806	memcpy(sei.m_overlayElementName[i][j], sval, slen);
1807	sei.m_overlayElementNameLength[i][j] = slen;
1808	}
1809	}
1810	}
1811	sei_read_flag( pDecodedMessageOutputStream, val, "overlay_info_persistence_flag" ); sei.m_overlayInfoPersistenceFlag = val;
1812	}
1813	}
1814	#endif
1815
1816	#if P0138_USE_ALT_CPB_PARAMS_FLAG
1817	/**
1818	* Check if SEI message contains payload extension
1819	*/
1820	Bool SEIReader::xPayloadExtensionPresent()
1821	{
1822	Int payloadBitsRemaining = getBitstream()->getNumBitsLeft();
1823	Bool payloadExtensionPresent = false;
1824
1825	if (payloadBitsRemaining > 8)
1826	{
1827	payloadExtensionPresent = true;
1828	}
1829	else
1830	{
1831	Int finalBits = getBitstream()->peekBits(payloadBitsRemaining);
1832	while (payloadBitsRemaining && (finalBits & 1) == 0)
1833	{
1834	payloadBitsRemaining--;
1835	finalBits >>= 1;
1836	}
1837	payloadBitsRemaining--;
1838	if (payloadBitsRemaining > 0)
1839	{
1840	payloadExtensionPresent = true;
1841	}
1842	}
1843
1844	return payloadExtensionPresent;
1845	}
1846	#endif
1847
1848	#if Q0189_TMVP_CONSTRAINTS
1849	Void SEIReader::xParseSEITMVPConstraints (SEITMVPConstrains& sei, UInt payloadSize, std::ostream *pDecodedMessageOutputStream)
1850	{
1851	UInt uiCode;
1852	sei_read_uvlc( pDecodedMessageOutputStream, uiCode, "prev_pics_not_used_flag" ); sei.prev_pics_not_used_flag = uiCode;
1853	sei_read_uvlc( pDecodedMessageOutputStream, uiCode, "no_intra_layer_col_pic_flag" ); sei.no_intra_layer_col_pic_flag = uiCode;
1854	}
1855	#endif
1856
1857	#if Q0247_FRAME_FIELD_INFO
1858	Void SEIReader::xParseSEIFrameFieldInfo (SEIFrameFieldInfo& sei, UInt payloadSize, std::ostream *pDecodedMessageOutputStream)
1859	{
1860	UInt code;
1861	sei_read_code( pDecodedMessageOutputStream, 4, code, "ffinfo_pic_struct" ); sei.m_ffinfo_picStruct = code;
1862	sei_read_code( pDecodedMessageOutputStream, 2, code, "ffinfo_source_scan_type" ); sei.m_ffinfo_sourceScanType = code;
1863	sei_read_flag( pDecodedMessageOutputStream, code, "ffinfo_duplicate_flag" ); sei.m_ffinfo_duplicateFlag = ( code == 1 ? true : false );
1864	}
1865	#endif
1866
1867
1868	#endif //SVC_EXTENSION
1869
1870	//! \}

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

Download in other formats: