1 /* Copyright (c) MediaArea.net SARL. All Rights Reserved.
2 *
3 * Use of this source code is governed by a BSD-style license that can
4 * be found in the License.html file in the root of the source tree.
5 */
6
7 //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
8 //
9 // Contributor: Lionel Duchateau, kurtnoise@free.fr
10 //
11 //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
12
13 //---------------------------------------------------------------------------
14 // Pre-compilation
15 #include "MediaInfo/PreComp.h"
16 #ifdef __BORLANDC__
17 #pragma hdrstop
18 #endif
19 //---------------------------------------------------------------------------
20
21 //---------------------------------------------------------------------------
22 #include "MediaInfo/Setup.h"
23 using namespace ZenLib;
24 //---------------------------------------------------------------------------
25
26 //---------------------------------------------------------------------------
27 #if defined(MEDIAINFO_MPEGPS_YES) || defined(MEDIAINFO_MPEGTS_YES) || defined(MEDIAINFO_HEVC_YES)
28 //---------------------------------------------------------------------------
29
30 namespace MediaInfoLib
31 {
32
33 //---------------------------------------------------------------------------
Hevc_tier_flag(bool tier_flag)34 extern const char* Hevc_tier_flag(bool tier_flag)
35 {
36 return tier_flag ? "High" : "Main";
37 }
38
39 //---------------------------------------------------------------------------
Hevc_profile_idc(int32u profile_idc)40 extern const char* Hevc_profile_idc(int32u profile_idc)
41 {
42 switch (profile_idc)
43 {
44 case 1 : return "Main";
45 case 2 : return "Main 10";
46 case 3 : return "Main Still";
47 case 4 : return "Format Range"; // extensions
48 case 5 : return "High Throughput";
49 case 6 : return "Multiview Main";
50 case 7 : return "Scalable Main"; // can be "Scalable Main 10" depending on general_max_8bit_constraint_flag
51 case 8 : return "3D Main";
52 case 9 : return "Screen Content"; // coding extensions
53 case 10 : return "Scalable Format Range"; // extensions
54 default : return "";
55 }
56 }
57
58 } //NameSpace
59
60 //---------------------------------------------------------------------------
61 #endif //...
62 //---------------------------------------------------------------------------
63
64 //---------------------------------------------------------------------------
65 #if defined(MEDIAINFO_HEVC_YES)
66 //---------------------------------------------------------------------------
67
68 //---------------------------------------------------------------------------
69 #include "MediaInfo/Video/File_Hevc.h"
70 #if defined(MEDIAINFO_DTVCCTRANSPORT_YES)
71 #include "MediaInfo/Text/File_DtvccTransport.h"
72 #endif //defined(MEDIAINFO_DTVCCTRANSPORT_YES)
73 #include <cmath>
74 #include <algorithm>
75 #include "MediaInfo/MediaInfo_Config_MediaInfo.h"
76 #if MEDIAINFO_EVENTS
77 #include "MediaInfo/MediaInfo_Config_PerPackage.h"
78 #include "MediaInfo/MediaInfo_Events.h"
79 #include "MediaInfo/MediaInfo_Events_Internal.h"
80 #endif //MEDIAINFO_EVENTS
81 using namespace std;
82 //---------------------------------------------------------------------------
83
84 namespace MediaInfoLib
85 {
86
87 //***************************************************************************
88 // Info
89 //***************************************************************************
90
91 //---------------------------------------------------------------------------
92 static const int8u Hevc_SubWidthC[]=
93 {
94 1,
95 2,
96 2,
97 1,
98 };
99
100 //---------------------------------------------------------------------------
101 static const int8u Hevc_SubHeightC[]=
102 {
103 1,
104 2,
105 1,
106 1,
107 };
108
109 //---------------------------------------------------------------------------
Hevc_chroma_format_idc(int8u chroma_format_idc)110 static const char* Hevc_chroma_format_idc(int8u chroma_format_idc)
111 {
112 switch (chroma_format_idc)
113 {
114 case 1: return "4:2:0";
115 case 2: return "4:2:2";
116 case 3: return "4:4:4";
117 default: return "";
118 }
119 }
120
121 //---------------------------------------------------------------------------
Hevc_chroma_format_idc_ColorSpace(int8u chroma_format_idc)122 static const char* Hevc_chroma_format_idc_ColorSpace(int8u chroma_format_idc)
123 {
124 switch (chroma_format_idc)
125 {
126 case 0: return "Y";
127 case 1: return "YUV";
128 case 2: return "YUV";
129 default: return "";
130 }
131 }
132
133 //---------------------------------------------------------------------------
134 static const char* Hevc_pic_type[]=
135 {
136 "I",
137 "I, P",
138 "I, P, B",
139 "",
140 "",
141 "",
142 "",
143 "",
144 "",
145 "",
146 };
147
148 //---------------------------------------------------------------------------
Hevc_slice_type(int32u slice_type)149 static const char* Hevc_slice_type(int32u slice_type)
150 {
151 switch (slice_type)
152 {
153 case 0 : return "P";
154 case 1 : return "B";
155 case 2 : return "I";
156 default: return "";
157 }
158 };
159
160 //---------------------------------------------------------------------------
161 extern const char* Mpegv_colour_primaries(int8u colour_primaries);
162 extern const char* Mpegv_transfer_characteristics(int8u transfer_characteristics);
163 extern const char* Mpegv_matrix_coefficients(int8u matrix_coefficients);
164 const char* Mpegv_matrix_coefficients_ColorSpace(int8u matrix_coefficients);
165
166 //---------------------------------------------------------------------------
167 extern const int8u Avc_PixelAspectRatio_Size;
168 extern const float32 Avc_PixelAspectRatio[];
169 extern const char* Avc_video_format[];
170 extern const char* Avc_video_full_range[];
171
172 //***************************************************************************
173 // Constructor/Destructor
174 //***************************************************************************
175
176 //---------------------------------------------------------------------------
File_Hevc()177 File_Hevc::File_Hevc()
178 {
179 //Config
180 #if MEDIAINFO_EVENTS
181 ParserIDs[0]=MediaInfo_Parser_Hevc;
182 StreamIDs_Width[0]=0;
183 #endif //MEDIAINFO_EVENTS
184 #if MEDIAINFO_TRACE
185 Trace_Layers_Update(8); //Stream
186 #endif //MEDIAINFO_TRACE
187 MustSynchronize=true;
188 Buffer_TotalBytes_FirstSynched_Max=64*1024;
189 PTS_DTS_Needed=true;
190 StreamSource=IsStream;
191 Frame_Count_NotParsedIncluded=0;
192
193 //In
194 Frame_Count_Valid=0;
195 FrameIsAlwaysComplete=false;
196 MustParse_VPS_SPS_PPS=false;
197 MustParse_VPS_SPS_PPS_FromMatroska=false;
198 MustParse_VPS_SPS_PPS_FromFlv=false;
199 SizedBlocks=false;
200 SizedBlocks_FileThenStream=0;
201
202 //File specific
203 lengthSizeMinusOne=(int8u)-1;
204
205 //Specific
206 RiskCalculationN=0;
207 RiskCalculationD=0;
208
209 //Temporal references
210 TemporalReferences_DelayedElement=NULL;
211 TemporalReferences_Min=0;
212 TemporalReferences_Max=0;
213 TemporalReferences_Reserved=0;
214 TemporalReferences_Offset=0;
215 TemporalReferences_Offset_pic_order_cnt_lsb_Last=0;
216 TemporalReferences_pic_order_cnt_Min=0;
217 pic_order_cnt_DTS_Ref=(int64u)-1;
218
219 //Text
220 #if defined(MEDIAINFO_DTVCCTRANSPORT_YES)
221 GA94_03_IsPresent=false;
222 GA94_03_Parser=NULL;
223 #endif //defined(MEDIAINFO_DTVCCTRANSPORT_YES)
224 }
225
226 //---------------------------------------------------------------------------
~File_Hevc()227 File_Hevc::~File_Hevc()
228 {
229 Clean_Seq_Parameter();
230 Clean_Temp_References();
231 #if defined(MEDIAINFO_DTVCCTRANSPORT_YES)
232 delete GA94_03_Parser; //GA94_03_Parser=NULL;
233 #endif //defined(MEDIAINFO_DTVCCTRANSPORT_YES)
234 }
235 //---------------------------------------------------------------------------
Clean_Seq_Parameter()236 void File_Hevc::Clean_Seq_Parameter()
237 {
238 for (size_t Pos = 0; Pos < seq_parameter_sets.size(); Pos++)
239 delete seq_parameter_sets[Pos]; //seq_parameter_sets[Pos]=NULL;
240 seq_parameter_sets.clear();
241 for (size_t Pos = 0; Pos<pic_parameter_sets.size(); Pos++)
242 delete pic_parameter_sets[Pos]; //pic_parameter_sets[Pos]=NULL;
243 pic_parameter_sets.clear();
244 for (size_t Pos = 0; Pos<video_parameter_sets.size(); Pos++)
245 delete video_parameter_sets[Pos]; //video_parameter_sets[Pos]=NULL;
246 video_parameter_sets.clear();
247
248 }
249
250 //---------------------------------------------------------------------------
Clean_Temp_References()251 void File_Hevc::Clean_Temp_References()
252 {
253 for (size_t Pos = 0; Pos<TemporalReferences.size(); Pos++)
254 delete TemporalReferences[Pos]; //TemporalReferences[Pos]=NULL;
255 TemporalReferences.clear();
256 pic_order_cnt_DTS_Ref=(int64u)-1;
257 }
258
259 //***************************************************************************
260 // Streams management
261 //***************************************************************************
262
263 //---------------------------------------------------------------------------
Streams_Fill()264 void File_Hevc::Streams_Fill()
265 {
266 if (MustParse_VPS_SPS_PPS_FromFlv)
267 return;
268
269 if (Count_Get(Stream_Video)==0)
270 Stream_Prepare(Stream_Video);
271 Fill(Stream_Video, 0, Video_Format, "HEVC");
272 Fill(Stream_Video, 0, Video_Codec, "HEVC");
273
274 for (std::vector<seq_parameter_set_struct*>::iterator seq_parameter_set_Item=seq_parameter_sets.begin(); seq_parameter_set_Item!=seq_parameter_sets.end(); ++seq_parameter_set_Item)
275 if ((*seq_parameter_set_Item))
276 Streams_Fill(seq_parameter_set_Item);
277
278 //Library name
279 Fill(Stream_General, 0, General_Encoded_Library, Encoded_Library);
280 Fill(Stream_General, 0, General_Encoded_Library_Name, Encoded_Library_Name);
281 Fill(Stream_General, 0, General_Encoded_Library_Version, Encoded_Library_Version);
282 Fill(Stream_General, 0, General_Encoded_Library_Settings, Encoded_Library_Settings);
283 Fill(Stream_Video, 0, Video_Encoded_Library, Encoded_Library);
284 Fill(Stream_Video, 0, Video_Encoded_Library_Name, Encoded_Library_Name);
285 Fill(Stream_Video, 0, Video_Encoded_Library_Version, Encoded_Library_Version);
286 Fill(Stream_Video, 0, Video_Encoded_Library_Settings, Encoded_Library_Settings);
287 hdr::iterator EtsiTs103433=HDR.find(HdrFormat_EtsiTs103433);
288 if (EtsiTs103433!=HDR.end())
289 {
290 for (std::map<video, Ztring>::iterator Item=EtsiTs103433->second.begin(); Item!=EtsiTs103433->second.end(); ++Item)
291 {
292 Fill(Stream_Video, 0, Item->first, Item->second);
293 }
294 }
295 hdr::iterator SmpteSt209440=HDR.find(HdrFormat_SmpteSt209440);
296 if (SmpteSt209440!=HDR.end())
297 {
298 for (std::map<video, Ztring>::iterator Item=SmpteSt209440->second.begin(); Item!=SmpteSt209440->second.end(); ++Item)
299 {
300 switch (Item->first)
301 {
302 case Video_MasteringDisplay_ColorPrimaries:
303 case Video_MasteringDisplay_Luminance:
304 if (Retrieve_Const(Stream_Video, 0, Item->first)==Item->second)
305 break;
306 // Fallthrough
307 default:
308 Fill(Stream_Video, 0, Item->first, Item->second);
309 }
310 }
311 }
312 hdr::iterator SmpteSt2086=HDR.find(HdrFormat_SmpteSt2086);
313 if (SmpteSt2086!=HDR.end())
314 {
315 for (std::map<video, Ztring>::iterator Item=SmpteSt2086->second.begin(); Item!=SmpteSt2086->second.end(); ++Item)
316 {
317 bool Ignore;
318 switch (Item->first)
319 {
320 case Video_HDR_Format:
321 Ignore=!Retrieve_Const(Stream_Video, 0, Item->first).empty();
322 break;
323 case Video_MasteringDisplay_ColorPrimaries:
324 case Video_MasteringDisplay_Luminance:
325 Ignore=Retrieve_Const(Stream_Video, 0, Item->first)==Item->second;
326 break;
327 default:
328 Ignore=false;
329 }
330 if (!Ignore)
331 Fill(Stream_Video, 0, Item->first, Item->second);
332 }
333 }
334 if (!EtsiTS103433.empty())
335 {
336 Fill(Stream_Video, 0, "EtsiTS103433", EtsiTS103433);
337 Fill_SetOptions(Stream_Video, 0, "EtsiTS103433", "N NTN");
338 }
339 if (maximum_content_light_level)
340 Fill(Stream_Video, 0, "MaxCLL", Ztring::ToZtring(maximum_content_light_level) + __T(" cd/m2"));
341 if (maximum_frame_average_light_level)
342 Fill(Stream_Video, 0, "MaxFALL", Ztring::ToZtring(maximum_frame_average_light_level) + __T(" cd/m2"));
343 if (chroma_sample_loc_type_top_field != (int32u)-1)
344 {
345 Fill(Stream_Video, 0, "ChromaSubsampling_Position", __T("Type ") + Ztring::ToZtring(chroma_sample_loc_type_top_field));
346 if (chroma_sample_loc_type_bottom_field != (int32u)-1 && chroma_sample_loc_type_bottom_field != chroma_sample_loc_type_top_field)
347 Fill(Stream_Video, 0, "ChromaSubsampling_Position", __T("Type ") + Ztring::ToZtring(chroma_sample_loc_type_bottom_field));
348 }
349 }
350
351 //---------------------------------------------------------------------------
Streams_Fill(std::vector<seq_parameter_set_struct * >::iterator seq_parameter_set_Item)352 void File_Hevc::Streams_Fill(std::vector<seq_parameter_set_struct*>::iterator seq_parameter_set_Item)
353 {
354 int32u Width = (*seq_parameter_set_Item)->pic_width_in_luma_samples;
355 int32u Height= (*seq_parameter_set_Item)->pic_height_in_luma_samples;
356 int8u chromaArrayType = (*seq_parameter_set_Item)->ChromaArrayType();
357 if (chromaArrayType >= 4)
358 chromaArrayType = 0;
359 int32u CropUnitX=Hevc_SubWidthC [chromaArrayType];
360 int32u CropUnitY=Hevc_SubHeightC[chromaArrayType];
361 Width -=((*seq_parameter_set_Item)->conf_win_left_offset+(*seq_parameter_set_Item)->conf_win_right_offset)*CropUnitX;
362 Height-=((*seq_parameter_set_Item)->conf_win_top_offset +(*seq_parameter_set_Item)->conf_win_bottom_offset)*CropUnitY;
363
364 Ztring Profile;
365 if ((*seq_parameter_set_Item)->profile_space==0)
366 {
367 if ((*seq_parameter_set_Item)->profile_idc)
368 {
369 Profile=Ztring().From_UTF8(Hevc_profile_idc((*seq_parameter_set_Item)->profile_idc));
370 if ((*seq_parameter_set_Item)->profile_idc == 7 && (*seq_parameter_set_Item)->general_max_8bit_constraint_flag)
371 Profile+=__T(" 10");
372 }
373 if ((*seq_parameter_set_Item)->level_idc)
374 {
375 if ((*seq_parameter_set_Item)->profile_idc)
376 Profile+=__T('@');
377 Profile+=__T('L')+Ztring().From_Number(((float)(*seq_parameter_set_Item)->level_idc)/30, ((*seq_parameter_set_Item)->level_idc%10)?1:0);
378 Profile+=__T('@');
379 Profile+=Ztring().From_UTF8(Hevc_tier_flag((*seq_parameter_set_Item)->tier_flag));
380 }
381 }
382 Fill(Stream_Video, 0, Video_Format_Profile, Profile);
383 Fill(Stream_Video, 0, Video_Codec_Profile, Profile);
384 Fill(Stream_Video, StreamPos_Last, Video_Width, Width);
385 Fill(Stream_Video, StreamPos_Last, Video_Height, Height);
386 if ((*seq_parameter_set_Item)->conf_win_left_offset || (*seq_parameter_set_Item)->conf_win_right_offset)
387 Fill(Stream_Video, StreamPos_Last, Video_Stored_Width, (*seq_parameter_set_Item)->pic_width_in_luma_samples);
388 if ((*seq_parameter_set_Item)->conf_win_top_offset || (*seq_parameter_set_Item)->conf_win_bottom_offset)
389 Fill(Stream_Video, StreamPos_Last, Video_Stored_Height, (*seq_parameter_set_Item)->pic_height_in_luma_samples);
390
391 Fill(Stream_Video, 0, Video_ColorSpace, Hevc_chroma_format_idc_ColorSpace((*seq_parameter_set_Item)->chroma_format_idc));
392 Fill(Stream_Video, 0, Video_ChromaSubsampling, Hevc_chroma_format_idc((*seq_parameter_set_Item)->chroma_format_idc));
393 if ((*seq_parameter_set_Item)->bit_depth_luma_minus8==(*seq_parameter_set_Item)->bit_depth_chroma_minus8)
394 Fill(Stream_Video, 0, Video_BitDepth, (*seq_parameter_set_Item)->bit_depth_luma_minus8+8);
395
396 if (preferred_transfer_characteristics!=2)
397 Fill(Stream_Video, 0, Video_transfer_characteristics, Mpegv_transfer_characteristics(preferred_transfer_characteristics));
398 if ((*seq_parameter_set_Item)->vui_parameters)
399 {
400 if ((*seq_parameter_set_Item)->vui_parameters->timing_info_present_flag)
401 {
402 if ((*seq_parameter_set_Item)->vui_parameters->time_scale && (*seq_parameter_set_Item)->vui_parameters->num_units_in_tick)
403 Fill(Stream_Video, StreamPos_Last, Video_FrameRate, (float64)(*seq_parameter_set_Item)->vui_parameters->time_scale / (*seq_parameter_set_Item)->vui_parameters->num_units_in_tick);
404 }
405
406 if ((*seq_parameter_set_Item)->vui_parameters->aspect_ratio_info_present_flag)
407 {
408 float64 PixelAspectRatio = 1;
409 if ((*seq_parameter_set_Item)->vui_parameters->aspect_ratio_idc<Avc_PixelAspectRatio_Size)
410 PixelAspectRatio = Avc_PixelAspectRatio[(*seq_parameter_set_Item)->vui_parameters->aspect_ratio_idc];
411 else if ((*seq_parameter_set_Item)->vui_parameters->aspect_ratio_idc == 0xFF && (*seq_parameter_set_Item)->vui_parameters->sar_height)
412 PixelAspectRatio = ((float64) (*seq_parameter_set_Item)->vui_parameters->sar_width) / (*seq_parameter_set_Item)->vui_parameters->sar_height;
413
414 Fill(Stream_Video, 0, Video_PixelAspectRatio, PixelAspectRatio, 3, true);
415 if(Height)
416 Fill(Stream_Video, 0, Video_DisplayAspectRatio, Width*PixelAspectRatio/Height, 3, true); //More precise
417 }
418
419 //Colour description
420 if ((*seq_parameter_set_Item)->vui_parameters->video_signal_type_present_flag)
421 {
422 Fill(Stream_Video, 0, Video_Standard, Avc_video_format[(*seq_parameter_set_Item)->vui_parameters->video_format]);
423 Fill(Stream_Video, 0, Video_colour_range, Avc_video_full_range[(*seq_parameter_set_Item)->vui_parameters->video_full_range_flag]);
424 if ((*seq_parameter_set_Item)->vui_parameters->colour_description_present_flag)
425 {
426 Fill(Stream_Video, 0, Video_colour_description_present, "Yes");
427 Fill(Stream_Video, 0, Video_colour_primaries, Mpegv_colour_primaries((*seq_parameter_set_Item)->vui_parameters->colour_primaries));
428 Fill(Stream_Video, 0, Video_transfer_characteristics, Mpegv_transfer_characteristics((*seq_parameter_set_Item)->vui_parameters->transfer_characteristics));
429 Fill(Stream_Video, 0, Video_matrix_coefficients, Mpegv_matrix_coefficients((*seq_parameter_set_Item)->vui_parameters->matrix_coefficients));
430 if ((*seq_parameter_set_Item)->vui_parameters->matrix_coefficients!=2)
431 Fill(Stream_Video, 0, Video_ColorSpace, Mpegv_matrix_coefficients_ColorSpace((*seq_parameter_set_Item)->vui_parameters->matrix_coefficients), Unlimited, true, true);
432 }
433 }
434 }
435 }
436
437 //---------------------------------------------------------------------------
Streams_Finish()438 void File_Hevc::Streams_Finish()
439 {
440 //GA94 captions
441 #if defined(MEDIAINFO_DTVCCTRANSPORT_YES)
442 if (GA94_03_Parser && GA94_03_Parser->Status[IsAccepted])
443 {
444 Clear(Stream_Text);
445
446 Finish(GA94_03_Parser);
447 Merge(*GA94_03_Parser);
448
449 Ztring LawRating=GA94_03_Parser->Retrieve(Stream_General, 0, General_LawRating);
450 if (!LawRating.empty())
451 Fill(Stream_General, 0, General_LawRating, LawRating, true);
452 Ztring Title=GA94_03_Parser->Retrieve(Stream_General, 0, General_Title);
453 if (!Title.empty() && Retrieve(Stream_General, 0, General_Title).empty())
454 Fill(Stream_General, 0, General_Title, Title);
455
456 for (size_t Pos=0; Pos<Count_Get(Stream_Text); Pos++)
457 {
458 Ztring MuxingMode=Retrieve(Stream_Text, Pos, "MuxingMode");
459 Fill(Stream_Text, Pos, "MuxingMode", __T("SCTE 128 / ")+MuxingMode, true);
460 }
461 }
462 #endif //defined(MEDIAINFO_DTVCCTRANSPORT_YES)
463 }
464
465 //***************************************************************************
466 // Buffer - File header
467 //***************************************************************************
468
469 //---------------------------------------------------------------------------
FileHeader_Begin()470 bool File_Hevc::FileHeader_Begin()
471 {
472 if (!File__Analyze::FileHeader_Begin_0x000001())
473 return false;
474
475 if (!MustSynchronize)
476 {
477 Synched_Init();
478 Buffer_TotalBytes_FirstSynched=0;
479 File_Offset_FirstSynched=File_Offset;
480 }
481
482 //All should be OK
483 return true;
484 }
485
486 //***************************************************************************
487 // Buffer - Synchro
488 //***************************************************************************
489
490 //---------------------------------------------------------------------------
Synchronize()491 bool File_Hevc::Synchronize()
492 {
493 //Synchronizing
494 size_t Buffer_Offset_Min=Buffer_Offset;
495 while(Buffer_Offset+4<=Buffer_Size && (Buffer[Buffer_Offset ]!=0x00
496 || Buffer[Buffer_Offset+1]!=0x00
497 || Buffer[Buffer_Offset+2]!=0x01))
498 {
499 Buffer_Offset+=2;
500 while(Buffer_Offset<Buffer_Size && Buffer[Buffer_Offset]!=0x00)
501 Buffer_Offset+=2;
502 if (Buffer_Offset>=Buffer_Size || Buffer[Buffer_Offset-1]==0x00)
503 Buffer_Offset--;
504 }
505 if (Buffer_Offset>Buffer_Offset_Min && Buffer[Buffer_Offset-1]==0x00)
506 Buffer_Offset--;
507
508 //Parsing last bytes if needed
509 if (Buffer_Offset+4==Buffer_Size && (Buffer[Buffer_Offset ]!=0x00
510 || Buffer[Buffer_Offset+1]!=0x00
511 || Buffer[Buffer_Offset+2]!=0x00
512 || Buffer[Buffer_Offset+3]!=0x01))
513 Buffer_Offset++;
514 if (Buffer_Offset+3==Buffer_Size && (Buffer[Buffer_Offset ]!=0x00
515 || Buffer[Buffer_Offset+1]!=0x00
516 || Buffer[Buffer_Offset+2]!=0x01))
517 Buffer_Offset++;
518 if (Buffer_Offset+2==Buffer_Size && (Buffer[Buffer_Offset ]!=0x00
519 || Buffer[Buffer_Offset+1]!=0x00))
520 Buffer_Offset++;
521 if (Buffer_Offset+1==Buffer_Size && Buffer[Buffer_Offset ]!=0x00)
522 Buffer_Offset++;
523
524 if (Buffer_Offset+4>Buffer_Size)
525 return false;
526
527 if (File_Offset==0 && Buffer_Offset==0 && (Buffer[3]==0xE0 || Buffer[3]==0xFE))
528 {
529 //It is from MPEG-PS
530 Reject();
531 return false;
532 }
533
534 //Synched is OK
535 Synched=true;
536 return true;
537 }
538
539 //---------------------------------------------------------------------------
Synched_Test()540 bool File_Hevc::Synched_Test()
541 {
542 //Must have enough buffer for having header
543 if (Buffer_Offset+6>Buffer_Size)
544 return false;
545
546 //Quick test of synchro
547 if (Buffer[Buffer_Offset ]!=0x00
548 || Buffer[Buffer_Offset+1]!=0x00
549 || (Buffer[Buffer_Offset+2]!=0x01 && (Buffer[Buffer_Offset+2]!=0x00 || Buffer[Buffer_Offset+3]!=0x01)))
550 {
551 Synched=false;
552 return true;
553 }
554
555 //Quick search
556 if (!Header_Parser_QuickSearch())
557 return false;
558
559 //We continue
560 return true;
561 }
562
563 //***************************************************************************
564 // Buffer - Demux
565 //***************************************************************************
566
567 //---------------------------------------------------------------------------
568 #if MEDIAINFO_DEMUX
Demux_UnpacketizeContainer_Test()569 bool File_Hevc::Demux_UnpacketizeContainer_Test()
570 {
571 const int8u* Buffer_Temp=NULL;
572 size_t Buffer_Temp_Size=0;
573 bool RandomAccess=true; //Default, in case of problem
574
575 if ((MustParse_VPS_SPS_PPS || SizedBlocks) && Demux_Transcode_Iso14496_15_to_AnnexB)
576 {
577 if (MustParse_VPS_SPS_PPS)
578 return true; //Wait for SPS and PPS
579
580 //Random access check
581 RandomAccess=false;
582
583 //Computing final size
584 size_t TranscodedBuffer_Size=0;
585 size_t Buffer_Offset_Save=Buffer_Offset;
586 while (Buffer_Offset+lengthSizeMinusOne+1+1<=Buffer_Size)
587 {
588 size_t Size;
589 if (Buffer_Offset+lengthSizeMinusOne>Buffer_Size)
590 {
591 Size=0;
592 Buffer_Offset=Buffer_Size;
593 }
594 else
595 switch (lengthSizeMinusOne)
596 {
597 case 0: Size=Buffer[Buffer_Offset];
598 TranscodedBuffer_Size+=2;
599 break;
600 case 1: Size=BigEndian2int16u(Buffer+Buffer_Offset);
601 TranscodedBuffer_Size++;
602 break;
603 case 2: Size=BigEndian2int24u(Buffer+Buffer_Offset);
604 break;
605 case 3: Size=BigEndian2int32u(Buffer+Buffer_Offset);
606 TranscodedBuffer_Size--;
607 break;
608 default: return true; //Problem
609 }
610 Size+=lengthSizeMinusOne+1;
611
612 //Coherency checking
613 if (Size<lengthSizeMinusOne+1+2 || Buffer_Offset+Size>Buffer_Size || (Buffer_Offset+Size!=Buffer_Size && Buffer_Offset+Size+lengthSizeMinusOne+1>Buffer_Size))
614 Size=Buffer_Size-Buffer_Offset;
615 size_t Buffer_Offset_Temp=Buffer_Offset+lengthSizeMinusOne+1;
616
617 //In case there are more than 1 NAL in the block (in Stream format), trying to find the first NAL being a slice
618 size_t Buffer_Offset_Temp_Max=Buffer_Offset+Size;
619 if (!RandomAccess && Buffer_Offset_Temp<Buffer_Offset_Temp_Max && (Buffer[Buffer_Offset_Temp]&0x40)!=0) //Is not a slice
620 {
621 while (Buffer_Offset_Temp+3<=Buffer_Offset+Size)
622 {
623 if (CC3(Buffer+Buffer_Offset_Temp)==0x000001)
624 {
625 if (!RandomAccess && Buffer_Offset+Buffer_Offset_Temp+3<Buffer_Size && (Buffer[Buffer_Offset+Buffer_Offset_Temp+3]&0x40)==0) //Is a slice
626 {
627 Buffer_Offset_Temp+=3;
628 break;
629 }
630 }
631 Buffer_Offset_Temp+=2;
632 while (Buffer_Offset_Temp<Buffer_Offset_Temp_Max && Buffer[Buffer_Offset_Temp]!=0x00)
633 Buffer_Offset_Temp+=2;
634 if (Buffer_Offset_Temp>=Buffer_Offset_Temp_Max || Buffer[Buffer_Offset_Temp]==0x00)
635 Buffer_Offset_Temp--;
636 }
637 }
638
639 //Random access check
640 if (!RandomAccess && Buffer_Offset_Temp+2<Buffer_Size && (Buffer[Buffer_Offset_Temp]&0x40)==0) //Is a slice
641 {
642 Element_Offset=Buffer_Offset_Temp+2-Buffer_Offset;
643 Element_Size=Size-Buffer_Offset_Temp;
644
645 BS_Begin();
646 Get_SB ( first_slice_segment_in_pic_flag, "first_slice_segment_in_pic_flag");
647 if (first_slice_segment_in_pic_flag)
648 {
649 Element_Code=(Buffer[Buffer_Offset_Temp]&0x3E)>>1; //nal_unit_type
650 RapPicFlag=Element_Code>=16 && Element_Code<=23;
651 if (RapPicFlag)
652 Skip_SB( "no_output_of_prior_pics_flag");
653 Get_UE ( slice_pic_parameter_set_id, "slice_pic_parameter_set_id");
654 int8u num_extra_slice_header_bits=(int8u)-1;
655 std::vector<pic_parameter_set_struct*>::iterator pic_parameter_set_Item;
656 if (MustParse_VPS_SPS_PPS_FromFlv)
657 num_extra_slice_header_bits=0; // We bet it is old, so without num_extra_slice_header_bits
658 else if (!(slice_pic_parameter_set_id>=pic_parameter_sets.size() || (*(pic_parameter_set_Item=pic_parameter_sets.begin()+slice_pic_parameter_set_id))==NULL))
659 {
660 num_extra_slice_header_bits=(*pic_parameter_set_Item)->num_extra_slice_header_bits;
661 }
662 if (num_extra_slice_header_bits!=(int8u)-1)
663 {
664 int32u slice_type;
665 Skip_S1(num_extra_slice_header_bits, "slice_reserved_flags");
666 Get_UE (slice_type, "slice_type");
667
668 switch (slice_type)
669 {
670 case 2 :
671 case 7 :
672 RandomAccess=true;
673 }
674 }
675 }
676 BS_End();
677 }
678
679 TranscodedBuffer_Size+=Size;
680 Buffer_Offset+=Size;
681 }
682 Buffer_Offset=Buffer_Offset_Save;
683
684 //Adding VPS/SPS/PPS sizes
685 if (RandomAccess)
686 {
687 for (video_parameter_set_structs::iterator Data_Item=video_parameter_sets.begin(); Data_Item!=video_parameter_sets.end(); ++Data_Item)
688 TranscodedBuffer_Size+=(*Data_Item)->AnnexB_Buffer_Size;
689 for (seq_parameter_set_structs::iterator Data_Item=seq_parameter_sets.begin(); Data_Item!=seq_parameter_sets.end(); ++Data_Item)
690 TranscodedBuffer_Size+=(*Data_Item)->AnnexB_Buffer_Size;
691 for (pic_parameter_set_structs::iterator Data_Item=pic_parameter_sets.begin(); Data_Item!=pic_parameter_sets.end(); ++Data_Item)
692 TranscodedBuffer_Size+=(*Data_Item)->AnnexB_Buffer_Size;
693 }
694
695 //Copying
696 int8u* TranscodedBuffer=new int8u[TranscodedBuffer_Size+100];
697 size_t TranscodedBuffer_Pos=0;
698 if (RandomAccess)
699 {
700 for (video_parameter_set_structs::iterator Data_Item=video_parameter_sets.begin(); Data_Item!=video_parameter_sets.end(); ++Data_Item)
701 {
702 std::memcpy(TranscodedBuffer+TranscodedBuffer_Pos, (*Data_Item)->AnnexB_Buffer, (*Data_Item)->AnnexB_Buffer_Size);
703 TranscodedBuffer_Pos+=(*Data_Item)->AnnexB_Buffer_Size;
704 }
705 for (seq_parameter_set_structs::iterator Data_Item=seq_parameter_sets.begin(); Data_Item!=seq_parameter_sets.end(); ++Data_Item)
706 {
707 std::memcpy(TranscodedBuffer+TranscodedBuffer_Pos, (*Data_Item)->AnnexB_Buffer, (*Data_Item)->AnnexB_Buffer_Size);
708 TranscodedBuffer_Pos+=(*Data_Item)->AnnexB_Buffer_Size;
709 }
710 for (pic_parameter_set_structs::iterator Data_Item=pic_parameter_sets.begin(); Data_Item!=pic_parameter_sets.end(); ++Data_Item)
711 {
712 std::memcpy(TranscodedBuffer+TranscodedBuffer_Pos, (*Data_Item)->AnnexB_Buffer, (*Data_Item)->AnnexB_Buffer_Size);
713 TranscodedBuffer_Pos+=(*Data_Item)->AnnexB_Buffer_Size;
714 }
715 }
716 while (Buffer_Offset<Buffer_Size)
717 {
718 //Sync layer
719 TranscodedBuffer[TranscodedBuffer_Pos]=0x00;
720 TranscodedBuffer_Pos++;
721 TranscodedBuffer[TranscodedBuffer_Pos]=0x00;
722 TranscodedBuffer_Pos++;
723 TranscodedBuffer[TranscodedBuffer_Pos]=0x01;
724 TranscodedBuffer_Pos++;
725
726 //Block
727 size_t Size;
728 switch (lengthSizeMinusOne)
729 {
730 case 0: Size=Buffer[Buffer_Offset];
731 Buffer_Offset++;
732 break;
733 case 1: Size=BigEndian2int16u(Buffer+Buffer_Offset);
734 Buffer_Offset+=2;
735 break;
736 case 2: Size=BigEndian2int24u(Buffer+Buffer_Offset);
737 Buffer_Offset+=3;
738 break;
739 case 3: Size=BigEndian2int32u(Buffer+Buffer_Offset);
740 Buffer_Offset+=4;
741 break;
742 default: //Problem
743 delete [] TranscodedBuffer;
744 return false;
745 }
746
747 //Coherency checking
748 if (Size==0 || Buffer_Offset+Size>Buffer_Size || (Buffer_Offset+Size!=Buffer_Size && Buffer_Offset+Size+lengthSizeMinusOne+1>Buffer_Size))
749 Size=Buffer_Size-Buffer_Offset;
750
751 std::memcpy(TranscodedBuffer+TranscodedBuffer_Pos, Buffer+Buffer_Offset, Size);
752 TranscodedBuffer_Pos+=Size;
753 Buffer_Offset+=Size;
754 }
755 Buffer_Offset=0;
756
757 Buffer_Temp=Buffer;
758 Buffer=TranscodedBuffer;
759 Buffer_Temp_Size=Buffer_Size;
760 Buffer_Size=TranscodedBuffer_Size;
761 Demux_Offset=Buffer_Size;
762 }
763 else
764 {
765 bool zero_byte=Buffer[Buffer_Offset+2]==0x00;
766 if (!(((Buffer[Buffer_Offset+(zero_byte?4:3)]&0x40)==0 && (Buffer[Buffer_Offset+(zero_byte?6:5)]&0x80)!=0x80)
767 || (Buffer[Buffer_Offset+(zero_byte?4:3)]&0x7E)==(38<<1)))
768 {
769 if (Demux_Offset==0)
770 {
771 Demux_Offset=Buffer_Offset;
772 Demux_IntermediateItemFound=false;
773 }
774 while (Demux_Offset+6<=Buffer_Size)
775 {
776 //Synchronizing
777 while(Demux_Offset+6<=Buffer_Size && (Buffer[Demux_Offset ]!=0x00
778 || Buffer[Demux_Offset+1]!=0x00
779 || Buffer[Demux_Offset+2]!=0x01))
780 {
781 Demux_Offset+=2;
782 while(Demux_Offset<Buffer_Size && Buffer[Buffer_Offset]!=0x00)
783 Demux_Offset+=2;
784 if (Demux_Offset>=Buffer_Size || Buffer[Demux_Offset-1]==0x00)
785 Demux_Offset--;
786 }
787
788 if (Demux_Offset+6>Buffer_Size)
789 {
790 if (Config->IsFinishing)
791 Demux_Offset=Buffer_Size;
792 break;
793 }
794
795 zero_byte=Buffer[Demux_Offset+2]==0x00;
796 int8u nal_unit_type=Buffer[Demux_Offset+(zero_byte?4:3)]>>1;
797 bool Next;
798 switch (nal_unit_type)
799 {
800 case 0 :
801 case 1 :
802 case 2 :
803 case 3 :
804 case 4 :
805 case 5 :
806 case 6 :
807 case 7 :
808 case 8 :
809 case 9 :
810 case 16 :
811 case 17 :
812 case 18 :
813 case 19 :
814 case 20 :
815 case 21 :
816 if (Demux_IntermediateItemFound)
817 {
818 if (Buffer[Demux_Offset+(zero_byte?6:5)]&0x80)
819 Next=true;
820 else
821 Next=false;
822 }
823 else
824 {
825 Next=false;
826 Demux_IntermediateItemFound=true;
827 }
828 break;
829 case 32 :
830 case 33 :
831 case 34 :
832 case 35 :
833 if (Demux_IntermediateItemFound)
834 Next=true;
835 else
836 Next=false;
837 break;
838 default : Next=false;
839 }
840
841 if (Next)
842 {
843 Demux_IntermediateItemFound=false;
844 break;
845 }
846
847 Demux_Offset++;
848 }
849
850 if (Demux_Offset+6>Buffer_Size && !FrameIsAlwaysComplete && !Config->IsFinishing)
851 return false; //No complete frame
852
853 if (Demux_Offset && Buffer[Demux_Offset-1]==0x00)
854 Demux_Offset--;
855
856 zero_byte=Buffer[Buffer_Offset+2]==0x00;
857 size_t Buffer_Offset_Random=Buffer_Offset;
858 if ((Buffer[Buffer_Offset_Random+(zero_byte?4:3)]&0x7E)==(35<<1))
859 {
860 Buffer_Offset_Random++;
861 if (zero_byte)
862 Buffer_Offset_Random++;
863 while(Buffer_Offset_Random+6<=Buffer_Size && (Buffer[Buffer_Offset_Random ]!=0x00
864 || Buffer[Buffer_Offset_Random+1]!=0x00
865 || Buffer[Buffer_Offset_Random+2]!=0x01))
866 Buffer_Offset_Random++;
867 zero_byte=Buffer[Buffer_Offset_Random+2]==0x00;
868 }
869 RandomAccess=Buffer_Offset_Random+6<=Buffer_Size && (Buffer[Buffer_Offset_Random+(zero_byte?4:3)]&0x7E)==(32<<1); //video_parameter_set
870 }
871 }
872
873 if (!Status[IsAccepted])
874 {
875 if (Config->Demux_EventWasSent)
876 return false;
877 File_Hevc* MI=new File_Hevc;
878 Element_Code=(int64u)-1;
879 Open_Buffer_Init(MI);
880 #ifdef MEDIAINFO_EVENTS
881 MediaInfo_Config_PerPackage* Config_PerPackage_Temp=MI->Config->Config_PerPackage;
882 MI->Config->Config_PerPackage=NULL;
883 #endif //MEDIAINFO_EVENTS
884 Open_Buffer_Continue(MI, Buffer, Buffer_Size);
885 #ifdef MEDIAINFO_EVENTS
886 MI->Config->Config_PerPackage=Config_PerPackage_Temp;
887 #endif //MEDIAINFO_EVENTS
888 bool IsOk=MI->Status[IsAccepted];
889 delete MI;
890 if (!IsOk)
891 return false;
892 }
893
894 if (IFrame_Count || RandomAccess)
895 {
896 int64u PTS_Temp=FrameInfo.PTS;
897 if (!IsSub)
898 FrameInfo.PTS=(int64u)-1;
899 Demux_UnpacketizeContainer_Demux(RandomAccess);
900 if (!IsSub)
901 FrameInfo.PTS=PTS_Temp;
902 }
903 else
904 Demux_UnpacketizeContainer_Demux_Clear();
905
906 if (Buffer_Temp)
907 {
908 Demux_TotalBytes-=Buffer_Size;
909 Demux_TotalBytes+=Buffer_Temp_Size;
910 delete[] Buffer;
911 Buffer=Buffer_Temp;
912 Buffer_Size=Buffer_Temp_Size;
913 }
914
915 return true;
916 }
917 #endif //MEDIAINFO_DEMUX
918
919 //---------------------------------------------------------------------------
Synched_Init()920 void File_Hevc::Synched_Init()
921 {
922 if (!Frame_Count_Valid)
923 Frame_Count_Valid=Config->ParseSpeed>=0.3?16:16; //Note: should be replaced by "512:2" when I-frame/GOP detection is OK
924
925 //FrameInfo
926 PTS_End=0;
927 if (!IsSub)
928 FrameInfo.DTS=0; //No DTS in container
929 DTS_Begin=FrameInfo.DTS;
930 DTS_End=FrameInfo.DTS;
931
932 //Status
933 IFrame_Count=0;
934
935 //Temp
936 chroma_sample_loc_type_top_field=(int32u)-1;
937 chroma_sample_loc_type_bottom_field=(int32u)-1;
938 maximum_content_light_level=0;
939 maximum_frame_average_light_level=0;
940 preferred_transfer_characteristics=2;
941 chroma_format_idc=0;
942
943 //Default values
944 Streams.resize(0x100);
945 Streams[32].Searching_Payload=true; //video_parameter_set
946 Streams[35].Searching_Payload=true; //access_unit_delimiter
947 Streams[39].Searching_Payload=true; //sei
948 for (int8u Pos=0xFF; Pos>=48; Pos--)
949 Streams[Pos].Searching_Payload=true; //unspecified
950
951 #if MEDIAINFO_DEMUX
952 Demux_Transcode_Iso14496_15_to_AnnexB=Config->Demux_Hevc_Transcode_Iso14496_15_to_AnnexB_Get();
953 #endif //MEDIAINFO_DEMUX
954 }
955
956 //***************************************************************************
957 // Buffer - Global
958 //***************************************************************************
959
960 //---------------------------------------------------------------------------
Read_Buffer_Unsynched()961 void File_Hevc::Read_Buffer_Unsynched()
962 {
963 //Impossible to know TimeStamps now
964 PTS_End=0;
965 DTS_End=0;
966
967 //Temporal references
968 Clean_Temp_References();
969 delete TemporalReferences_DelayedElement; TemporalReferences_DelayedElement=NULL;
970 TemporalReferences_Min=0;
971 TemporalReferences_Max=0;
972 TemporalReferences_Reserved=0;
973 TemporalReferences_Offset=0;
974 TemporalReferences_Offset_pic_order_cnt_lsb_Last=0;
975 TemporalReferences_pic_order_cnt_Min=0;
976
977 //Text
978 #if defined(MEDIAINFO_DTVCCTRANSPORT_YES)
979 if (GA94_03_Parser)
980 GA94_03_Parser->Open_Buffer_Unsynch();
981 #endif //defined(MEDIAINFO_DTVCCTRANSPORT_YES)
982 }
983
984 //***************************************************************************
985 // Buffer - Per element
986 //***************************************************************************
987
988 //---------------------------------------------------------------------------
Header_Parse()989 void File_Hevc::Header_Parse()
990 {
991 //Specific case
992 if (MustParse_VPS_SPS_PPS)
993 {
994 Header_Fill_Size(Element_Size);
995 Header_Fill_Code((int64u)-1, "Specific");
996 return;
997 }
998
999 //Parsing
1000 int8u nal_unit_type, nuh_temporal_id_plus1;
1001 if (!SizedBlocks || SizedBlocks_FileThenStream)
1002 {
1003 if (Buffer[Buffer_Offset+2]==0x00)
1004 Skip_B1( "zero_byte");
1005 Skip_B3( "start_code_prefix_one_3bytes");
1006 BS_Begin();
1007 Mark_0 ();
1008 Get_S1 (6, nal_unit_type, "nal_unit_type");
1009 Get_S1 (6, nuh_layer_id, "nuh_layer_id");
1010 Get_S1 (3, nuh_temporal_id_plus1, "nuh_temporal_id_plus1");
1011 BS_End();
1012
1013 if (!Header_Parser_Fill_Size())
1014 {
1015 Element_WaitForMoreData();
1016 return;
1017 }
1018
1019 //if (nuh_temporal_id_plus1==0) // Found 1 stream with nuh_temporal_id_plus1==0, lets disable this coherency test for the moment
1020 // Trusted_IsNot("nuh_temporal_id_plus1");
1021
1022 //In case there are more than 1 NAL in the block (in Stream format), trying to find the first NAL being a slice
1023 if (SizedBlocks_FileThenStream && Element[Element_Level-1].Next>=SizedBlocks_FileThenStream)
1024 {
1025 if (Element[Element_Level-1].Next>SizedBlocks_FileThenStream)
1026 Header_Fill_Size(SizedBlocks_FileThenStream-(File_Offset+Buffer_Offset));
1027 SizedBlocks_FileThenStream=0; //TODO: more integrity tests, handling of first element size of first element (wrong in the trace)
1028 }
1029 }
1030 else
1031 {
1032 int32u Size;
1033 switch (lengthSizeMinusOne)
1034 {
1035 case 0: {
1036 int8u Size_;
1037 Get_B1 (Size_, "size");
1038 Size=Size_;
1039 }
1040 break;
1041 case 1: {
1042 int16u Size_;
1043 Get_B2 (Size_, "size");
1044 Size=Size_;
1045 }
1046 break;
1047 case 2: {
1048 int32u Size_;
1049 Get_B3 (Size_, "size");
1050 Size=Size_;
1051 }
1052 break;
1053 case 3: Get_B4 (Size, "size");
1054 break;
1055 default: Trusted_IsNot("No size of NALU defined");
1056 Size=(int32u)(Buffer_Size-Buffer_Offset);
1057 }
1058 Size+=lengthSizeMinusOne+1;
1059
1060 //Coherency checking
1061 if (Size<lengthSizeMinusOne+1+2 || Buffer_Offset+Size>Buffer_Size || (Buffer_Offset+Size!=Buffer_Size && Buffer_Offset+Size+lengthSizeMinusOne+1>Buffer_Size))
1062 Size=Buffer_Size-Buffer_Offset;
1063
1064 //In case there are more than 1 NAL in the block (in Stream format), trying to find the first NAL being a slice
1065 size_t Buffer_Offset_Temp=Buffer_Offset+lengthSizeMinusOne+1;
1066 size_t Buffer_Offset_Temp_Max=Buffer_Offset+Size;
1067 while (Buffer_Offset_Temp+3<=Buffer_Offset+Size)
1068 {
1069 if (CC3(Buffer+Buffer_Offset_Temp)==0x000001 || CC3(Buffer+Buffer_Offset_Temp)==0x000000)
1070 {
1071 break;
1072 }
1073 Buffer_Offset_Temp+=2;
1074 while (Buffer_Offset_Temp<Buffer_Offset_Temp_Max && Buffer[Buffer_Offset_Temp]!=0x00)
1075 Buffer_Offset_Temp+=2;
1076 if (Buffer_Offset_Temp>=Buffer_Offset_Temp_Max || Buffer[Buffer_Offset_Temp]==0x00)
1077 Buffer_Offset_Temp--;
1078 }
1079 if (Buffer_Offset_Temp+3<=Buffer_Offset+Size)
1080 {
1081 SizedBlocks_FileThenStream=File_Offset+Buffer_Offset+Size;
1082 Size=Buffer_Offset_Temp-Buffer_Offset;
1083 }
1084
1085 BS_Begin();
1086 Mark_0 ();
1087 Get_S1 (6, nal_unit_type, "nal_unit_type");
1088 Get_S1 (6, nuh_layer_id, "nuh_layer_id");
1089 Get_S1 (3, nuh_temporal_id_plus1, "nuh_temporal_id_plus1");
1090 BS_End();
1091
1092 //if (nuh_temporal_id_plus1==0) // Found 1 stream with nuh_temporal_id_plus1==0, lets disable this coherency test for the moment
1093 // Trusted_IsNot("nuh_temporal_id_plus1");
1094
1095 FILLING_BEGIN();
1096 Header_Fill_Size(Size);
1097 FILLING_END();
1098 }
1099
1100 //Filling
1101 #if MEDIAINFO_TRACE
1102 if (Trace_Activated)
1103 Header_Fill_Code(nal_unit_type, Ztring().From_CC1(nal_unit_type));
1104 else
1105 #endif //MEDIAINFO_TRACE
1106 Header_Fill_Code(nal_unit_type);
1107 }
1108
1109 //---------------------------------------------------------------------------
Header_Parser_Fill_Size()1110 bool File_Hevc::Header_Parser_Fill_Size()
1111 {
1112 //Look for next Sync word
1113 if (Buffer_Offset_Temp==0) //Buffer_Offset_Temp is not 0 if Header_Parse_Fill_Size() has already parsed first frames
1114 Buffer_Offset_Temp=Buffer_Offset+4;
1115 while (Buffer_Offset_Temp+5<=Buffer_Size
1116 && CC3(Buffer+Buffer_Offset_Temp)!=0x000001)
1117 {
1118 Buffer_Offset_Temp+=2;
1119 while(Buffer_Offset_Temp<Buffer_Size && Buffer[Buffer_Offset_Temp]!=0x00)
1120 Buffer_Offset_Temp+=2;
1121 if (Buffer_Offset_Temp>=Buffer_Size || Buffer[Buffer_Offset_Temp-1]==0x00)
1122 Buffer_Offset_Temp--;
1123 }
1124
1125 //Must wait more data?
1126 if (Buffer_Offset_Temp+5>Buffer_Size)
1127 {
1128 if (FrameIsAlwaysComplete || Config->IsFinishing)
1129 Buffer_Offset_Temp=Buffer_Size; //We are sure that the next bytes are a start
1130 else
1131 return false;
1132 }
1133
1134 if (Buffer[Buffer_Offset_Temp-1]==0x00)
1135 Buffer_Offset_Temp--;
1136
1137 //OK, we continue
1138 Header_Fill_Size(Buffer_Offset_Temp-Buffer_Offset);
1139 Buffer_Offset_Temp=0;
1140 return true;
1141 }
1142
1143 //---------------------------------------------------------------------------
Header_Parser_QuickSearch()1144 bool File_Hevc::Header_Parser_QuickSearch()
1145 {
1146 while ( Buffer_Offset+6<=Buffer_Size
1147 && Buffer[Buffer_Offset ]==0x00
1148 && Buffer[Buffer_Offset+1]==0x00
1149 && (Buffer[Buffer_Offset+2]==0x01
1150 || (Buffer[Buffer_Offset+2]==0x00 && Buffer[Buffer_Offset+3]==0x01)))
1151 {
1152 //Getting start_code
1153 int8u nal_unit_type;
1154 if (Buffer[Buffer_Offset+2]==0x00)
1155 nal_unit_type=(CC1(Buffer+Buffer_Offset+4)&0x7E)>>1;
1156 else
1157 nal_unit_type=(CC1(Buffer+Buffer_Offset+3)&0x7E)>>1;
1158
1159 //Searching start
1160 if (Streams[nal_unit_type].Searching_Payload)
1161 return true;
1162
1163 //Synchronizing
1164 Buffer_Offset+=4;
1165 Synched=false;
1166 if (!Synchronize())
1167 {
1168 UnSynched_IsNotJunk=true;
1169 return false;
1170 }
1171
1172 if (Buffer_Offset+6>Buffer_Size)
1173 {
1174 UnSynched_IsNotJunk=true;
1175 return false;
1176 }
1177 }
1178
1179 Trusted_IsNot("HEVC, Synchronisation lost");
1180 return Synchronize();
1181 }
1182
1183 //---------------------------------------------------------------------------
Data_Parse()1184 void File_Hevc::Data_Parse()
1185 {
1186 //Specific case
1187 if (Element_Code==(int64u)-1)
1188 {
1189 VPS_SPS_PPS();
1190 return;
1191 }
1192
1193 if (nuh_layer_id)
1194 {
1195 //Skip_XX(Element_Size, "(Extension)");
1196 //return;
1197 }
1198
1199 //Trailing zeroes
1200 int64u Element_Size_SaveBeforeZeroes=Element_Size;
1201 if (Element_Size)
1202 {
1203 while (Element_Size && Buffer[Buffer_Offset+(size_t)Element_Size-1]==0)
1204 Element_Size--;
1205 }
1206
1207 //Searching emulation_prevention_three_byte
1208 int8u* Buffer_3Bytes=NULL;
1209 const int8u* Save_Buffer=Buffer;
1210 int64u Save_File_Offset=File_Offset;
1211 size_t Save_Buffer_Offset=Buffer_Offset;
1212 int64u Save_Element_Size=Element_Size;
1213 size_t Element_Offset_3Bytes=(size_t)Element_Offset;
1214 std::vector<size_t> ThreeByte_List;
1215 while (Element_Offset_3Bytes+3<=Element_Size)
1216 {
1217 if (CC3(Buffer+Buffer_Offset+(size_t)Element_Offset_3Bytes)==0x000003)
1218 ThreeByte_List.push_back(Element_Offset_3Bytes+2);
1219 Element_Offset_3Bytes+=2;
1220 while(Element_Offset_3Bytes<Element_Size && Buffer[Buffer_Offset+(size_t)Element_Offset_3Bytes]!=0x00)
1221 Element_Offset_3Bytes+=2;
1222 if (Element_Offset_3Bytes>=Element_Size || Buffer[Buffer_Offset+(size_t)Element_Offset_3Bytes-1]==0x00)
1223 Element_Offset_3Bytes--;
1224 }
1225
1226 if (!ThreeByte_List.empty())
1227 {
1228 //We must change the buffer for keeping out
1229 Element_Size=Save_Element_Size-ThreeByte_List.size();
1230 File_Offset+=Buffer_Offset;
1231 Buffer_Offset=0;
1232 Buffer_3Bytes=new int8u[(size_t)Element_Size];
1233 for (size_t Pos=0; Pos<=ThreeByte_List.size(); Pos++)
1234 {
1235 size_t Pos0=(Pos==ThreeByte_List.size())?(size_t)Save_Element_Size:(ThreeByte_List[Pos]);
1236 size_t Pos1=(Pos==0)?0:(ThreeByte_List[Pos-1]+1);
1237 size_t Buffer_3bytes_Begin=Pos1-Pos;
1238 size_t Save_Buffer_Begin =Pos1;
1239 size_t Size= Pos0-Pos1;
1240 std::memcpy(Buffer_3Bytes+Buffer_3bytes_Begin, Save_Buffer+Save_Buffer_Offset+Save_Buffer_Begin, Size);
1241 }
1242 Buffer=Buffer_3Bytes;
1243 }
1244
1245 //Parsing
1246 switch (Element_Code)
1247 {
1248 case 0 :
1249 case 1 :
1250 case 2 :
1251 case 3 :
1252 case 4:
1253 case 5:
1254 case 6:
1255 case 7:
1256 case 8:
1257 case 9:
1258 case 16 :
1259 case 17 :
1260 case 18 :
1261 case 19 :
1262 case 20 :
1263 case 21 :
1264 slice_segment_layer(); break;
1265 case 32 : video_parameter_set(); break;
1266 case 33 : seq_parameter_set(); break;
1267 case 34 : pic_parameter_set(); break;
1268 case 35 : access_unit_delimiter(); break;
1269 case 36 : end_of_seq(); break;
1270 case 37 : end_of_bitstream(); break;
1271 case 38 : filler_data(); break;
1272 case 39 :
1273 case 40 :
1274 sei(); break;
1275 default :
1276 Skip_XX(Element_Size-Element_Offset, "Data");
1277 if (Element_Code>=48)
1278 Trusted_IsNot("Unspecified");
1279 }
1280
1281 if (!ThreeByte_List.empty())
1282 {
1283 //We must change the buffer for keeping out
1284 Element_Size=Save_Element_Size;
1285 File_Offset=Save_File_Offset;
1286 Buffer_Offset=Save_Buffer_Offset;
1287 delete[] Buffer; Buffer=Save_Buffer;
1288 Buffer_3Bytes=NULL; //Same as Buffer...
1289 Element_Offset+=ThreeByte_List.size();
1290 }
1291
1292 #if MEDIAINFO_DEMUX
1293 if (Demux_Transcode_Iso14496_15_to_AnnexB)
1294 {
1295 if (Element_Code==32)
1296 {
1297 std::vector<video_parameter_set_struct*>::iterator Data_Item=video_parameter_sets.begin();
1298 if (Data_Item!=video_parameter_sets.end() && (*Data_Item))
1299 {
1300 delete[] (*Data_Item)->AnnexB_Buffer;
1301 (*Data_Item)->AnnexB_Buffer_Size=(size_t)(Element_Size+5);
1302 (*Data_Item)->AnnexB_Buffer=new int8u[(*Data_Item)->AnnexB_Buffer_Size];
1303 (*Data_Item)->AnnexB_Buffer[0]=0x00;
1304 (*Data_Item)->AnnexB_Buffer[1]=0x00;
1305 (*Data_Item)->AnnexB_Buffer[2]=0x01;
1306 (*Data_Item)->AnnexB_Buffer[3]=Buffer[Buffer_Offset-2];
1307 (*Data_Item)->AnnexB_Buffer[4]=Buffer[Buffer_Offset-1];
1308 std::memcpy((*Data_Item)->AnnexB_Buffer+5, Buffer+Buffer_Offset, (size_t)Element_Size);
1309 }
1310 }
1311 if (Element_Code==33)
1312 {
1313 std::vector<seq_parameter_set_struct*>::iterator Data_Item=seq_parameter_sets.begin();
1314 if (Data_Item!=seq_parameter_sets.end() && (*Data_Item))
1315 {
1316 delete[] (*Data_Item)->AnnexB_Buffer;
1317 (*Data_Item)->AnnexB_Buffer_Size=(size_t)(Element_Size+5);
1318 (*Data_Item)->AnnexB_Buffer=new int8u[(*Data_Item)->AnnexB_Buffer_Size];
1319 (*Data_Item)->AnnexB_Buffer[0]=0x00;
1320 (*Data_Item)->AnnexB_Buffer[1]=0x00;
1321 (*Data_Item)->AnnexB_Buffer[2]=0x01;
1322 (*Data_Item)->AnnexB_Buffer[3]=Buffer[Buffer_Offset-2];
1323 (*Data_Item)->AnnexB_Buffer[4]=Buffer[Buffer_Offset-1];
1324 std::memcpy((*Data_Item)->AnnexB_Buffer+5, Buffer+Buffer_Offset, (size_t)Element_Size);
1325 }
1326 }
1327 if (Element_Code==34)
1328 {
1329 std::vector<pic_parameter_set_struct*>::iterator Data_Item=pic_parameter_sets.begin();
1330 if (Data_Item!=pic_parameter_sets.end() && (*Data_Item))
1331 {
1332 delete[] (*Data_Item)->AnnexB_Buffer;
1333 (*Data_Item)->AnnexB_Buffer_Size=(size_t)(Element_Size+5);
1334 (*Data_Item)->AnnexB_Buffer=new int8u[(*Data_Item)->AnnexB_Buffer_Size];
1335 (*Data_Item)->AnnexB_Buffer[0]=0x00;
1336 (*Data_Item)->AnnexB_Buffer[1]=0x00;
1337 (*Data_Item)->AnnexB_Buffer[2]=0x01;
1338 (*Data_Item)->AnnexB_Buffer[3]=Buffer[Buffer_Offset-2];
1339 (*Data_Item)->AnnexB_Buffer[4]=Buffer[Buffer_Offset-1];
1340 std::memcpy((*Data_Item)->AnnexB_Buffer+5, Buffer+Buffer_Offset, (size_t)Element_Size);
1341 }
1342 }
1343 }
1344 #endif //MEDIAINFO_DEMUX
1345
1346 //Trailing zeroes
1347 Element_Size=Element_Size_SaveBeforeZeroes;
1348 }
1349
1350 //***************************************************************************
1351 // Elements
1352 //***************************************************************************
1353
1354 //---------------------------------------------------------------------------
1355 // Packets
slice_segment_layer()1356 void File_Hevc::slice_segment_layer()
1357 {
1358 #if MEDIAINFO_TRACE
1359 Element_Name("slice_segment_layer");
1360 switch (Element_Code)
1361 {
1362 case 0 :
1363 case 1 : break;
1364 case 2 :
1365 case 3 : Element_Info("TSA"); break;
1366 case 4:
1367 case 5: Element_Info("STSA"); break;
1368 case 6:
1369 case 7: Element_Info("RADL"); break;
1370 case 8:
1371 case 9: Element_Info("RASL"); break;
1372 case 16 :
1373 case 17 :
1374 case 18 : Element_Info("BLA"); break;
1375 case 19 :
1376 case 20 : Element_Info("IDR"); break;
1377 case 21 : Element_Info("CRA"); break;
1378 default: ;
1379 }
1380 #endif //MEDIAINFO_TRACE
1381
1382 //Parsing
1383 RapPicFlag=Element_Code>=16 && Element_Code<=23;
1384 BS_Begin();
1385 slice_segment_header();
1386 BS_End();
1387 Skip_XX(Element_Size-Element_Offset, "(ToDo)");
1388
1389 FILLING_BEGIN();
1390 if (slice_pic_parameter_set_id==(int32u)-1)
1391 return;
1392
1393 //Count of I-Frames
1394 if (first_slice_segment_in_pic_flag && (Element_Code==19 || Element_Code==20))
1395 IFrame_Count++;
1396
1397 if (first_slice_segment_in_pic_flag)
1398 {
1399 //Frame_Count
1400 Frame_Count++;
1401 if (IFrame_Count && Frame_Count_NotParsedIncluded!=(int64u)-1)
1402 Frame_Count_NotParsedIncluded++;
1403 Frame_Count_InThisBlock++;
1404
1405 //Filling only if not already done
1406 if (Frame_Count==1 && !Status[IsAccepted])
1407 {
1408 if (RiskCalculationD && RiskCalculationN*2>=RiskCalculationD) // Check if we trust or not the sync
1409 {
1410 Reject("HEVC");
1411 return;
1412 }
1413 Accept("HEVC");
1414 }
1415 if (!Status[IsFilled])
1416 {
1417 if (IFrame_Count>=8)
1418 Frame_Count_Valid=Frame_Count; //We have enough frames
1419 if (Frame_Count>=Frame_Count_Valid)
1420 {
1421 Fill("HEVC");
1422 if (!IsSub && Config->ParseSpeed<1.0)
1423 Finish("HEVC");
1424 }
1425 }
1426 }
1427 FILLING_END();
1428 }
1429
1430 //---------------------------------------------------------------------------
1431 // Packet "32"
video_parameter_set()1432 void File_Hevc::video_parameter_set()
1433 {
1434 Element_Name("video_parameter_set");
1435
1436 //Parsing
1437 int32u vps_num_layer_sets_minus1;
1438 int8u vps_video_parameter_set_id, vps_max_sub_layers_minus1, vps_max_layer_id;
1439 bool vps_temporal_id_nesting_flag, vps_sub_layer_ordering_info_present_flag;
1440 BS_Begin();
1441 Get_S1 (4, vps_video_parameter_set_id, "vps_video_parameter_set_id");
1442 if (MustParse_VPS_SPS_PPS_FromFlv)
1443 {
1444 BS_End();
1445 Skip_XX(Element_Size-Element_Offset, "Data");
1446
1447 //Creating Data
1448 if (vps_video_parameter_set_id>=video_parameter_sets.size())
1449 video_parameter_sets.resize(vps_video_parameter_set_id+1);
1450 std::vector<video_parameter_set_struct*>::iterator Data_Item=video_parameter_sets.begin()+vps_video_parameter_set_id;
1451 delete *Data_Item; *Data_Item=new video_parameter_set_struct(
1452 0 //TODO: check which code is intended here
1453 );
1454
1455 //NextCode
1456 NextCode_Clear();
1457 NextCode_Add(33);
1458
1459 //Autorisation of other streams
1460 Streams[33].Searching_Payload=true; //seq_parameter_set
1461 Streams[36].Searching_Payload=true; //end_of_seq
1462 Streams[37].Searching_Payload=true; //end_of_bitstream
1463 Streams[38].Searching_Payload=true; //filler_data
1464
1465 return;
1466 }
1467 Skip_S1(2, "vps_reserved_three_2bits");
1468 Skip_S1(6, "vps_reserved_zero_6bits");
1469 Get_S1 (3, vps_max_sub_layers_minus1, "vps_max_sub_layers_minus1");
1470 if (vps_max_sub_layers_minus1>6)
1471 {
1472 Trusted_IsNot("vps_max_sub_layers_minus1 not valid");
1473 RiskCalculationN++;
1474 RiskCalculationD++;
1475 BS_End();
1476 return; //Problem, not valid
1477 }
1478 Get_SB ( vps_temporal_id_nesting_flag, "vps_temporal_id_nesting_flag");
1479 //if (vps_max_sub_layers_minus1==0 && !vps_temporal_id_nesting_flag)
1480 //{
1481 // Trusted_IsNot("vps_temporal_id_nesting_flag not valid");
1482 // BS_End();
1483 // return; //Problem, not valid
1484 //}
1485 Skip_S2(16, "vps_reserved_0xffff_16bits");
1486 profile_tier_level(vps_max_sub_layers_minus1);
1487 Get_SB ( vps_sub_layer_ordering_info_present_flag, "vps_sub_layer_ordering_info_present_flag");
1488 for (int32u SubLayerPos=(vps_sub_layer_ordering_info_present_flag?0:vps_max_sub_layers_minus1); SubLayerPos<=vps_max_sub_layers_minus1; SubLayerPos++)
1489 {
1490 Element_Begin1("SubLayer");
1491 Skip_UE( "vps_max_dec_pic_buffering_minus1");
1492 Skip_UE( "vps_max_num_reorder_pics");
1493 Skip_UE( "vps_max_latency_increase_plus1");
1494 Element_End0();
1495 }
1496 Get_S1 ( 6, vps_max_layer_id, "vps_max_layer_id");
1497 Get_UE ( vps_num_layer_sets_minus1, "vps_num_layer_sets_minus1");
1498 if (vps_num_layer_sets_minus1>=1024)
1499 {
1500 Trusted_IsNot("vps_num_layer_sets_minus1 not valid");
1501 RiskCalculationN++;
1502 RiskCalculationD++;
1503 BS_End();
1504 return; //Problem, not valid
1505 }
1506 for (int32u LayerSetPos=1; LayerSetPos<=vps_num_layer_sets_minus1; LayerSetPos++)
1507 for (int8u LayerId=0; LayerId<=vps_max_layer_id; LayerId++)
1508 Skip_SB( "layer_id_included_flag");
1509 TEST_SB_SKIP( "vps_timing_info_present_flag");
1510 int32u vps_time_scale, vps_num_hrd_parameters;
1511 Skip_S4(32, "vps_num_units_in_tick");
1512 Get_S4 (32, vps_time_scale, "vps_time_scale");
1513 if (vps_time_scale==0)
1514 {
1515 Trusted_IsNot("vps_time_scale not valid");
1516 RiskCalculationN++;
1517 RiskCalculationD++;
1518 Element_End0();
1519 BS_End();
1520 return; //Problem, not valid
1521 }
1522 TEST_SB_SKIP( "vps_poc_proportional_to_timing_flag");
1523 Skip_UE( "vps_num_ticks_poc_diff_one_minus1");
1524 TEST_SB_END();
1525 Get_UE ( vps_num_hrd_parameters, "vps_num_hrd_parameters");
1526 if (vps_num_hrd_parameters>1024)
1527 {
1528 Trusted_IsNot("vps_num_hrd_parameters not valid");
1529 RiskCalculationN++;
1530 RiskCalculationD++;
1531 vps_num_hrd_parameters=0;
1532 }
1533 for (int32u HrdPos=0; HrdPos<vps_num_hrd_parameters; HrdPos++)
1534 {
1535 seq_parameter_set_struct::vui_parameters_struct::xxl_common *xxL_Common=NULL;
1536 seq_parameter_set_struct::vui_parameters_struct::xxl *NAL=NULL, *VCL=NULL;
1537 int32u hrd_layer_set_idx;
1538 bool cprms_present_flag;
1539 Get_UE ( hrd_layer_set_idx, "hrd_layer_set_idx");
1540 if (hrd_layer_set_idx>=1024)
1541 Trusted_IsNot("hrd_layer_set_idx not valid");
1542 if (HrdPos)
1543 Get_SB (cprms_present_flag, "cprms_present_flag");
1544 else
1545 cprms_present_flag=true;
1546 hrd_parameters(cprms_present_flag, vps_max_sub_layers_minus1, xxL_Common, NAL, VCL);
1547 delete xxL_Common; xxL_Common=NULL; //TODO: keep VPS hrd_parameters
1548 delete NAL; NAL=NULL;
1549 delete VCL; VCL=NULL;
1550 }
1551 TEST_SB_END();
1552 EndOfxPS( "vps_extension_flag", "vps_extension_data");
1553 BS_End();
1554
1555 FILLING_BEGIN_PRECISE();
1556 //Creating Data
1557 if (vps_video_parameter_set_id>=video_parameter_sets.size())
1558 video_parameter_sets.resize(vps_video_parameter_set_id+1);
1559 std::vector<video_parameter_set_struct*>::iterator Data_Item=video_parameter_sets.begin()+vps_video_parameter_set_id;
1560 delete *Data_Item; *Data_Item=new video_parameter_set_struct(
1561 vps_max_sub_layers_minus1
1562 );
1563
1564 //NextCode
1565 NextCode_Clear();
1566 NextCode_Add(33);
1567
1568 //Autorisation of other streams
1569 Streams[33].Searching_Payload=true; //seq_parameter_set
1570 Streams[36].Searching_Payload=true; //end_of_seq
1571 Streams[37].Searching_Payload=true; //end_of_bitstream
1572 Streams[38].Searching_Payload=true; //filler_data
1573 FILLING_END();
1574 }
1575
1576 //---------------------------------------------------------------------------
1577 // Packet "33"
seq_parameter_set()1578 void File_Hevc::seq_parameter_set()
1579 {
1580 Element_Name("seq_parameter_set");
1581
1582 //Parsing
1583 seq_parameter_set_struct::vui_parameters_struct* vui_parameters_Item=NULL;
1584 int32u sps_seq_parameter_set_id, chroma_format_idc, pic_width_in_luma_samples, pic_height_in_luma_samples, bit_depth_luma_minus8, bit_depth_chroma_minus8, log2_max_pic_order_cnt_lsb_minus4, num_short_term_ref_pic_sets;
1585 int32u conf_win_left_offset=0, conf_win_right_offset=0, conf_win_top_offset=0, conf_win_bottom_offset=0, sps_max_num_reorder_pics=0;
1586 int8u video_parameter_set_id, max_sub_layers_minus1;
1587 bool separate_colour_plane_flag=false, sps_sub_layer_ordering_info_present_flag;
1588 BS_Begin();
1589 Get_S1 (4, video_parameter_set_id, "sps_video_parameter_set_id");
1590 std::vector<video_parameter_set_struct*>::iterator video_parameter_set_Item;
1591 if (video_parameter_set_id >= video_parameter_sets.size() || (*(video_parameter_set_Item = video_parameter_sets.begin() + video_parameter_set_id)) == NULL)
1592 {
1593 //Not yet present
1594 Skip_BS(Data_BS_Remain(), "Data (video_parameter_set is missing)");
1595 BS_End();
1596 RiskCalculationN++;
1597 RiskCalculationD++;
1598 return;
1599 }
1600 Get_S1 (3, max_sub_layers_minus1, "sps_max_sub_layers_minus1");
1601 Skip_SB( "sps_temporal_id_nesting_flag");
1602 profile_tier_level(max_sub_layers_minus1);
1603 Get_UE ( sps_seq_parameter_set_id, "sps_seq_parameter_set_id");
1604 if (MustParse_VPS_SPS_PPS_FromFlv)
1605 {
1606 BS_End();
1607 Skip_XX(Element_Size-Element_Offset, "Data");
1608
1609 //Creating Data
1610 if (sps_seq_parameter_set_id>=seq_parameter_sets.size())
1611 seq_parameter_sets.resize(sps_seq_parameter_set_id+1);
1612 std::vector<seq_parameter_set_struct*>::iterator Data_Item=seq_parameter_sets.begin()+sps_seq_parameter_set_id;
1613 delete *Data_Item; *Data_Item=new seq_parameter_set_struct(
1614 NULL, //TODO: check which code is intended here
1615 0,
1616 0,
1617 0,
1618 0,
1619 0,
1620 0,
1621 0,
1622 0,
1623 0,
1624 0,
1625 0,
1626 0,
1627 0,
1628 0,
1629 0,
1630 0,
1631 0,
1632 false,
1633 false,
1634 false,
1635 false
1636 );
1637
1638 //NextCode
1639 NextCode_Clear();
1640 NextCode_Add(34);
1641
1642 //Autorisation of other streams
1643 Streams[34].Searching_Payload=true; //pic_parameter_set
1644
1645 return;
1646 }
1647 Get_UE ( chroma_format_idc, "chroma_format_idc"); Param_Info1(Hevc_chroma_format_idc((int8u)chroma_format_idc));
1648 if (chroma_format_idc>=4)
1649 {
1650 Trusted_IsNot("chroma_format_idc not valid");
1651 RiskCalculationN++;
1652 RiskCalculationD++;
1653 BS_End();
1654 return; //Problem, not valid
1655 }
1656 if (chroma_format_idc==3)
1657 Get_SB (separate_colour_plane_flag, "separate_colour_plane_flag");
1658 Get_UE ( pic_width_in_luma_samples, "pic_width_in_luma_samples");
1659 Get_UE ( pic_height_in_luma_samples, "pic_height_in_luma_samples");
1660 TEST_SB_SKIP( "conformance_window_flag");
1661 Get_UE (conf_win_left_offset, "conf_win_left_offset");
1662 Get_UE (conf_win_right_offset, "conf_win_right_offset");
1663 Get_UE (conf_win_top_offset, "conf_win_top_offset");
1664 Get_UE (conf_win_bottom_offset, "conf_win_bottom_offset");
1665 TEST_SB_END();
1666 Get_UE ( bit_depth_luma_minus8, "bit_depth_luma_minus8");
1667 if (bit_depth_luma_minus8>6)
1668 {
1669 Trusted_IsNot("bit_depth_luma_minus8 not valid");
1670 RiskCalculationN++;
1671 RiskCalculationD++;
1672 return; //Problem, not valid
1673 }
1674 Get_UE ( bit_depth_chroma_minus8, "bit_depth_chroma_minus8");
1675 if (bit_depth_chroma_minus8>6)
1676 {
1677 Trusted_IsNot("bit_depth_chroma_minus8 not valid");
1678 RiskCalculationN++;
1679 RiskCalculationD++;
1680 return; //Problem, not valid
1681 }
1682 Get_UE ( log2_max_pic_order_cnt_lsb_minus4, "log2_max_pic_order_cnt_lsb_minus4");
1683 if (log2_max_pic_order_cnt_lsb_minus4>12)
1684 {
1685 Trusted_IsNot("log2_max_pic_order_cnt_lsb_minus4 not valid");
1686 RiskCalculationN++;
1687 RiskCalculationD++;
1688 return; //Problem, not valid
1689 }
1690 Get_SB ( sps_sub_layer_ordering_info_present_flag, "sps_sub_layer_ordering_info_present_flag");
1691 for (int32u SubLayerPos = (sps_sub_layer_ordering_info_present_flag ? 0 : max_sub_layers_minus1); SubLayerPos <= max_sub_layers_minus1; SubLayerPos++)
1692 {
1693 Element_Begin1("SubLayer");
1694 Skip_UE( "sps_max_dec_pic_buffering_minus1");
1695 Get_UE (sps_max_num_reorder_pics, "sps_max_num_reorder_pics");
1696 Skip_UE( "sps_max_latency_increase_plus1");
1697 Element_End0();
1698 }
1699 Skip_UE( "log2_min_luma_coding_block_size_minus3");
1700 Skip_UE( "log2_diff_max_min_luma_coding_block_size");
1701 Skip_UE( "log2_min_transform_block_size_minus2");
1702 Skip_UE( "log2_diff_max_min_transform_block_size");
1703 Skip_UE( "max_transform_hierarchy_depth_inter");
1704 Skip_UE( "max_transform_hierarchy_depth_intra");
1705 TEST_SB_SKIP( "scaling_list_enabled_flag");
1706 TEST_SB_SKIP( "sps_scaling_list_data_present_flag");
1707 scaling_list_data();
1708 TEST_SB_END();
1709 TEST_SB_END();
1710 Skip_SB( "amp_enabled_flag");
1711 Skip_SB( "sample_adaptive_offset_enabled_flag");
1712 TEST_SB_SKIP( "pcm_enabled_flag");
1713 Element_Begin1("pcm");
1714 Skip_S1(4, "pcm_sample_bit_depth_luma_minus1");
1715 Skip_S1(4, "pcm_sample_bit_depth_chroma_minus1");
1716 Skip_UE( "log2_min_pcm_luma_coding_block_size_minus3");
1717 Skip_UE( "log2_diff_max_min_pcm_luma_coding_block_size");
1718 Skip_SB( "pcm_loop_filter_disabled_flag");
1719 Element_End0();
1720 TEST_SB_END();
1721 Get_UE ( num_short_term_ref_pic_sets, "num_short_term_ref_pic_sets");
1722 if (num_short_term_ref_pic_sets>64)
1723 {
1724 BS_End();
1725 Trusted_IsNot("num_short_term_ref_pic_sets not valid");
1726 RiskCalculationN++;
1727 RiskCalculationD++;
1728 return; //Problem, not valid
1729 }
1730 short_term_ref_pic_sets((int8u)num_short_term_ref_pic_sets);
1731 TEST_SB_SKIP( "long_term_ref_pics_present_flag");
1732 Element_Begin1("long_term_ref_pics");
1733 int32u num_long_term_ref_pics_sps;
1734 Get_UE (num_long_term_ref_pics_sps, "num_long_term_ref_pics_sps");
1735 for (int32u long_term_ref_pics_sps_pos=0; long_term_ref_pics_sps_pos<num_long_term_ref_pics_sps; long_term_ref_pics_sps_pos++)
1736 {
1737 Skip_BS(log2_max_pic_order_cnt_lsb_minus4+4, "lt_ref_pic_poc_lsb_sps");
1738 Skip_SB( "used_by_curr_pic_lt_sps_flag");
1739 }
1740 Element_End0();
1741 TEST_SB_END();
1742 Skip_SB( "sps_temporal_mvp_enabled_flag");
1743 Skip_SB( "strong_intra_smoothing_enabled_flag");
1744 TEST_SB_SKIP( "vui_parameters_present_flag");
1745 vui_parameters(video_parameter_set_Item, vui_parameters_Item);
1746 TEST_SB_END();
1747 EndOfxPS( "sps_extension_flag", "sps_extension_data");
1748 BS_End();
1749
1750 FILLING_BEGIN_PRECISE();
1751 //Creating Data
1752 if (sps_seq_parameter_set_id>=seq_parameter_sets.size())
1753 seq_parameter_sets.resize(sps_seq_parameter_set_id+1);
1754 std::vector<seq_parameter_set_struct*>::iterator Data_Item=seq_parameter_sets.begin()+sps_seq_parameter_set_id;
1755 delete *Data_Item; *Data_Item=new seq_parameter_set_struct(
1756 vui_parameters_Item,
1757 profile_space,
1758 tier_flag,
1759 profile_idc,
1760 level_idc,
1761 pic_width_in_luma_samples,
1762 pic_height_in_luma_samples,
1763 conf_win_left_offset,
1764 conf_win_right_offset,
1765 conf_win_top_offset,
1766 conf_win_bottom_offset,
1767 (int8u)video_parameter_set_id,
1768 (int8u)chroma_format_idc,
1769 separate_colour_plane_flag,
1770 (int8u)log2_max_pic_order_cnt_lsb_minus4,
1771 (int8u)bit_depth_luma_minus8,
1772 (int8u)bit_depth_chroma_minus8,
1773 (int8u)sps_max_num_reorder_pics,
1774 general_progressive_source_flag,
1775 general_interlaced_source_flag,
1776 general_frame_only_constraint_flag,
1777 general_max_8bit_constraint_flag
1778 );
1779
1780 //NextCode
1781 NextCode_Clear();
1782 NextCode_Add(34);
1783
1784 //Autorisation of other streams
1785 Streams[34].Searching_Payload=true; //pic_parameter_set
1786
1787 //Computing values (for speed)
1788 size_t MaxNumber=(int32u)std::pow(2.0, (int)((*Data_Item)->log2_max_pic_order_cnt_lsb_minus4 + 4)); // TODO
1789 /*
1790 switch (Data_Item_New->pic_order_cnt_type)
1791 {
1792 case 0 :
1793 MaxNumber=Data_Item_New->MaxPicOrderCntLsb;
1794 break;
1795 case 1 :
1796 case 2 :
1797 MaxNumber=Data_Item_New->MaxFrameNum*2;
1798 break;
1799 default:
1800 MaxNumber = 0;
1801 }
1802 */
1803
1804 if (MaxNumber>TemporalReferences_Reserved)
1805 {
1806 TemporalReferences.resize(4*MaxNumber);
1807 TemporalReferences_Reserved=MaxNumber;
1808 }
1809 FILLING_ELSE();
1810 delete vui_parameters_Item; //vui_parameters_Item=NULL;
1811 FILLING_END();
1812 }
1813
1814 //---------------------------------------------------------------------------
1815 // Packet "34"
pic_parameter_set()1816 void File_Hevc::pic_parameter_set()
1817 {
1818 Element_Name("pic_parameter_set");
1819
1820 //Parsing
1821 int32u pps_pic_parameter_set_id, pps_seq_parameter_set_id, num_ref_idx_l0_default_active_minus1, num_ref_idx_l1_default_active_minus1;
1822 int8u num_extra_slice_header_bits;
1823 bool tiles_enabled_flag, dependent_slice_segments_enabled_flag;
1824 BS_Begin();
1825 Get_UE ( pps_pic_parameter_set_id, "pps_pic_parameter_set_id");
1826 if (pps_pic_parameter_set_id>=64)
1827 {
1828 Trusted_IsNot("pic_parameter_set_id not valid");
1829 BS_End();
1830 RiskCalculationN++;
1831 RiskCalculationD++;
1832 return; //Problem, not valid
1833 }
1834 Get_UE ( pps_seq_parameter_set_id, "pps_seq_parameter_set_id");
1835 if (pps_seq_parameter_set_id>=16)
1836 {
1837 Trusted_IsNot("seq_parameter_set_id not valid");
1838 BS_End();
1839 RiskCalculationN++;
1840 RiskCalculationD++;
1841 return; //Problem, not valid
1842 }
1843 //std::vector<seq_parameter_set_struct*>::iterator seq_parameter_set_Item;
1844 if (pps_seq_parameter_set_id>=seq_parameter_sets.size() || (*(seq_parameter_sets.begin()+pps_seq_parameter_set_id))==NULL) //(seq_parameter_set_Item=seq_parameter_sets.begin()+pps_seq_parameter_set_id) not usd for the moment
1845 {
1846 //Not yet present
1847 Skip_BS(Data_BS_Remain(), "Data (seq_parameter_set is missing)");
1848 BS_End();
1849 RiskCalculationN++;
1850 RiskCalculationD++;
1851 return;
1852 }
1853 if (MustParse_VPS_SPS_PPS_FromFlv)
1854 {
1855 BS_End();
1856 Skip_XX(Element_Size-Element_Offset, "Data");
1857
1858 //Filling
1859 if (pps_pic_parameter_set_id>=pic_parameter_sets.size())
1860 pic_parameter_sets.resize(pps_pic_parameter_set_id+1);
1861 std::vector<pic_parameter_set_struct*>::iterator pic_parameter_sets_Item=pic_parameter_sets.begin()+pps_pic_parameter_set_id;
1862 delete *pic_parameter_sets_Item; *pic_parameter_sets_Item=new pic_parameter_set_struct(
1863 0,
1864 0,
1865 0,
1866 0,
1867 false
1868 );
1869
1870 //NextCode
1871 NextCode_Clear();
1872
1873 //Autorisation of other streams
1874 Streams[ 0].Searching_Payload=true; //slice_segment_layer
1875 Streams[ 1].Searching_Payload=true; //slice_segment_layer
1876 Streams[ 2].Searching_Payload=true; //slice_segment_layer
1877 Streams[ 3].Searching_Payload=true; //slice_segment_layer
1878 Streams[ 4].Searching_Payload=true; //slice_layer
1879 Streams[ 5].Searching_Payload=true; //slice_layer
1880 Streams[ 6].Searching_Payload=true; //slice_layer
1881 Streams[ 7].Searching_Payload=true; //slice_layer
1882 Streams[ 8].Searching_Payload=true; //slice_layer
1883 Streams[ 9].Searching_Payload=true; //slice_layer
1884 Streams[16].Searching_Payload=true; //slice_segment_layer
1885 Streams[17].Searching_Payload=true; //slice_segment_layer
1886 Streams[18].Searching_Payload=true; //slice_segment_layer
1887 Streams[19].Searching_Payload=true; //slice_segment_layer
1888 Streams[20].Searching_Payload=true; //slice_segment_layer
1889 Streams[21].Searching_Payload=true; //slice_segment_layer
1890
1891 return;
1892 }
1893 Get_SB ( dependent_slice_segments_enabled_flag, "dependent_slice_segments_enabled_flag");
1894 Skip_SB( "output_flag_present_flag");
1895 Get_S1 (3, num_extra_slice_header_bits, "num_extra_slice_header_bits");
1896 Skip_SB( "sign_data_hiding_flag");
1897 Skip_SB( "cabac_init_present_flag");
1898 Get_UE ( num_ref_idx_l0_default_active_minus1, "num_ref_idx_l0_default_active_minus1");
1899 Get_UE ( num_ref_idx_l1_default_active_minus1, "num_ref_idx_l1_default_active_minus1");
1900 Skip_SE( "init_qp_minus26");
1901 Skip_SB( "constrained_intra_pred_flag");
1902 Skip_SB( "transform_skip_enabled_flag");
1903 TEST_SB_SKIP( "cu_qp_delta_enabled_flag");
1904 Skip_UE( "diff_cu_qp_delta_depth");
1905 TEST_SB_END();
1906 Skip_SE( "pps_cb_qp_offset");
1907 Skip_SE( "pps_cr_qp_offset");
1908 Skip_SB( "pps_slice_chroma_qp_offsets_present_flag");
1909 Skip_SB( "weighted_pred_flag");
1910 Skip_SB( "weighted_bipred_flag");
1911 Skip_SB( "transquant_bypass_enable_flag");
1912 Get_SB ( tiles_enabled_flag, "tiles_enabled_flag");
1913 Skip_SB( "entropy_coding_sync_enabled_flag");
1914 if (tiles_enabled_flag)
1915 {
1916 Element_Begin1("tiles");
1917 int32u num_tile_columns_minus1, num_tile_rows_minus1;
1918 bool uniform_spacing_flag;
1919 Get_UE ( num_tile_columns_minus1, "num_tile_columns_minus1");
1920 Get_UE ( num_tile_rows_minus1, "num_tile_rows_minus1");
1921 Get_SB ( uniform_spacing_flag, "uniform_spacing_flag");
1922 if (!uniform_spacing_flag)
1923 {
1924 for (int32u tile_pos=0; tile_pos<num_tile_columns_minus1; tile_pos++)
1925 Skip_UE( "column_width_minus1");
1926 for (int32u tile_pos=0; tile_pos<num_tile_rows_minus1; tile_pos++)
1927 Skip_UE( "row_height_minus1");
1928 }
1929 Skip_SB( "loop_filter_across_tiles_enabled_flag");
1930 Element_End0();
1931 }
1932 Skip_SB( "pps_loop_filter_across_slices_enabled_flag");
1933 TEST_SB_SKIP( "deblocking_filter_control_present_flag");
1934 bool pps_disable_deblocking_filter_flag;
1935 Skip_SB( "deblocking_filter_override_enabled_flag");
1936 Get_SB ( pps_disable_deblocking_filter_flag, "pps_disable_deblocking_filter_flag");
1937 if (!pps_disable_deblocking_filter_flag)
1938 {
1939 Skip_SE( "pps_beta_offset_div2");
1940 Skip_SE( "pps_tc_offset_div2");
1941 }
1942 TEST_SB_END();
1943 TEST_SB_SKIP( "pps_scaling_list_data_present_flag ");
1944 scaling_list_data();
1945 TEST_SB_END();
1946 Skip_SB( "lists_modification_present_flag");
1947 Skip_UE( "log2_parallel_merge_level_minus2");
1948 Skip_SB( "slice_segment_header_extension_present_flag");
1949 EndOfxPS( "pps_extension_flag", "pps_extension_data");
1950 BS_End();
1951
1952 FILLING_BEGIN_PRECISE();
1953 //NextCode
1954 //NextCode_Clear();
1955 //NextCode_Add(0x05);
1956 //NextCode_Add(0x06);
1957
1958 //Filling
1959 if (pps_pic_parameter_set_id>=pic_parameter_sets.size())
1960 pic_parameter_sets.resize(pps_pic_parameter_set_id+1);
1961 std::vector<pic_parameter_set_struct*>::iterator pic_parameter_sets_Item=pic_parameter_sets.begin()+pps_pic_parameter_set_id;
1962 delete *pic_parameter_sets_Item; *pic_parameter_sets_Item = new pic_parameter_set_struct(
1963 (int8u)pps_seq_parameter_set_id,
1964 (int8u)num_ref_idx_l0_default_active_minus1,
1965 (int8u)num_ref_idx_l1_default_active_minus1,
1966 num_extra_slice_header_bits,
1967 dependent_slice_segments_enabled_flag
1968 );
1969 //Autorisation of other streams
1970 //if (!seq_parameter_sets.empty())
1971 //{
1972 // for (int8u Pos=0x01; Pos<=0x06; Pos++)
1973 // {
1974 // Streams[Pos].Searching_Payload=true; //Coded slice...
1975 // if (Streams[0x08].ShouldDuplicate)
1976 // Streams[Pos].ShouldDuplicate=true;
1977 // }
1978 //}
1979
1980 //NextCode
1981 NextCode_Clear();
1982
1983 //Autorisation of other streams
1984 Streams[ 0].Searching_Payload=true; //slice_segment_layer
1985 Streams[ 1].Searching_Payload=true; //slice_segment_layer
1986 Streams[ 2].Searching_Payload=true; //slice_segment_layer
1987 Streams[ 3].Searching_Payload=true; //slice_segment_layer
1988 Streams[ 4].Searching_Payload=true; //slice_layer
1989 Streams[ 5].Searching_Payload=true; //slice_layer
1990 Streams[ 6].Searching_Payload=true; //slice_layer
1991 Streams[ 7].Searching_Payload=true; //slice_layer
1992 Streams[ 8].Searching_Payload=true; //slice_layer
1993 Streams[ 9].Searching_Payload=true; //slice_layer
1994 Streams[16].Searching_Payload=true; //slice_segment_layer
1995 Streams[17].Searching_Payload=true; //slice_segment_layer
1996 Streams[18].Searching_Payload=true; //slice_segment_layer
1997 Streams[19].Searching_Payload=true; //slice_segment_layer
1998 Streams[20].Searching_Payload=true; //slice_segment_layer
1999 Streams[21].Searching_Payload=true; //slice_segment_layer
2000 FILLING_END();
2001 }
2002
2003 //---------------------------------------------------------------------------
2004 // Packet "35"
access_unit_delimiter()2005 void File_Hevc::access_unit_delimiter()
2006 {
2007 Element_Name("access_unit_delimiter");
2008
2009 //Parsing
2010 BS_Begin();
2011 Info_S1( 3, pic_type, "pic_type"); Param_Info1(Hevc_pic_type[pic_type]);
2012 Mark_1();
2013 BS_End();
2014
2015 FILLING_BEGIN_PRECISE();
2016 FILLING_ELSE();
2017 RiskCalculationN++;
2018 FILLING_END();
2019 RiskCalculationD++;
2020 }
2021
2022 //---------------------------------------------------------------------------
2023 // Packet "36"
end_of_seq()2024 void File_Hevc::end_of_seq()
2025 {
2026 Element_Name("end_of_seq");
2027 }
2028
2029 //---------------------------------------------------------------------------
2030 // Packet "37"
end_of_bitstream()2031 void File_Hevc::end_of_bitstream()
2032 {
2033 Element_Name("end_of_bitstream");
2034 }
2035
2036 //---------------------------------------------------------------------------
2037 // Packet "38"
filler_data()2038 void File_Hevc::filler_data()
2039 {
2040 Element_Name("filler_data");
2041
2042 //Parsing
2043 Skip_XX(Element_Size, "ff_bytes");
2044 }
2045
2046 //---------------------------------------------------------------------------
2047 // Packet "39" or "40
sei()2048 void File_Hevc::sei()
2049 {
2050 Element_Name("sei");
2051
2052 //Parsing
2053 int32u seq_parameter_set_id=(int32u)-1;
2054 while(Element_Offset+1<Element_Size)
2055 {
2056 Element_Begin1("sei message");
2057 sei_message(seq_parameter_set_id);
2058 Element_End0();
2059 }
2060 BS_Begin();
2061 if (!Data_BS_Remain() || !Peek_SB())
2062 {
2063 Fill(Stream_Video, 0, "SEI_rbsp_stop_one_bit", "Missing", Unlimited, true, true);
2064 RiskCalculationN++;
2065 RiskCalculationD++;
2066 }
2067 else
2068 rbsp_trailing_bits();
2069 BS_End();
2070
2071 FILLING_BEGIN_PRECISE();
2072 FILLING_ELSE();
2073 RiskCalculationN++;
2074 FILLING_END();
2075 RiskCalculationD++;
2076 }
2077
2078 //---------------------------------------------------------------------------
sei_message(int32u & seq_parameter_set_id)2079 void File_Hevc::sei_message(int32u &seq_parameter_set_id)
2080 {
2081 //Parsing
2082 int32u payloadType=0, payloadSize=0;
2083 int8u payload_type_byte, payload_size_byte;
2084 Element_Begin1("sei message header");
2085 do
2086 {
2087 Get_B1 (payload_type_byte, "payload_type_byte");
2088 payloadType+=payload_type_byte;
2089 }
2090 while(payload_type_byte==0xFF);
2091 do
2092 {
2093 Get_B1 (payload_size_byte, "payload_size_byte");
2094 payloadSize+=payload_size_byte;
2095 }
2096 while(payload_size_byte==0xFF);
2097 Element_End0();
2098
2099 //Manage buggy files not having final bit stop
2100 const int8u* Buffer_Buggy;
2101 int64u Buffer_Offset_Buggy, Element_Size_Buggy;
2102 if (Element_Offset+payloadSize>Element_Size)
2103 {
2104 Buffer_Buggy=Buffer;
2105 Buffer_Offset_Buggy=Buffer_Offset;
2106 Element_Size_Buggy=Element_Size;
2107 Element_Size=Element_Offset+payloadSize;
2108 Buffer=new int8u[(size_t)Element_Size];
2109 Buffer_Offset=0;
2110 memcpy((void*)Buffer, Buffer_Buggy+Buffer_Offset, (size_t)Element_Size_Buggy);
2111 memset((void*)(Buffer+(size_t)Element_Size_Buggy), 0x00, (size_t)(Element_Size-Element_Size_Buggy)); //Last 0x00 bytes are discarded, we recreate them
2112 }
2113 else
2114 Buffer_Buggy=NULL;
2115
2116 int64u Element_Offset_Save=Element_Offset+payloadSize;
2117 if (Element_Offset_Save>Element_Size)
2118 {
2119 Trusted_IsNot("Wrong size");
2120 Skip_XX(Element_Size-Element_Offset, "unknown");
2121 return;
2122 }
2123 int64u Element_Size_Save=Element_Size;
2124 Element_Size=Element_Offset_Save;
2125 switch (payloadType)
2126 {
2127 case 0 : sei_message_buffering_period(seq_parameter_set_id, payloadSize); break;
2128 case 1 : sei_message_pic_timing(seq_parameter_set_id, payloadSize); break;
2129 case 4 : sei_message_user_data_registered_itu_t_t35(); break;
2130 case 5 : sei_message_user_data_unregistered(payloadSize); break;
2131 case 6 : sei_message_recovery_point(); break;
2132 //case 32 : sei_message_mainconcept(payloadSize); break;
2133 case 129 : sei_message_active_parameter_sets(); break;
2134 case 132 : sei_message_decoded_picture_hash(payloadSize); break;
2135 case 137 : sei_message_mastering_display_colour_volume(); break;
2136 case 144 : sei_message_light_level(); break;
2137 case 147 : sei_alternative_transfer_characteristics(); break;
2138 default :
2139 Element_Info1("unknown");
2140 Skip_XX(payloadSize, "data");
2141 }
2142 Element_Offset=Element_Offset_Save; //Positionning in the right place.
2143 Element_Size=Element_Size_Save; //Positionning in the right place.
2144
2145 //Manage buggy files not having final bit stop
2146 if (Buffer_Buggy)
2147 {
2148 delete[] Buffer;
2149 Buffer=Buffer_Buggy;
2150 Buffer_Offset=Buffer_Offset_Buggy;
2151 Element_Size=Element_Size_Buggy;
2152 }
2153 }
2154
2155 //---------------------------------------------------------------------------
2156 // SEI - 0
sei_message_buffering_period(int32u & seq_parameter_set_id,int32u payloadSize)2157 void File_Hevc::sei_message_buffering_period(int32u &seq_parameter_set_id, int32u payloadSize)
2158 {
2159 Element_Info1("buffering_period");
2160
2161 //Parsing
2162 if (Element_Offset==Element_Size)
2163 return; //Nothing to do
2164 BS_Begin();
2165 Get_UE (seq_parameter_set_id, "seq_parameter_set_id");
2166 std::vector<seq_parameter_set_struct*>::iterator seq_parameter_set_Item;
2167 if (seq_parameter_set_id>=seq_parameter_sets.size() || (*(seq_parameter_set_Item=seq_parameter_sets.begin()+seq_parameter_set_id))==NULL)
2168 {
2169 //Not yet present
2170 Skip_BS(Data_BS_Remain(), "Data (seq_parameter_set is missing)");
2171 BS_End();
2172 RiskCalculationN++;
2173 RiskCalculationD++;
2174 return;
2175 }
2176 bool sub_pic_hrd_params_present_flag=false; //Default
2177 bool irap_cpb_params_present_flag=((*seq_parameter_set_Item)->vui_parameters && (*seq_parameter_set_Item)->vui_parameters->xxL_Common)?(*seq_parameter_set_Item)->vui_parameters->xxL_Common->sub_pic_hrd_params_present_flag:false;
2178 if (!sub_pic_hrd_params_present_flag)
2179 Get_SB (irap_cpb_params_present_flag, "irap_cpb_params_present_flag");
2180 int8u au_cpb_removal_delay_length_minus1=((*seq_parameter_set_Item)->vui_parameters && (*seq_parameter_set_Item)->vui_parameters->xxL_Common)?(*seq_parameter_set_Item)->vui_parameters->xxL_Common->au_cpb_removal_delay_length_minus1:23;
2181 int8u dpb_output_delay_length_minus1=((*seq_parameter_set_Item)->vui_parameters && (*seq_parameter_set_Item)->vui_parameters->xxL_Common)?(*seq_parameter_set_Item)->vui_parameters->xxL_Common->dpb_output_delay_length_minus1:23;
2182 if (irap_cpb_params_present_flag)
2183 {
2184 Skip_S4(au_cpb_removal_delay_length_minus1+1, "cpb_delay_offset");
2185 Skip_S4(dpb_output_delay_length_minus1+1, "dpb_delay_offset");
2186 }
2187 Skip_SB( "concatenation_flag");
2188 Skip_S4(au_cpb_removal_delay_length_minus1+1, "au_cpb_removal_delay_delta_minus1");
2189 if ((*seq_parameter_set_Item)->NalHrdBpPresentFlag())
2190 sei_message_buffering_period_xxl((*seq_parameter_set_Item)->vui_parameters?(*seq_parameter_set_Item)->vui_parameters->xxL_Common:NULL, irap_cpb_params_present_flag, (*seq_parameter_set_Item)->vui_parameters->NAL);
2191 if ((*seq_parameter_set_Item)->VclHrdBpPresentFlag())
2192 sei_message_buffering_period_xxl((*seq_parameter_set_Item)->vui_parameters?(*seq_parameter_set_Item)->vui_parameters->xxL_Common:NULL, irap_cpb_params_present_flag, (*seq_parameter_set_Item)->vui_parameters->VCL);
2193 BS_End();
2194 }
2195
sei_message_buffering_period_xxl(seq_parameter_set_struct::vui_parameters_struct::xxl_common * xxL_Common,bool irap_cpb_params_present_flag,seq_parameter_set_struct::vui_parameters_struct::xxl * xxl)2196 void File_Hevc::sei_message_buffering_period_xxl(seq_parameter_set_struct::vui_parameters_struct::xxl_common* xxL_Common, bool irap_cpb_params_present_flag, seq_parameter_set_struct::vui_parameters_struct::xxl* xxl)
2197 {
2198 if (xxL_Common==NULL || xxl==NULL)
2199 {
2200 //Problem?
2201 Skip_BS(Data_BS_Remain(), "Problem?");
2202 return;
2203 }
2204 for (int32u SchedSelIdx=0; SchedSelIdx<xxl->SchedSel.size(); SchedSelIdx++)
2205 {
2206 //Get_S4 (xxl->SchedSel[SchedSelIdx].initial_cpb_removal_delay_length_minus1+1, xxl->SchedSel[SchedSelIdx].initial_cpb_removal_delay, "initial_cpb_removal_delay"); Param_Info2(xxl->SchedSel[SchedSelIdx].initial_cpb_removal_delay/90, " ms");
2207 //Get_S4 (xxl->SchedSel[SchedSelIdx].initial_cpb_removal_delay_length_minus1+1, xxl->SchedSel[SchedSelIdx].initial_cpb_removal_delay_offset, "initial_cpb_removal_delay_offset"); Param_Info2(xxl->SchedSel[SchedSelIdx].initial_cpb_removal_delay_offset/90, " ms");
2208 Info_S4 (xxL_Common->initial_cpb_removal_delay_length_minus1+1, initial_cpb_removal_delay, "initial_cpb_removal_delay"); Param_Info2(initial_cpb_removal_delay/90, " ms");
2209 Info_S4 (xxL_Common->initial_cpb_removal_delay_length_minus1+1, initial_cpb_removal_delay_offset, "initial_cpb_removal_delay_offset"); Param_Info2(initial_cpb_removal_delay_offset/90, " ms");
2210 if (xxL_Common->sub_pic_hrd_params_present_flag || irap_cpb_params_present_flag)
2211 {
2212 Info_S4 (xxL_Common->initial_cpb_removal_delay_length_minus1+1, initial_alt_cpb_removal_delay, "initial_alt_cpb_removal_delay"); Param_Info2(initial_alt_cpb_removal_delay/90, " ms");
2213 Info_S4 (xxL_Common->initial_cpb_removal_delay_length_minus1+1, initial_alt_cpb_removal_delay_offset, "initial_alt_cpb_removal_delay_offset"); Param_Info2(initial_alt_cpb_removal_delay_offset/90, " ms");
2214 }
2215 }
2216 }
2217
2218 //---------------------------------------------------------------------------
2219 // SEI - 1
sei_message_pic_timing(int32u & seq_parameter_set_id,int32u payloadSize)2220 void File_Hevc::sei_message_pic_timing(int32u &seq_parameter_set_id, int32u payloadSize)
2221 {
2222 Element_Info1("pic_timing");
2223
2224 //Testing if we can parsing it now. TODO: handle case seq_parameter_set_id is unknown (buffering of message, decoding in slice parsing)
2225 if (seq_parameter_set_id==(int32u)-1 && seq_parameter_sets.size()==1)
2226 seq_parameter_set_id=0;
2227 std::vector<seq_parameter_set_struct*>::iterator seq_parameter_set_Item;
2228 if (seq_parameter_set_id>=seq_parameter_sets.size() || (*(seq_parameter_set_Item=seq_parameter_sets.begin()+seq_parameter_set_id))==NULL)
2229 {
2230 //Not yet present
2231 Skip_BS(Data_BS_Remain(), "Data (seq_parameter_set is missing)");
2232 return;
2233 }
2234
2235 //Parsing
2236 BS_Begin();
2237 if ((*seq_parameter_set_Item)->vui_parameters?(*seq_parameter_set_Item)->vui_parameters->frame_field_info_present_flag:((*seq_parameter_set_Item)->general_progressive_source_flag && (*seq_parameter_set_Item)->general_interlaced_source_flag))
2238 {
2239 Skip_S1(4, "pic_struct");
2240 Skip_S1(2, "source_scan_type");
2241 Skip_SB( "duplicate_flag");
2242 }
2243 if ((*seq_parameter_set_Item)->CpbDpbDelaysPresentFlag())
2244 {
2245 int8u au_cpb_removal_delay_length_minus1=(*seq_parameter_set_Item)->vui_parameters->xxL_Common->au_cpb_removal_delay_length_minus1;
2246 int8u dpb_output_delay_length_minus1=(*seq_parameter_set_Item)->vui_parameters->xxL_Common->dpb_output_delay_length_minus1;
2247 bool sub_pic_hrd_params_present_flag=(*seq_parameter_set_Item)->vui_parameters->xxL_Common->sub_pic_hrd_params_present_flag;
2248 Skip_S4(au_cpb_removal_delay_length_minus1+1, "au_cpb_removal_delay_minus1");
2249 Skip_S4(dpb_output_delay_length_minus1+1, "pic_dpb_output_delay");
2250 if (sub_pic_hrd_params_present_flag)
2251 {
2252 int8u dpb_output_delay_du_length_minus1=(*seq_parameter_set_Item)->vui_parameters->xxL_Common->dpb_output_delay_du_length_minus1;
2253 Skip_S4(dpb_output_delay_du_length_minus1+1, "pic_dpb_output_du_delay");
2254 }
2255 }
2256 BS_End();
2257 }
2258
2259 //---------------------------------------------------------------------------
2260 // SEI - 4
sei_message_user_data_registered_itu_t_t35()2261 void File_Hevc::sei_message_user_data_registered_itu_t_t35()
2262 {
2263 Element_Info1("user_data_registered_itu_t_t35");
2264
2265 int8u itu_t_t35_country_code;
2266 Get_B1(itu_t_t35_country_code, "itu_t_t35_country_code");
2267
2268 switch (itu_t_t35_country_code)
2269 {
2270 case 0xB5: sei_message_user_data_registered_itu_t_t35_B5(); break; // USA
2271 }
2272 }
2273
2274 //---------------------------------------------------------------------------
2275 // SEI - 4 - USA
sei_message_user_data_registered_itu_t_t35_B5()2276 void File_Hevc::sei_message_user_data_registered_itu_t_t35_B5()
2277 {
2278 int16u itu_t_t35_terminal_provider_code;
2279 Get_B2 (itu_t_t35_terminal_provider_code, "itu_t_t35_terminal_provider_code");
2280
2281 switch (itu_t_t35_terminal_provider_code)
2282 {
2283 case 0x0031: sei_message_user_data_registered_itu_t_t35_B5_0031(); break;
2284 case 0x003A: sei_message_user_data_registered_itu_t_t35_B5_003A(); break;
2285 case 0x003C: sei_message_user_data_registered_itu_t_t35_B5_003C(); break;
2286 }
2287 }
2288
2289 //---------------------------------------------------------------------------
2290 // SEI - 4 - USA - 0031
sei_message_user_data_registered_itu_t_t35_B5_0031()2291 void File_Hevc::sei_message_user_data_registered_itu_t_t35_B5_0031()
2292 {
2293 int32u Identifier;
2294 Peek_B4(Identifier);
2295 switch (Identifier)
2296 {
2297 case 0x47413934 : sei_message_user_data_registered_itu_t_t35_B5_0031_GA94(); return;
2298 default : if (Element_Size-Element_Offset)
2299 Skip_XX(Element_Size-Element_Offset, "Unknown");
2300 }
2301 }
2302
2303 //---------------------------------------------------------------------------
2304 // SEI - 4 - USA - 0031 - GA94
sei_message_user_data_registered_itu_t_t35_B5_0031_GA94()2305 void File_Hevc::sei_message_user_data_registered_itu_t_t35_B5_0031_GA94()
2306 {
2307 //Parsing
2308 int8u user_data_type_code;
2309 Skip_B4("GA94_identifier");
2310 Get_B1(user_data_type_code, "user_data_type_code");
2311 switch (user_data_type_code)
2312 {
2313 case 0x03: sei_message_user_data_registered_itu_t_t35_B5_0031_GA94_03(); break;
2314 default: Skip_XX(Element_Size - Element_Offset, "GA94_reserved_user_data");
2315 }
2316 }
2317
2318 //---------------------------------------------------------------------------
2319 // SEI - 4 - USA - 0031 - GA94 - 03
sei_message_user_data_registered_itu_t_t35_B5_0031_GA94_03()2320 void File_Hevc::sei_message_user_data_registered_itu_t_t35_B5_0031_GA94_03()
2321 {
2322 #if defined(MEDIAINFO_DTVCCTRANSPORT_YES)
2323 GA94_03_IsPresent=true;
2324 MustExtendParsingDuration=true;
2325 Buffer_TotalBytes_Fill_Max=(int64u)-1; //Disabling this feature for this format, this is done in the parser
2326
2327 Element_Info1("DTVCC Transport");
2328
2329 //Coherency
2330 delete TemporalReferences_DelayedElement; TemporalReferences_DelayedElement=new temporal_reference();
2331
2332 TemporalReferences_DelayedElement->GA94_03=new buffer_data(Buffer+Buffer_Offset+(size_t)Element_Offset,(size_t)(Element_Size-Element_Offset));
2333
2334 //Parsing
2335 Skip_XX(Element_Size-Element_Offset, "CC data");
2336 #else //defined(MEDIAINFO_DTVCCTRANSPORT_YES)
2337 Skip_XX(Element_Size-Element_Offset, "DTVCC Transport data");
2338 #endif //defined(MEDIAINFO_DTVCCTRANSPORT_YES)
2339 }
2340
sei_message_user_data_registered_itu_t_t35_B5_0031_GA94_03_Delayed(int32u seq_parameter_set_id)2341 void File_Hevc::sei_message_user_data_registered_itu_t_t35_B5_0031_GA94_03_Delayed(int32u seq_parameter_set_id)
2342 {
2343 // Skipping missing frames
2344 if (TemporalReferences_Max-TemporalReferences_Min>(size_t)(4*(seq_parameter_sets[seq_parameter_set_id]->sps_max_num_reorder_pics+3))) // max_num_ref_frames ref frame maximum
2345 {
2346 size_t TemporalReferences_Min_New=TemporalReferences_Max-4*(seq_parameter_sets[seq_parameter_set_id]->sps_max_num_reorder_pics+3);
2347 while (TemporalReferences_Min_New>TemporalReferences_Min && TemporalReferences[TemporalReferences_Min_New-1])
2348 TemporalReferences_Min_New--;
2349 TemporalReferences_Min=TemporalReferences_Min_New;
2350 while (TemporalReferences[TemporalReferences_Min]==NULL)
2351 TemporalReferences_Min++;
2352 }
2353
2354 // Parsing captions
2355 while (TemporalReferences[TemporalReferences_Min] && TemporalReferences_Min+2*seq_parameter_sets[seq_parameter_set_id]->sps_max_num_reorder_pics<TemporalReferences_Max)
2356 {
2357 #if defined(MEDIAINFO_DTVCCTRANSPORT_YES)
2358 Element_Begin1("Reordered DTVCC Transport");
2359
2360 //Parsing
2361 #if MEDIAINFO_DEMUX
2362 int64u Element_Code_Old=Element_Code;
2363 Element_Code=0x4741393400000003LL;
2364 #endif //MEDIAINFO_DEMUX
2365 if (GA94_03_Parser==NULL)
2366 {
2367 GA94_03_Parser=new File_DtvccTransport;
2368 Open_Buffer_Init(GA94_03_Parser);
2369 ((File_DtvccTransport*)GA94_03_Parser)->Format=File_DtvccTransport::Format_A53_4_GA94_03;
2370 }
2371 if (((File_DtvccTransport*)GA94_03_Parser)->AspectRatio==0)
2372 {
2373 float64 PixelAspectRatio=1;
2374 std::vector<seq_parameter_set_struct*>::iterator seq_parameter_set_Item=seq_parameter_sets.begin();
2375 for (; seq_parameter_set_Item!=seq_parameter_sets.end(); ++seq_parameter_set_Item)
2376 if ((*seq_parameter_set_Item))
2377 break;
2378 if (seq_parameter_set_Item!=seq_parameter_sets.end())
2379 {
2380 if (((*seq_parameter_set_Item)->vui_parameters) && ((*seq_parameter_set_Item)->vui_parameters->aspect_ratio_info_present_flag))
2381 {
2382 if ((*seq_parameter_set_Item)->vui_parameters->aspect_ratio_idc<Avc_PixelAspectRatio_Size)
2383 PixelAspectRatio=Avc_PixelAspectRatio[(*seq_parameter_set_Item)->vui_parameters->aspect_ratio_idc];
2384 else if ((*seq_parameter_set_Item)->vui_parameters->aspect_ratio_idc==0xFF && (*seq_parameter_set_Item)->vui_parameters->sar_height)
2385 PixelAspectRatio=((float64)(*seq_parameter_set_Item)->vui_parameters->sar_width)/(*seq_parameter_set_Item)->vui_parameters->sar_height;
2386 }
2387 const int32u Width =(*seq_parameter_set_Item)->pic_width_in_luma_samples;
2388 const int32u Height=(*seq_parameter_set_Item)->pic_height_in_luma_samples;
2389 if(Height)
2390 ((File_DtvccTransport*)GA94_03_Parser)->AspectRatio=Width*PixelAspectRatio/Height;
2391 }
2392 }
2393 if (GA94_03_Parser->PTS_DTS_Needed)
2394 {
2395 GA94_03_Parser->FrameInfo.PCR=FrameInfo.PCR;
2396 GA94_03_Parser->FrameInfo.PTS=FrameInfo.PTS;
2397 GA94_03_Parser->FrameInfo.DTS=FrameInfo.DTS;
2398 }
2399 #if MEDIAINFO_DEMUX
2400 if (TemporalReferences[TemporalReferences_Min]->GA94_03)
2401 {
2402 int8u Demux_Level_Save=Demux_Level;
2403 Demux_Level=8; //Ancillary
2404 Demux(TemporalReferences[TemporalReferences_Min]->GA94_03->Data, TemporalReferences[TemporalReferences_Min]->GA94_03->Size, ContentType_MainStream);
2405 Demux_Level=Demux_Level_Save;
2406 }
2407 Element_Code=Element_Code_Old;
2408 #endif //MEDIAINFO_DEMUX
2409 if (TemporalReferences[TemporalReferences_Min]->GA94_03)
2410 {
2411 #if defined(MEDIAINFO_EIA608_YES) || defined(MEDIAINFO_EIA708_YES)
2412 GA94_03_Parser->ServiceDescriptors=ServiceDescriptors;
2413 #endif
2414 Open_Buffer_Continue(GA94_03_Parser, TemporalReferences[TemporalReferences_Min]->GA94_03->Data, TemporalReferences[TemporalReferences_Min]->GA94_03->Size);
2415 }
2416
2417 Element_End0();
2418 #endif //defined(MEDIAINFO_DTVCCTRANSPORT_YES)
2419
2420 //TemporalReferences_Min+=((seq_parameter_sets[seq_parameter_set_id]->frame_mbs_only_flag | !TemporalReferences[TemporalReferences_Min]->IsField)?2:1);
2421 TemporalReferences_Min++;
2422 }
2423 }
2424
2425 //---------------------------------------------------------------------------
2426 // SEI - 4 - USA - 003A
sei_message_user_data_registered_itu_t_t35_B5_003A()2427 void File_Hevc::sei_message_user_data_registered_itu_t_t35_B5_003A()
2428 {
2429 int8u itu_t_t35_terminal_provider_oriented_code;
2430 Get_B1 (itu_t_t35_terminal_provider_oriented_code, "itu_t_t35_terminal_provider_oriented_code");
2431
2432 switch (itu_t_t35_terminal_provider_oriented_code)
2433 {
2434 case 0x00: sei_message_user_data_registered_itu_t_t35_B5_003A_00(); break;
2435 case 0x02: sei_message_user_data_registered_itu_t_t35_B5_003A_02(); break;
2436 }
2437 }
2438
2439 //---------------------------------------------------------------------------
2440 // SEI - 4 - USA - 003A - ETSI 103-433-1
sei_message_user_data_registered_itu_t_t35_B5_003A_00()2441 void File_Hevc::sei_message_user_data_registered_itu_t_t35_B5_003A_00()
2442 {
2443 Element_Info1("SL-HDR message");
2444 BS_Begin();
2445 int8u sl_hdr_mode_value_minus1, sl_hdr_spec_major_version_idc, sl_hdr_spec_minor_version_idc;
2446 bool sl_hdr_cancel_flag;
2447 Get_S1 (4, sl_hdr_mode_value_minus1, "sl_hdr_mode_value_minus1");
2448 Get_S1 (4, sl_hdr_spec_major_version_idc, "sl_hdr_spec_major_version_idc");
2449 Get_S1 (7, sl_hdr_spec_minor_version_idc, "sl_hdr_spec_minor_version_idc");
2450 Get_SB (sl_hdr_cancel_flag, "sl_hdr_cancel_flag");
2451 int8u sl_hdr_payload_mode;
2452 int8u k_coefficient_value[3];
2453 if (!sl_hdr_cancel_flag)
2454 {
2455 mastering_metadata_2086 Meta;
2456 bool coded_picture_info_present_flag, target_picture_info_present_flag, src_mdcv_info_present_flag;
2457 Skip_SB( "sl_hdr_persistence_flag");
2458 Get_SB (coded_picture_info_present_flag, "coded_picture_info_present_flag");
2459 Get_SB (target_picture_info_present_flag, "target_picture_info_present_flag");
2460 Get_SB (src_mdcv_info_present_flag, "src_mdcv_info_present_flag");
2461 Skip_SB( "sl_hdr_extension_present_flag");
2462 Get_S1 (3, sl_hdr_payload_mode, "sl_hdr_payload_mode");
2463 BS_End();
2464 if (coded_picture_info_present_flag)
2465 {
2466 Skip_B1( "coded_picture_primaries");
2467 Skip_B2( "coded_picture_max_luminance");
2468 Skip_B2( "coded_picture_min_luminance");
2469 }
2470 if (target_picture_info_present_flag)
2471 {
2472 Skip_B1( "target_picture_primaries");
2473 Skip_B2( "target_picture_max_luminance");
2474 Skip_B2( "target_picture_min_luminance");
2475 }
2476 if (src_mdcv_info_present_flag)
2477 {
2478 int16u max, min;
2479 for (int8u i = 0; i < 3; i++)
2480 {
2481 Get_B2 (Meta.Primaries[i*2 ], "src_mdcv_primaries_x");
2482 Get_B2 (Meta.Primaries[i*2+1], "src_mdcv_primaries_y");
2483 }
2484 Get_B2 (Meta.Primaries[3*2 ], "src_mdcv_ref_white_x");
2485 Get_B2 (Meta.Primaries[3*2+1], "src_mdcv_ref_white_y");
2486 Get_B2 (max, "src_mdcv_max_mastering_luminance");
2487 Get_B2 (min, "src_mdcv_min_mastering_luminance");
2488 Meta.Luminance[0]=min;
2489 Meta.Luminance[1]=((int32u)max)*10000;
2490 }
2491 for (int8u i = 0; i < 4; i++)
2492 Skip_B2( "matrix_coefficient_value");
2493 for (int8u i = 0; i < 2; i++)
2494 Skip_B2( "chroma_to_luma_injection");
2495 for (int8u i = 0; i < 3; i++)
2496 Get_B1 (k_coefficient_value[i], "k_coefficient_value");
2497
2498 FILLING_BEGIN()
2499 std::map<video, Ztring>& EtsiTs103433=HDR[HdrFormat_EtsiTs103433];
2500 Ztring& HDR_Format=EtsiTs103433[Video_HDR_Format];
2501 if (HDR_Format.empty())
2502 {
2503 HDR_Format=__T("SL-HDR")+Ztring().From_Number(sl_hdr_mode_value_minus1+1);
2504 EtsiTs103433[Video_HDR_Format_Version]=Ztring().From_Number(sl_hdr_spec_major_version_idc)+__T('.')+Ztring().From_Number(sl_hdr_spec_minor_version_idc);
2505 Get_MasteringDisplayColorVolume(EtsiTs103433[Video_MasteringDisplay_ColorPrimaries], EtsiTs103433[Video_MasteringDisplay_Luminance], Meta);
2506 if (sl_hdr_payload_mode<2)
2507 EtsiTs103433[Video_HDR_Format_Settings]=sl_hdr_payload_mode?__T("Table-based"):__T("Parameter-based");
2508 else
2509 EtsiTs103433[Video_HDR_Format_Settings]=__T("Payload Mode ") + Ztring().From_Number(sl_hdr_payload_mode);
2510 if (!sl_hdr_mode_value_minus1)
2511 EtsiTs103433[Video_HDR_Format_Settings]+=k_coefficient_value[0]==0 && k_coefficient_value[1]==0 && k_coefficient_value[2]==0?__T(", non-constant"):__T(", constant");
2512
2513 EtsiTS103433 = __T("SL-HDR") + Ztring().From_Number(sl_hdr_mode_value_minus1 + 1);
2514 if (!sl_hdr_mode_value_minus1)
2515 EtsiTS103433 += k_coefficient_value[0] == 0 && k_coefficient_value[1] == 0 && k_coefficient_value[2] == 0 ? __T(" NCL") : __T(" CL");
2516 EtsiTS103433 += __T(" specVersion=") + Ztring().From_Number(sl_hdr_spec_major_version_idc) + __T(".") + Ztring().From_Number(sl_hdr_spec_minor_version_idc);
2517 EtsiTS103433 += __T(" payloadMode=") + Ztring().From_Number(sl_hdr_payload_mode);
2518 }
2519 FILLING_END();
2520 }
2521 else
2522 BS_End();
2523 }
2524
2525 //---------------------------------------------------------------------------
2526 // SEI - 4 - USA - 003A - ETSI 103-433
sei_message_user_data_registered_itu_t_t35_B5_003A_02()2527 void File_Hevc::sei_message_user_data_registered_itu_t_t35_B5_003A_02()
2528 {
2529 Element_Info1("SL-HDR information");
2530 int8u ts_103_433_spec_version;
2531 BS_Begin();
2532 Get_S1 (4, ts_103_433_spec_version, "ts_103_433_spec_version");
2533 if (ts_103_433_spec_version==0)
2534 {
2535 Skip_S1 (4, "ts_103_433_payload_mode");
2536 }
2537 else if (ts_103_433_spec_version==1)
2538 {
2539 Skip_S1 (3, "sl_hdr_mode_support");
2540 }
2541 else
2542 Skip_S1 (Data_BS_Remain(), "Unknown");
2543 BS_End();
2544 }
2545
2546 //---------------------------------------------------------------------------
2547 // SEI - 4 - USA - 003C
sei_message_user_data_registered_itu_t_t35_B5_003C()2548 void File_Hevc::sei_message_user_data_registered_itu_t_t35_B5_003C()
2549 {
2550 int16u itu_t_t35_terminal_provider_oriented_code;
2551 Get_B2 (itu_t_t35_terminal_provider_oriented_code, "itu_t_t35_terminal_provider_oriented_code");
2552
2553 switch (itu_t_t35_terminal_provider_oriented_code)
2554 {
2555 case 0x0001: sei_message_user_data_registered_itu_t_t35_B5_003C_0001(); break;
2556 }
2557 }
2558
2559 //---------------------------------------------------------------------------
2560 // SEI - 4 - USA - 003C - 0001
sei_message_user_data_registered_itu_t_t35_B5_003C_0001()2561 void File_Hevc::sei_message_user_data_registered_itu_t_t35_B5_003C_0001()
2562 {
2563 int8u application_identifier;
2564 Get_B1 (application_identifier, "application_identifier");
2565
2566 switch (application_identifier)
2567 {
2568 case 0x04: sei_message_user_data_registered_itu_t_t35_B5_003C_0001_04(); break;
2569 }
2570 }
2571
2572 //---------------------------------------------------------------------------
2573 // SEI - 4 - USA - 003C - 0001 - SMPTE ST 2094-40 (HDR10+)
sei_message_user_data_registered_itu_t_t35_B5_003C_0001_04()2574 void File_Hevc::sei_message_user_data_registered_itu_t_t35_B5_003C_0001_04()
2575 {
2576 Element_Info1("SMPTE ST 2094 App 4");
2577 int8u application_version;
2578 bool IsHDRplus=false, tone_mapping_flag;
2579 Get_B1 (application_version, "application_version");
2580 if (application_version==1)
2581 {
2582 int32u targeted_system_display_maximum_luminance, maxscl[4], distribution_maxrgb_percentiles[16];
2583 int16u fraction_bright_pixels;
2584 int8u num_distribution_maxrgb_percentiles, distribution_maxrgb_percentages[16], num_windows, num_bezier_curve_anchors;
2585 bool targeted_system_display_actual_peak_luminance_flag, mastering_display_actual_peak_luminance_flag, color_saturation_mapping_flag;
2586 BS_Begin();
2587 Get_S1 ( 2, num_windows, "num_windows");
2588
2589 for (int8u w=1; w<num_windows; w++)
2590 {
2591 Element_Begin1("window");
2592 Skip_S2(16, "window_upper_left_corner_x");
2593 Skip_S2(16, "window_upper_left_corner_y");
2594 Skip_S2(16, "window_lower_right_corner_x");
2595 Skip_S2(16, "window_lower_right_corner_y");
2596 Skip_S2(16, "center_of_ellipse_x");
2597 Skip_S2(16, "center_of_ellipse_y");
2598 Skip_S1( 8, "rotation_angle");
2599 Skip_S2(16, "semimajor_axis_internal_ellipse");
2600 Skip_S2(16, "semimajor_axis_external_ellipse");
2601 Skip_S2(16, "semiminor_axis_external_ellipse");
2602 Skip_SB( "overlap_process_option");
2603 Element_End0();
2604 }
2605
2606 Get_S4 (27, targeted_system_display_maximum_luminance, "targeted_system_display_maximum_luminance");
2607 TEST_SB_GET (targeted_system_display_actual_peak_luminance_flag, "targeted_system_display_actual_peak_luminance_flag");
2608 int8u num_rows_targeted_system_display_actual_peak_luminance, num_cols_targeted_system_display_actual_peak_luminance;
2609 Get_S1(5, num_rows_targeted_system_display_actual_peak_luminance, "num_rows_targeted_system_display_actual_peak_luminance");
2610 Get_S1(5, num_cols_targeted_system_display_actual_peak_luminance, "num_cols_targeted_system_display_actual_peak_luminance");
2611 for(int8u i=0; i<num_rows_targeted_system_display_actual_peak_luminance; i++)
2612 for(int8u j=0; j<num_cols_targeted_system_display_actual_peak_luminance; j++)
2613 Skip_S1(4, "targeted_system_display_actual_peak_luminance");
2614 TEST_SB_END();
2615
2616 for (int8u w=0; w<num_windows; w++)
2617 {
2618 Element_Begin1("window");
2619 for(int8u i=0; i<3; i++)
2620 {
2621 Get_S3 (17, maxscl[i], "maxscl"); Param_Info2(Ztring::ToZtring(((float)maxscl[i])/100000, 5), " cd/m2");
2622 }
2623 Get_S3 (17, maxscl[3], "average_maxrgb"); Param_Info2(Ztring::ToZtring(((float)maxscl[3])/100000, 5), " cd/m2");
2624
2625 Get_S1(4, num_distribution_maxrgb_percentiles, "num_distribution_maxrgb_percentiles");
2626 for (int8u i=0; i< num_distribution_maxrgb_percentiles; i++)
2627 {
2628 Element_Begin1( "distribution_maxrgb");
2629 Get_S1 ( 7, distribution_maxrgb_percentages[i], "distribution_maxrgb_percentages");
2630 Get_S3 (17, distribution_maxrgb_percentiles[i], "distribution_maxrgb_percentiles");
2631 Element_Info1(distribution_maxrgb_percentages[i]);
2632 Element_Info1(distribution_maxrgb_percentiles[i]);
2633 Element_End0();
2634 }
2635 Get_S2 (10, fraction_bright_pixels, "fraction_bright_pixels");
2636 Element_End0();
2637 }
2638
2639 TEST_SB_GET (mastering_display_actual_peak_luminance_flag, "mastering_display_actual_peak_luminance_flag");
2640 int8u num_rows_mastering_display_actual_peak_luminance, num_cols_mastering_display_actual_peak_luminance;
2641 Get_S1(5, num_rows_mastering_display_actual_peak_luminance, "num_rows_mastering_display_actual_peak_luminance");
2642 Get_S1(5, num_cols_mastering_display_actual_peak_luminance, "num_cols_mastering_display_actual_peak_luminance");
2643 for(int8u i=0; i< num_rows_mastering_display_actual_peak_luminance; i++)
2644 for(int8u j=0; j< num_cols_mastering_display_actual_peak_luminance; j++)
2645 Skip_S1(4, "mastering_display_actual_peak_luminance");
2646 TEST_SB_END();
2647
2648 for (int8u w=0; w<num_windows; w++)
2649 {
2650 Element_Begin1("window");
2651 TEST_SB_GET (tone_mapping_flag, "tone_mapping_flag");
2652 Skip_S2(12, "knee_point_x");
2653 Skip_S2(12, "knee_point_y");
2654 Get_S1(4, num_bezier_curve_anchors, "num_bezier_curve_anchors");
2655 for (int8u i = 0; i < num_bezier_curve_anchors; i++)
2656 Skip_S2(10, "bezier_curve_anchor");
2657 TEST_SB_END();
2658 Element_End0();
2659 }
2660 TEST_SB_GET (color_saturation_mapping_flag, "color_saturation_mapping_flag");
2661 Info_S1(6, color_saturation_weight, "color_saturation_weight"); Param_Info1(((float)color_saturation_weight)/8);
2662 TEST_SB_END();
2663 BS_End();
2664
2665 FILLING_BEGIN();
2666 IsHDRplus=true;
2667 if (num_windows!=1 || targeted_system_display_actual_peak_luminance_flag || num_distribution_maxrgb_percentiles!=9 || fraction_bright_pixels || mastering_display_actual_peak_luminance_flag || (distribution_maxrgb_percentages[2]>100 && distribution_maxrgb_percentages[2]!=0xFF) || (!tone_mapping_flag && targeted_system_display_maximum_luminance) || (tone_mapping_flag && num_bezier_curve_anchors>9) || color_saturation_mapping_flag)
2668 IsHDRplus=false;
2669 for(int8u i=0; i<4; i++)
2670 if (maxscl[i]>100000)
2671 IsHDRplus=false;
2672 if (IsHDRplus)
2673 for(int8u i=0; i<9; i++)
2674 {
2675 static const int8u distribution_maxrgb_percentages_List[9]={1, 5, 10, 25, 50, 75, 90, 95, 99};
2676 if (distribution_maxrgb_percentages[i]!=distribution_maxrgb_percentages_List[i])
2677 IsHDRplus=false;
2678 if (distribution_maxrgb_percentiles[i]>100000)
2679 IsHDRplus=false;
2680 }
2681 FILLING_END();
2682 }
2683
2684 FILLING_BEGIN();
2685 std::map<video, Ztring>& SmpteSt209440=HDR[HdrFormat_SmpteSt209440];
2686 Ztring& HDR_Format=SmpteSt209440[Video_HDR_Format];
2687 if (HDR_Format.empty())
2688 {
2689 HDR_Format=__T("SMPTE ST 2094 App 4");
2690 SmpteSt209440[Video_HDR_Format_Version].From_Number(application_version);
2691 if (IsHDRplus)
2692 SmpteSt209440[Video_HDR_Format_Compatibility]=tone_mapping_flag?__T("HDR10+ Profile B"):__T("HDR10+ Profile A");
2693 }
2694 FILLING_END();
2695 }
2696
2697 //---------------------------------------------------------------------------
2698 // SEI - 5
sei_message_user_data_unregistered(int32u payloadSize)2699 void File_Hevc::sei_message_user_data_unregistered(int32u payloadSize)
2700 {
2701 Element_Info1("user_data_unregistered");
2702
2703 //Parsing
2704 int128u uuid_iso_iec_11578;
2705 Get_UUID(uuid_iso_iec_11578, "uuid_iso_iec_11578");
2706
2707 switch (uuid_iso_iec_11578.hi)
2708 {
2709 case 0x427FCC9BB8924821LL : Element_Info1("Ateme");
2710 sei_message_user_data_unregistered_Ateme(payloadSize-16); break;
2711 case 0x2CA2DE09B51747DBLL : Element_Info1("x265");
2712 sei_message_user_data_unregistered_x265(payloadSize-16); break;
2713 default :
2714 Element_Info1("unknown");
2715 Skip_XX(payloadSize-16, "data");
2716 }
2717 }
2718
2719 //---------------------------------------------------------------------------
2720 // SEI - 5 - Ateme
sei_message_user_data_unregistered_Ateme(int32u payloadSize)2721 void File_Hevc::sei_message_user_data_unregistered_Ateme(int32u payloadSize)
2722 {
2723 //Parsing
2724 Get_UTF8 (payloadSize, Encoded_Library, "Library name");
2725
2726 //Encoded_Library
2727 if (Encoded_Library.find(__T("ATEME "))==0)
2728 {
2729 size_t Pos=Encoded_Library.find_first_of(__T("0123456789"));
2730 if (Pos && Encoded_Library[Pos-1]==__T(' '))
2731 {
2732 Encoded_Library_Name=Encoded_Library.substr(0, Pos-1);
2733 Encoded_Library_Version=Encoded_Library.substr(Pos);
2734 }
2735 }
2736 }
2737
2738 //---------------------------------------------------------------------------
2739 // SEI - 5 - x265
sei_message_user_data_unregistered_x265(int32u payloadSize)2740 void File_Hevc::sei_message_user_data_unregistered_x265(int32u payloadSize)
2741 {
2742 //Parsing
2743 string Data;
2744 Peek_String(payloadSize, Data);
2745 if (Data.size()!=payloadSize && Data.size()+1!=payloadSize)
2746 {
2747 Skip_XX(payloadSize, "Unknown");
2748 return; //This is not a text string
2749 }
2750 size_t Data_Pos_Before=0;
2751 size_t Loop=0;
2752 do
2753 {
2754 size_t Data_Pos=Data.find(" - ", Data_Pos_Before);
2755 if (Data_Pos==std::string::npos)
2756 Data_Pos=Data.size();
2757 if (Data.find("options: ", Data_Pos_Before)==Data_Pos_Before)
2758 {
2759 Element_Begin1("options");
2760 size_t Options_Pos_Before=Data_Pos_Before;
2761 Encoded_Library_Settings.clear();
2762 while (Options_Pos_Before!=Data.size())
2763 {
2764 size_t Options_Pos=Data.find(__T(' '), Options_Pos_Before);
2765 if (Options_Pos==std::string::npos)
2766 Options_Pos=Data.size();
2767 string option;
2768 Get_String (Options_Pos-Options_Pos_Before, option, "option");
2769 Options_Pos_Before=Options_Pos;
2770 while (Options_Pos_Before!=Data.size())
2771 {
2772 string Separator;
2773 Peek_String(1, Separator);
2774 if (Separator==" ")
2775 {
2776 Skip_UTF8(1, "separator");
2777 Options_Pos_Before+=1;
2778 }
2779 else
2780 break;
2781 }
2782
2783 //Filling
2784 if (option!="options:" && !(!option.empty() && option[0]>='0' && option[0]<='9') && option.find("fps=")!=0 && option.find("bitdepth=")!=0) //Ignoring redundant information e.g. width, height, frame rate, bit depth
2785 {
2786 if (!Encoded_Library_Settings.empty())
2787 Encoded_Library_Settings+=__T(" / ");
2788 Encoded_Library_Settings+=Ztring().From_UTF8(option.c_str());
2789 }
2790 }
2791 Element_End0();
2792 }
2793 else
2794 {
2795 string Value;
2796 Get_String(Data_Pos-Data_Pos_Before, Value, "data");
2797
2798 //Saving
2799 if (Loop==0)
2800 {
2801 //Cleaning a little the value
2802 while (!Value.empty() && Value[0]<0x30)
2803 Value.erase(Value.begin());
2804 while (!Value.empty() && Value[Value.size()-1]<0x30)
2805 Value.erase(Value.end()-1);
2806 size_t Value_Pos=Value.find(__T(' '));
2807 if (Value_Pos!=string::npos)
2808 Value.resize(Value_Pos);
2809 Encoded_Library.From_UTF8(Value.c_str());
2810 }
2811 if (Loop==1 && Encoded_Library.find(__T("x265"))==0)
2812 {
2813 size_t Value_Pos=Value.find(" 8bpp");
2814 if (Value_Pos!=string::npos)
2815 Value.resize(Value_Pos);
2816
2817 Encoded_Library+=__T(" - ");
2818 Encoded_Library+=Ztring().From_UTF8(Value.c_str());
2819 }
2820 }
2821 Data_Pos_Before=Data_Pos;
2822 if (Data_Pos_Before+3<=Data.size())
2823 {
2824 Skip_UTF8(3, "separator");
2825 Data_Pos_Before+=3;
2826 }
2827
2828 Loop++;
2829 }
2830 while (Data_Pos_Before!=Data.size());
2831
2832 //Encoded_Library
2833 if (Encoded_Library.find(__T("x265 - "))==0)
2834 {
2835 Encoded_Library_Name=__T("x265");
2836 Encoded_Library_Version=Encoded_Library.SubString(__T("x265 - "), Ztring());
2837 }
2838 else
2839 Encoded_Library_Name=Encoded_Library;
2840 }
2841
2842 //---------------------------------------------------------------------------
2843 // SEI - 6
sei_message_recovery_point()2844 void File_Hevc::sei_message_recovery_point()
2845 {
2846 Element_Info1("recovery_point");
2847
2848 //Parsing
2849 BS_Begin();
2850 Skip_SE( "recovery_poc_cnt");
2851 Skip_SB( "exact_match_flag");
2852 Skip_SB( "broken_link_flag");
2853 BS_End();
2854 }
2855
2856 //---------------------------------------------------------------------------
sei_message_active_parameter_sets()2857 void File_Hevc::sei_message_active_parameter_sets()
2858 {
2859 Element_Info1("active_parameter_sets");
2860
2861 //Parsing
2862 int32u num_sps_ids_minus1;
2863 BS_Begin();
2864 Skip_S1(4, "active_video_parameter_set_id");
2865 Skip_SB( "self_contained_cvs_flag");
2866 Skip_SB( "no_parameter_set_update_flag");
2867 Get_UE ( num_sps_ids_minus1, "num_sps_ids_minus1");
2868 for (int32u i=0; i<=num_sps_ids_minus1; ++i)
2869 {
2870 Skip_UE( "active_seq_parameter_set_id");
2871 }
2872 BS_End();
2873 }
2874
2875 //---------------------------------------------------------------------------
sei_message_decoded_picture_hash(int32u payloadSize)2876 void File_Hevc::sei_message_decoded_picture_hash(int32u payloadSize)
2877 {
2878 Element_Info1("decoded_picture_hash");
2879
2880 //Parsing
2881 int8u hash_type;
2882 Get_B1 (hash_type, "hash_type");
2883 for (int8u cIdx=0; cIdx<(chroma_format_idc?3:1); cIdx++)
2884 switch (hash_type)
2885 {
2886 case 0 : // md5
2887 Skip_XX(16, "md5");
2888 break;
2889 case 1 : // crc
2890 Skip_XX( 2, "crc");
2891 break;
2892 case 2 : // checksum
2893 Skip_XX( 4, "checksum");
2894 break;
2895 default : //
2896 Skip_XX((Element_Size-1)/(chroma_format_idc?1:3), "unknown");
2897 break;
2898 }
2899 }
2900
2901 //---------------------------------------------------------------------------
sei_message_mastering_display_colour_volume()2902 void File_Hevc::sei_message_mastering_display_colour_volume()
2903 {
2904 Element_Info1("mastering_display_colour_volume");
2905
2906 std::map<video, Ztring>& SmpteSt2086=HDR[HdrFormat_SmpteSt2086];
2907 Ztring& HDR_Format=SmpteSt2086[Video_HDR_Format];
2908 if (HDR_Format.empty())
2909 {
2910 HDR_Format=__T("SMPTE ST 2086");
2911 SmpteSt2086[Video_HDR_Format_Compatibility]="HDR10";
2912 }
2913 Get_MasteringDisplayColorVolume(SmpteSt2086[Video_MasteringDisplay_ColorPrimaries], SmpteSt2086[Video_MasteringDisplay_Luminance]);
2914 }
2915
2916 //---------------------------------------------------------------------------
sei_message_light_level()2917 void File_Hevc::sei_message_light_level()
2918 {
2919 Element_Info1("light_level");
2920
2921 //Parsing
2922 Get_B2(maximum_content_light_level, "maximum_content_light_level");
2923 Get_B2(maximum_frame_average_light_level, "maximum_frame_average_light_level");
2924 }
2925
2926 //---------------------------------------------------------------------------
sei_alternative_transfer_characteristics()2927 void File_Hevc::sei_alternative_transfer_characteristics()
2928 {
2929 Element_Info1("alternative_transfer_characteristics");
2930
2931 //Parsing
2932 Get_B1(preferred_transfer_characteristics, "preferred_transfer_characteristics"); Param_Info1(Mpegv_transfer_characteristics(preferred_transfer_characteristics));
2933 }
2934
2935 //***************************************************************************
2936 // Sub-elements
2937 //***************************************************************************
2938
2939 //---------------------------------------------------------------------------
slice_segment_header()2940 void File_Hevc::slice_segment_header()
2941 {
2942 Element_Begin1("slice_segment_header");
2943
2944 //Parsing
2945 bool dependent_slice_segment_flag=false;
2946 Get_SB ( first_slice_segment_in_pic_flag, "first_slice_segment_in_pic_flag");
2947 if (RapPicFlag)
2948 Skip_SB( "no_output_of_prior_pics_flag");
2949 Get_UE ( slice_pic_parameter_set_id, "slice_pic_parameter_set_id");
2950 std::vector<pic_parameter_set_struct*>::iterator pic_parameter_set_Item;
2951 if (slice_pic_parameter_set_id>=pic_parameter_sets.size() || (*(pic_parameter_set_Item=pic_parameter_sets.begin()+slice_pic_parameter_set_id))==NULL)
2952 {
2953 //Not yet present
2954 RiskCalculationN++;
2955 RiskCalculationD++;
2956 Skip_BS(Data_BS_Remain(), "Data (pic_parameter_set is missing)");
2957 Element_End0();
2958 slice_pic_parameter_set_id=(int32u)-1;
2959 slice_type=(int32u)-1;
2960 return;
2961 }
2962 if (!first_slice_segment_in_pic_flag)
2963 {
2964 if (!MustParse_VPS_SPS_PPS_FromFlv && (*pic_parameter_set_Item)->dependent_slice_segments_enabled_flag)
2965 Get_SB (dependent_slice_segment_flag, "dependent_slice_segment_flag");
2966 //Skip_BS(Ceil( Log2( PicSizeInCtbsY ) ), "slice_segment_address");
2967 Skip_BS(Data_BS_Remain(), "(ToDo)");
2968 Element_End0();
2969 slice_type=(int32u)-1;
2970 return;
2971 }
2972 if (!dependent_slice_segment_flag)
2973 {
2974 if (!MustParse_VPS_SPS_PPS_FromFlv)
2975 Skip_S1((*pic_parameter_set_Item)->num_extra_slice_header_bits, "slice_reserved_flags");
2976 Get_UE (slice_type, "slice_type"); Param_Info1(Hevc_slice_type(slice_type));
2977 }
2978
2979 //TODO...
2980 Skip_BS(Data_BS_Remain(), "(ToDo)");
2981
2982 Element_End0();
2983
2984 #if MEDIAINFO_EVENTS
2985 if (first_slice_segment_in_pic_flag)
2986 {
2987 switch(Element_Code)
2988 {
2989 case 19 :
2990 case 20 : // This is an IDR frame
2991 case 21 :
2992 case 22 :
2993 case 23 :
2994 TemporalReferences_Offset=TemporalReferences_Max+1;
2995 pic_order_cnt_DTS_Ref=FrameInfo.DTS;
2996 if (Config->Config_PerPackage && Element_Code==0x05) // First slice of an IDR frame
2997 {
2998 // IDR
2999 Config->Config_PerPackage->FrameForAlignment(this, true);
3000 Config->Config_PerPackage->IsClosedGOP(this);
3001 }
3002 }
3003 }
3004 #endif //MEDIAINFO_EVENTS
3005
3006 //Saving some info
3007 std::vector<seq_parameter_set_struct*>::iterator seq_parameter_set_Item;
3008 if ((*pic_parameter_set_Item)->seq_parameter_set_id>=seq_parameter_sets.size() || (*(seq_parameter_set_Item=seq_parameter_sets.begin()+(*pic_parameter_set_Item)->seq_parameter_set_id))==NULL || (*seq_parameter_set_Item)->vui_parameters==NULL)
3009 return;
3010 float FrameRate=0;
3011 if ((*seq_parameter_set_Item)->vui_parameters->time_scale && (*seq_parameter_set_Item)->vui_parameters->num_units_in_tick)
3012 FrameRate=(float64)(*seq_parameter_set_Item)->vui_parameters->time_scale/(*seq_parameter_set_Item)->vui_parameters->num_units_in_tick;
3013 else
3014 FrameRate=0;
3015 if (first_slice_segment_in_pic_flag && pic_order_cnt_DTS_Ref!=(int64u)-1 && FrameInfo.PTS!=(int64u)-1 && FrameRate)
3016 {
3017 //Frame order detection
3018 int64s pic_order_cnt=float64_int64s((FrameInfo.PTS-pic_order_cnt_DTS_Ref)*FrameRate/1000000000);
3019 if (pic_order_cnt<TemporalReferences_pic_order_cnt_Min)
3020 {
3021 if (pic_order_cnt<0)
3022 {
3023 size_t Base=(size_t)(TemporalReferences_Offset+TemporalReferences_pic_order_cnt_Min);
3024 size_t ToInsert=(size_t)(TemporalReferences_pic_order_cnt_Min-pic_order_cnt);
3025 if (Base+ToInsert>=4*TemporalReferences_Reserved || Base>=4*TemporalReferences_Reserved || ToInsert+TemporalReferences_Max>=4*TemporalReferences_Reserved || TemporalReferences_Max>=4*TemporalReferences_Reserved || TemporalReferences_Max-Base>=4*TemporalReferences_Reserved)
3026 {
3027 Trusted_IsNot("Problem in temporal references");
3028 return;
3029 }
3030 Element_Info1(__T("Offset of ")+Ztring::ToZtring(ToInsert));
3031 TemporalReferences.insert(TemporalReferences.begin()+Base, ToInsert, NULL);
3032 TemporalReferences_Offset+=ToInsert;
3033 TemporalReferences_Offset_pic_order_cnt_lsb_Last += ToInsert;
3034 TemporalReferences_Max+=ToInsert;
3035 TemporalReferences_pic_order_cnt_Min=pic_order_cnt;
3036 }
3037 else if (TemporalReferences_Min>(size_t)(TemporalReferences_Offset+pic_order_cnt))
3038 TemporalReferences_Min=(size_t)(TemporalReferences_Offset+pic_order_cnt);
3039 }
3040
3041 if (pic_order_cnt<0 && TemporalReferences_Offset<(size_t)(-pic_order_cnt)) //Found in playreadyEncryptedBlowUp.ts without encryption test
3042 {
3043 Trusted_IsNot("Problem in temporal references");
3044 return;
3045 }
3046
3047 if ((size_t)(TemporalReferences_Offset+pic_order_cnt)>=3*TemporalReferences_Reserved)
3048 {
3049 size_t Offset=TemporalReferences_Max-TemporalReferences_Offset;
3050 if (Offset%2)
3051 Offset++;
3052 if (Offset>=TemporalReferences_Reserved && pic_order_cnt>=(int64s)TemporalReferences_Reserved)
3053 {
3054 TemporalReferences_Offset+=TemporalReferences_Reserved;
3055 pic_order_cnt-=TemporalReferences_Reserved;
3056 TemporalReferences_pic_order_cnt_Min-=TemporalReferences_Reserved/2;
3057 }
3058 while (TemporalReferences_Offset+pic_order_cnt>=3*TemporalReferences_Reserved)
3059 {
3060 for (size_t Pos=0; Pos<TemporalReferences_Reserved; Pos++)
3061 {
3062 if (TemporalReferences[Pos])
3063 {
3064 /*
3065 if ((Pos % 2) == 0)
3066 PictureTypes_PreviousFrames+=Avc_slice_type[TemporalReferences[Pos]->slice_type];
3067 */
3068 delete TemporalReferences[Pos];
3069 TemporalReferences[Pos]=NULL;
3070 }
3071 /*
3072 else if (!PictureTypes_PreviousFrames.empty()) //Only if stream already started
3073 {
3074 if ((Pos%2)==0)
3075 PictureTypes_PreviousFrames+=' ';
3076 }
3077 */
3078 }
3079 /*
3080 if (PictureTypes_PreviousFrames.size()>=8*TemporalReferences.size())
3081 PictureTypes_PreviousFrames.erase(PictureTypes_PreviousFrames.begin(), PictureTypes_PreviousFrames.begin()+PictureTypes_PreviousFrames.size()-TemporalReferences.size());
3082 */
3083 TemporalReferences.erase(TemporalReferences.begin(), TemporalReferences.begin()+TemporalReferences_Reserved);
3084 TemporalReferences.resize(4*TemporalReferences_Reserved);
3085 if (TemporalReferences_Reserved<TemporalReferences_Offset)
3086 TemporalReferences_Offset-=TemporalReferences_Reserved;
3087 else
3088 TemporalReferences_Offset=0;
3089 if (TemporalReferences_Reserved<TemporalReferences_Min)
3090 TemporalReferences_Min-=TemporalReferences_Reserved;
3091 else
3092 TemporalReferences_Min=0;
3093 if (TemporalReferences_Reserved<TemporalReferences_Max)
3094 TemporalReferences_Max-=TemporalReferences_Reserved;
3095 else
3096 TemporalReferences_Max=0;
3097 if (TemporalReferences_Reserved<TemporalReferences_Offset_pic_order_cnt_lsb_Last)
3098 TemporalReferences_Offset_pic_order_cnt_lsb_Last-=TemporalReferences_Reserved;
3099 else
3100 TemporalReferences_Offset_pic_order_cnt_lsb_Last=0;
3101 }
3102 }
3103
3104 //TemporalReferences_Offset_pic_order_cnt_lsb_Diff=(int32s)((int32s)(TemporalReferences_Offset+pic_order_cnt)-TemporalReferences_Offset_pic_order_cnt_lsb_Last);
3105 TemporalReferences_Offset_pic_order_cnt_lsb_Last=(size_t)(TemporalReferences_Offset+pic_order_cnt);
3106 /*
3107 if (field_pic_flag && (*seq_parameter_set_Item)->pic_order_cnt_type == 2 && TemporalReferences_Offset_pic_order_cnt_lsb_Last<TemporalReferences.size() && TemporalReferences[TemporalReferences_Offset_pic_order_cnt_lsb_Last])
3108 TemporalReferences_Offset_pic_order_cnt_lsb_Last++;
3109 */
3110 if (TemporalReferences_Max<=TemporalReferences_Offset_pic_order_cnt_lsb_Last)
3111 TemporalReferences_Max=TemporalReferences_Offset_pic_order_cnt_lsb_Last;//+((*seq_parameter_set_Item)->frame_mbs_only_flag?2:1);
3112 if (TemporalReferences_Min>TemporalReferences_Offset_pic_order_cnt_lsb_Last)
3113 TemporalReferences_Min=TemporalReferences_Offset_pic_order_cnt_lsb_Last;
3114 if (TemporalReferences_DelayedElement)
3115 {
3116 delete TemporalReferences[TemporalReferences_Offset_pic_order_cnt_lsb_Last]; TemporalReferences[TemporalReferences_Offset_pic_order_cnt_lsb_Last]=TemporalReferences_DelayedElement;
3117 }
3118 if (TemporalReferences[TemporalReferences_Offset_pic_order_cnt_lsb_Last]==NULL)
3119 TemporalReferences[TemporalReferences_Offset_pic_order_cnt_lsb_Last]=new temporal_reference();
3120 /*
3121 TemporalReferences[TemporalReferences_Offset_pic_order_cnt_lsb_Last]->frame_num=frame_num;
3122 TemporalReferences[TemporalReferences_Offset_pic_order_cnt_lsb_Last]->slice_type=(int8u)slice_type;
3123 TemporalReferences[TemporalReferences_Offset_pic_order_cnt_lsb_Last]->IsTop=!bottom_field_flag;
3124 TemporalReferences[TemporalReferences_Offset_pic_order_cnt_lsb_Last]->IsField=field_pic_flag;
3125 */
3126 if (TemporalReferences_DelayedElement)
3127 {
3128 TemporalReferences_DelayedElement=NULL;
3129 sei_message_user_data_registered_itu_t_t35_B5_0031_GA94_03_Delayed((*pic_parameter_set_Item)->seq_parameter_set_id);
3130 }
3131 }
3132 }
3133
3134 //---------------------------------------------------------------------------
profile_tier_level(int8u maxNumSubLayersMinus1)3135 void File_Hevc::profile_tier_level(int8u maxNumSubLayersMinus1)
3136 {
3137 Element_Begin1("profile_tier_level");
3138
3139 //Parsing
3140 std::vector<bool>sub_layer_profile_present_flags, sub_layer_level_present_flags;
3141 Get_S1 (2, profile_space, "general_profile_space");
3142 Get_SB ( tier_flag, "general_tier_flag");
3143 Get_S1 (5, profile_idc, "general_profile_idc");
3144 Element_Begin1("general_profile_compatibility_flags");
3145 for (int8u profile_pos=0; profile_pos<32; profile_pos++)
3146 if (profile_pos==profile_idc)
3147 {
3148 bool general_profile_compatibility_flag;
3149 Get_SB ( general_profile_compatibility_flag, "general_profile_compatibility_flag");
3150 //if (!general_profile_compatibility_flag && !profile_space) //found some files without this flag, ignoring the test for the moment (not really important)
3151 // Trusted_IsNot("general_profile_compatibility_flag not valid");
3152 }
3153 else
3154 Skip_SB( "general_profile_compatibility_flag");
3155 Element_End0();
3156 Element_Begin1("general_profile_compatibility_flags");
3157 Get_SB ( general_progressive_source_flag, "general_progressive_source_flag");
3158 Get_SB ( general_interlaced_source_flag, "general_interlaced_source_flag");
3159 Skip_SB( "general_non_packed_constraint_flag");
3160 Get_SB ( general_frame_only_constraint_flag, "general_frame_only_constraint_flag");
3161 Skip_SB( "general_max_12bit_constraint_flag");
3162 Skip_SB( "general_max_10bit_constraint_flag");
3163 Get_SB ( general_max_8bit_constraint_flag, "general_max_8bit_constraint_flag");
3164 Skip_SB( "general_max_422chroma_constraint_flag");
3165 Skip_SB( "general_max_420chroma_constraint_flag");
3166 Skip_SB( "general_max_monochrome_constraint_flag");
3167 Skip_SB( "general_intra_constraint_flag");
3168 Skip_SB( "general_one_picture_only_constraint_flag");
3169 Skip_SB( "general_lower_bit_rate_constraint_flag");
3170 Skip_SB( "general_max_14bit_constraint_flag");
3171 for (int8u constraint_pos=0; constraint_pos<33; constraint_pos++)
3172 Skip_SB( "general_reserved");
3173 Skip_SB( "general_inbld_flag");
3174 Element_End0();
3175 Get_S1 (8, level_idc, "general_level_idc");
3176 for (int32u SubLayerPos=0; SubLayerPos<maxNumSubLayersMinus1; SubLayerPos++)
3177 {
3178 Element_Begin1("SubLayer");
3179 bool sub_layer_profile_present_flag, sub_layer_level_present_flag;
3180 Get_SB ( sub_layer_profile_present_flag, "sub_layer_profile_present_flag");
3181 Get_SB ( sub_layer_level_present_flag, "sub_layer_level_present_flag");
3182 sub_layer_profile_present_flags.push_back(sub_layer_profile_present_flag);
3183 sub_layer_level_present_flags.push_back(sub_layer_level_present_flag);
3184 Element_End0();
3185 }
3186 if (maxNumSubLayersMinus1)
3187 for(int32u SubLayerPos=maxNumSubLayersMinus1; SubLayerPos<8; SubLayerPos++)
3188 Skip_S1(2, "reserved_zero_2bits");
3189 for (int32u SubLayerPos=0; SubLayerPos<maxNumSubLayersMinus1; SubLayerPos++)
3190 {
3191 Element_Begin1("SubLayer");
3192 if (sub_layer_profile_present_flags[SubLayerPos])
3193 {
3194 Skip_S1(2, "sub_layer_profile_space");
3195 Skip_SB( "sub_layer_tier_flag");
3196 Skip_S1(5, "sub_layer_profile_idc");
3197 Skip_S4(32, "sub_layer_profile_compatibility_flags");
3198 Skip_SB( "sub_layer_progressive_source_flag");
3199 Skip_SB( "sub_layer_interlaced_source_flag");
3200 Skip_SB( "sub_layer_non_packed_constraint_flag");
3201 Skip_SB( "sub_layer_frame_only_constraint_flag");
3202 Skip_S8(44, "sub_layer_reserved_zero_44bits");
3203 }
3204 if (sub_layer_level_present_flags[SubLayerPos])
3205 {
3206 Skip_S1(8, "sub_layer_level_idc");
3207 }
3208 Element_End0();
3209 }
3210
3211 Element_End0();
3212 }
3213
3214 //---------------------------------------------------------------------------
short_term_ref_pic_sets(int8u num_short_term_ref_pic_sets)3215 void File_Hevc::short_term_ref_pic_sets(int8u num_short_term_ref_pic_sets)
3216 {
3217 Element_Begin1("short_term_ref_pic_sets");
3218 int32u num_pics=0;
3219
3220 for (int32u stRpsIdx=0; stRpsIdx<num_short_term_ref_pic_sets; stRpsIdx++)
3221 {
3222 Element_Begin1("short_term_ref_pic_set");
3223 bool inter_ref_pic_set_prediction_flag=false;
3224 if (stRpsIdx)
3225 Get_SB (inter_ref_pic_set_prediction_flag, "inter_ref_pic_set_prediction_flag");
3226 if (inter_ref_pic_set_prediction_flag)
3227 {
3228 int32u delta_idx_minus1=0, abs_delta_rps_minus1;
3229 bool delta_rps_sign;
3230 if (stRpsIdx==num_short_term_ref_pic_sets)
3231 Get_UE (delta_idx_minus1, "delta_idx_minus1");
3232 if (delta_idx_minus1+1>stRpsIdx)
3233 {
3234 Skip_BS(Data_BS_Remain(), "(Problem)");
3235 Element_End0();
3236 Element_End0();
3237 return;
3238 }
3239 Get_SB ( delta_rps_sign, "delta_rps_sign");
3240 Get_UE ( abs_delta_rps_minus1, "abs_delta_rps_minus1");
3241 int32u num_pics_new=0;
3242 for(int32u pic_pos=0 ; pic_pos<=num_pics; pic_pos++)
3243 {
3244 TESTELSE_SB_SKIP( "used_by_curr_pic_flag");
3245 num_pics_new++;
3246 TESTELSE_SB_ELSE( "used_by_curr_pic_flag");
3247 bool use_delta_flag;
3248 Get_SB (use_delta_flag, "use_delta_flag");
3249 if (use_delta_flag)
3250 num_pics_new++;
3251 TESTELSE_SB_END();
3252 }
3253 num_pics=num_pics_new;
3254 }
3255 else
3256 {
3257 int32u num_negative_pics, num_positive_pics;
3258 Get_UE (num_negative_pics, "num_negative_pics");
3259 Get_UE (num_positive_pics, "num_positive_pics");
3260 num_pics=num_negative_pics+num_positive_pics;
3261 for (int32u i=0; i<num_negative_pics; i++)
3262 {
3263 Skip_UE( "delta_poc_s0_minus1");
3264 Skip_SB( "used_by_curr_pic_s0_flag");
3265 }
3266 for (int32u i=0; i<num_positive_pics; i++)
3267 {
3268 Skip_UE( "delta_poc_s1_minus1");
3269 Skip_SB( "used_by_curr_pic_s1_flag");
3270 }
3271 }
3272 Element_End0();
3273 }
3274
3275 Element_End0();
3276 }
3277
3278 //---------------------------------------------------------------------------
vui_parameters(std::vector<video_parameter_set_struct * >::iterator video_parameter_set_Item,seq_parameter_set_struct::vui_parameters_struct * & vui_parameters_Item_)3279 void File_Hevc::vui_parameters(std::vector<video_parameter_set_struct*>::iterator video_parameter_set_Item, seq_parameter_set_struct::vui_parameters_struct* &vui_parameters_Item_)
3280 {
3281 //Parsing
3282 seq_parameter_set_struct::vui_parameters_struct::xxl_common *xxL_Common=NULL;
3283 seq_parameter_set_struct::vui_parameters_struct::xxl *NAL = NULL, *VCL = NULL;
3284 int32u num_units_in_tick = (int32u)-1, time_scale = (int32u)-1;
3285 int16u sar_width=(int16u)-1, sar_height=(int16u)-1;
3286 int8u aspect_ratio_idc=0, video_format=5, video_full_range_flag=0, colour_primaries=2, transfer_characteristics=2, matrix_coefficients=2;
3287 bool aspect_ratio_info_present_flag, video_signal_type_present_flag, frame_field_info_present_flag, colour_description_present_flag=false, timing_info_present_flag;
3288 TEST_SB_GET (aspect_ratio_info_present_flag, "aspect_ratio_info_present_flag");
3289 Get_S1 (8, aspect_ratio_idc, "aspect_ratio_idc"); Param_Info1C((aspect_ratio_idc<Avc_PixelAspectRatio_Size), Avc_PixelAspectRatio[aspect_ratio_idc]);
3290 if (aspect_ratio_idc==0xFF)
3291 {
3292 Get_S2 (16, sar_width, "sar_width");
3293 Get_S2 (16, sar_height, "sar_height");
3294 }
3295 TEST_SB_END();
3296 TEST_SB_SKIP( "overscan_info_present_flag");
3297 Skip_SB( "overscan_appropriate_flag");
3298 TEST_SB_END();
3299 TEST_SB_GET (video_signal_type_present_flag, "video_signal_type_present_flag");
3300 Get_S1 (3, video_format, "video_format"); Param_Info1(Avc_video_format[video_format]);
3301 Get_S1 (1, video_full_range_flag, "video_full_range_flag"); Param_Info1(Avc_video_full_range[video_full_range_flag]);
3302 TEST_SB_GET (colour_description_present_flag, "colour_description_present_flag");
3303 Get_S1 (8, colour_primaries, "colour_primaries"); Param_Info1(Mpegv_colour_primaries(colour_primaries));
3304 Get_S1 (8, transfer_characteristics, "transfer_characteristics"); Param_Info1(Mpegv_transfer_characteristics(transfer_characteristics));
3305 Get_S1 (8, matrix_coefficients, "matrix_coefficients"); Param_Info1(Mpegv_matrix_coefficients(matrix_coefficients));
3306 TEST_SB_END();
3307 TEST_SB_END();
3308 TEST_SB_SKIP( "chroma_loc_info_present_flag");
3309 Get_UE (chroma_sample_loc_type_top_field, "chroma_sample_loc_type_top_field");
3310 Get_UE (chroma_sample_loc_type_bottom_field, "chroma_sample_loc_type_bottom_field");
3311 TEST_SB_END();
3312 Skip_SB( "neutral_chroma_indication_flag");
3313 Skip_SB( "field_seq_flag");
3314 Get_SB ( frame_field_info_present_flag, "frame_field_info_present_flag");
3315 TEST_SB_SKIP( "default_display_window_flag ");
3316 Skip_UE( "def_disp_win_left_offset");
3317 Skip_UE( "def_disp_win_right_offset");
3318 Skip_UE( "def_disp_win_top_offset");
3319 Skip_UE( "def_disp_win_bottom_offset");
3320 TEST_SB_END();
3321 TEST_SB_GET (timing_info_present_flag, "timing_info_present_flag");
3322 Get_S4 (32, num_units_in_tick, "num_units_in_tick");
3323 Get_S4 (32, time_scale, "time_scale");
3324 TEST_SB_SKIP( "vui_poc_proportional_to_timing_flag");
3325 Skip_UE( "vui_num_ticks_poc_diff_one_minus1");
3326 TEST_SB_END();
3327 TEST_SB_SKIP( "hrd_parameters_present_flag");
3328 hrd_parameters(true, (*video_parameter_set_Item)->vps_max_sub_layers_minus1, xxL_Common, NAL, VCL);
3329 TEST_SB_END();
3330 TEST_SB_END();
3331 TEST_SB_SKIP( "bitstream_restriction_flag");
3332 Skip_SB( "tiles_fixed_structure_flag");
3333 Skip_SB( "motion_vectors_over_pic_boundaries_flag");
3334 Skip_SB( "restricted_ref_pic_lists_flag");
3335 Skip_UE( "min_spatial_segmentation_idc");
3336 Skip_UE( "max_bytes_per_pic_denom");
3337 Skip_UE( "max_bits_per_min_cu_denom");
3338 Skip_UE( "log2_max_mv_length_horizontal");
3339 Skip_UE( "log2_max_mv_length_vertical");
3340 TEST_SB_END();
3341
3342 FILLING_BEGIN();
3343 vui_parameters_Item_ = new seq_parameter_set_struct::vui_parameters_struct(
3344 NAL,
3345 VCL,
3346 xxL_Common,
3347 num_units_in_tick,
3348 time_scale,
3349 sar_width,
3350 sar_height,
3351 aspect_ratio_idc,
3352 video_format,
3353 video_full_range_flag,
3354 colour_primaries,
3355 transfer_characteristics,
3356 matrix_coefficients,
3357 aspect_ratio_info_present_flag,
3358 video_signal_type_present_flag,
3359 frame_field_info_present_flag,
3360 colour_description_present_flag,
3361 timing_info_present_flag
3362 );
3363 FILLING_ELSE();
3364 delete xxL_Common; xxL_Common=NULL;
3365 delete NAL; NAL=NULL;
3366 delete VCL; VCL=NULL;
3367 FILLING_END();
3368 }
3369
3370 //---------------------------------------------------------------------------
hrd_parameters(bool commonInfPresentFlag,int8u maxNumSubLayersMinus1,seq_parameter_set_struct::vui_parameters_struct::xxl_common * & xxL_Common,seq_parameter_set_struct::vui_parameters_struct::xxl * & NAL,seq_parameter_set_struct::vui_parameters_struct::xxl * & VCL)3371 void File_Hevc::hrd_parameters(bool commonInfPresentFlag, int8u maxNumSubLayersMinus1, seq_parameter_set_struct::vui_parameters_struct::xxl_common* &xxL_Common, seq_parameter_set_struct::vui_parameters_struct::xxl* &NAL, seq_parameter_set_struct::vui_parameters_struct::xxl* &VCL)
3372 {
3373 //Parsing
3374 int8u bit_rate_scale=0, cpb_size_scale=0, du_cpb_removal_delay_increment_length_minus1=0, dpb_output_delay_du_length_minus1=0, initial_cpb_removal_delay_length_minus1=0, au_cpb_removal_delay_length_minus1=0, dpb_output_delay_length_minus1=0;
3375 bool nal_hrd_parameters_present_flag=false, vcl_hrd_parameters_present_flag=false, sub_pic_hrd_params_present_flag=false;
3376 if (commonInfPresentFlag)
3377 {
3378 Get_SB (nal_hrd_parameters_present_flag, "nal_hrd_parameters_present_flag");
3379 Get_SB (vcl_hrd_parameters_present_flag, "vcl_hrd_parameters_present_flag");
3380 if (nal_hrd_parameters_present_flag || vcl_hrd_parameters_present_flag)
3381 {
3382 TEST_SB_GET (sub_pic_hrd_params_present_flag, "sub_pic_hrd_params_present_flag");
3383 Skip_S1(8, "tick_divisor_minus2");
3384 Get_S1 (5, du_cpb_removal_delay_increment_length_minus1, "du_cpb_removal_delay_increment_length_minus1");
3385 Skip_SB( "sub_pic_cpb_params_in_pic_timing_sei_flag");
3386 Get_S1 (5, dpb_output_delay_du_length_minus1, "dpb_output_delay_du_length_minus1");
3387 TEST_SB_END();
3388 Get_S1 (4, bit_rate_scale, "bit_rate_scale");
3389 Get_S1 (4, cpb_size_scale, "cpb_size_scale");
3390 if (sub_pic_hrd_params_present_flag)
3391 Skip_S1(4, "cpb_size_du_scale");
3392 Get_S1 (5, initial_cpb_removal_delay_length_minus1, "initial_cpb_removal_delay_length_minus1");
3393 Get_S1 (5, au_cpb_removal_delay_length_minus1, "au_cpb_removal_delay_length_minus1");
3394 Get_S1 (5, dpb_output_delay_length_minus1, "dpb_output_delay_length_minus1");
3395 }
3396 }
3397
3398 for (int8u NumSubLayer=0; NumSubLayer<=maxNumSubLayersMinus1; NumSubLayer++)
3399 {
3400 int32u cpb_cnt_minus1=0;
3401 bool fixed_pic_rate_general_flag, fixed_pic_rate_within_cvs_flag=true, low_delay_hrd_flag=false;
3402 Get_SB (fixed_pic_rate_general_flag, "fixed_pic_rate_general_flag");
3403 if (!fixed_pic_rate_general_flag)
3404 Get_SB (fixed_pic_rate_within_cvs_flag, "fixed_pic_rate_within_cvs_flag");
3405 if (fixed_pic_rate_within_cvs_flag)
3406 Skip_UE( "elemental_duration_in_tc_minus1");
3407 else
3408 Get_SB (low_delay_hrd_flag, "low_delay_hrd_flag");
3409 if (!low_delay_hrd_flag)
3410 {
3411 Get_UE (cpb_cnt_minus1, "cpb_cnt_minus1");
3412 if (cpb_cnt_minus1>31)
3413 {
3414 Trusted_IsNot("cpb_cnt_minus1 too high");
3415 cpb_cnt_minus1=0;
3416 return;
3417 }
3418 }
3419 if (nal_hrd_parameters_present_flag || vcl_hrd_parameters_present_flag)
3420 xxL_Common=new seq_parameter_set_struct::vui_parameters_struct::xxl_common(
3421 sub_pic_hrd_params_present_flag,
3422 du_cpb_removal_delay_increment_length_minus1,
3423 dpb_output_delay_du_length_minus1,
3424 initial_cpb_removal_delay_length_minus1,
3425 au_cpb_removal_delay_length_minus1,
3426 dpb_output_delay_length_minus1
3427 );
3428 if (nal_hrd_parameters_present_flag)
3429 sub_layer_hrd_parameters(xxL_Common, bit_rate_scale, cpb_size_scale, cpb_cnt_minus1, NAL); //TODO: save HRD per NumSubLayer
3430 if (vcl_hrd_parameters_present_flag)
3431 sub_layer_hrd_parameters(xxL_Common, bit_rate_scale, cpb_size_scale, cpb_cnt_minus1, VCL); //TODO: save HRD per NumSubLayer
3432 }
3433 }
3434
3435 //---------------------------------------------------------------------------
sub_layer_hrd_parameters(seq_parameter_set_struct::vui_parameters_struct::xxl_common * xxL_Common,int8u bit_rate_scale,int8u cpb_size_scale,int32u cpb_cnt_minus1,seq_parameter_set_struct::vui_parameters_struct::xxl * & hrd_parameters_Item_)3436 void File_Hevc::sub_layer_hrd_parameters(seq_parameter_set_struct::vui_parameters_struct::xxl_common* xxL_Common, int8u bit_rate_scale, int8u cpb_size_scale, int32u cpb_cnt_minus1, seq_parameter_set_struct::vui_parameters_struct::xxl* &hrd_parameters_Item_)
3437 {
3438 //Parsing
3439 vector<seq_parameter_set_struct::vui_parameters_struct::xxl::xxl_data> SchedSel;
3440 SchedSel.reserve(cpb_cnt_minus1 + 1);
3441 for (int8u SchedSelIdx = 0; SchedSelIdx <= cpb_cnt_minus1; ++SchedSelIdx)
3442 {
3443 Element_Begin1("ShedSel");
3444 int64u bit_rate_value, cpb_size_value;
3445 int32u bit_rate_value_minus1, cpb_size_value_minus1;
3446 bool cbr_flag;
3447 Get_UE (bit_rate_value_minus1, "bit_rate_value_minus1");
3448 bit_rate_value = (int64u)((bit_rate_value_minus1 + 1)*pow(2.0, 6 + bit_rate_scale)); Param_Info2(bit_rate_value, " bps");
3449 Get_UE (cpb_size_value_minus1, "cpb_size_value_minus1");
3450 cpb_size_value = (int64u)((cpb_size_value_minus1 + 1)*pow(2.0, 4 + cpb_size_scale)); Param_Info2(cpb_size_value, " bits");
3451 if (xxL_Common->sub_pic_hrd_params_present_flag)
3452 {
3453 Skip_UE( "cpb_size_du_value_minus1");
3454 Skip_UE( "bit_rate_du_value_minus1");
3455 }
3456 Get_SB (cbr_flag, "cbr_flag");
3457 Element_End0();
3458
3459 FILLING_BEGIN();
3460 SchedSel.push_back(seq_parameter_set_struct::vui_parameters_struct::xxl::xxl_data(
3461 bit_rate_value,
3462 cpb_size_value,
3463 cbr_flag
3464 ));
3465 FILLING_END();
3466 }
3467
3468 //Validity test
3469 if (!Element_IsOK() || (SchedSel.size() == 1 && SchedSel[0].bit_rate_value == 64))
3470 {
3471 return; //We do not trust this kind of data
3472 }
3473
3474 //Filling
3475 hrd_parameters_Item_=new seq_parameter_set_struct::vui_parameters_struct::xxl(
3476 SchedSel
3477 );
3478 }
3479
3480 //---------------------------------------------------------------------------
scaling_list_data()3481 void File_Hevc::scaling_list_data()
3482 {
3483 for(int8u sizeId=0; sizeId<4; sizeId++)
3484 for (int8u matrixId = 0; matrixId<((sizeId == 3) ? 2 : 6); matrixId++)
3485 {
3486 bool scaling_list_pred_mode_flag;
3487 Get_SB (scaling_list_pred_mode_flag, "scaling_list_pred_mode_flag");
3488 if(!scaling_list_pred_mode_flag)
3489 Skip_UE( "scaling_list_pred_matrix_id_delta");
3490 else
3491 {
3492 //nextCoef = 8
3493 size_t coefNum=std::min(64, (1<<(4+(sizeId<<1))));
3494 if( sizeId > 1 )
3495 {
3496 Skip_SE( "scaling_list_dc_coef_minus8"); //[ sizeId ? 2 ][ matrixId ] se(v)
3497 //nextCoef = scaling_list_dc_coef_minus8[ sizeId ? 2 ][ matrixId ] + 8
3498 }
3499 for(size_t i=0; i<coefNum; i++)
3500 {
3501 Skip_SE( "scaling_list_delta_coef");
3502 //nextCoef = ( nextCoef + scaling_list_delta_coef + 256 ) % 256
3503 //ScalingList[ sizeId ][ matrixId ][ i ] = nextCoef
3504 }
3505 }
3506 }
3507 }
3508
3509 //***************************************************************************
3510 // Specific
3511 //***************************************************************************
3512
3513 //---------------------------------------------------------------------------
VPS_SPS_PPS()3514 void File_Hevc::VPS_SPS_PPS()
3515 {
3516 if (MustParse_VPS_SPS_PPS_FromMatroska || MustParse_VPS_SPS_PPS_FromFlv)
3517 {
3518 if (Element_Size>=5
3519 && Buffer[Buffer_Offset ]==0x01
3520 && Buffer[Buffer_Offset+1]==0x00
3521 && Buffer[Buffer_Offset+2]==0x00
3522 && Buffer[Buffer_Offset+3]==0x00
3523 && Buffer[Buffer_Offset+4]==0xFF) //Trying to detect old proposal of the form of Matroska implementation
3524 return VPS_SPS_PPS_FromMatroska();
3525
3526 MustParse_VPS_SPS_PPS_FromMatroska=false;
3527 MustParse_VPS_SPS_PPS_FromFlv=false;
3528 }
3529
3530 //Parsing
3531 int64u general_constraint_indicator_flags;
3532 int32u general_profile_compatibility_flags;
3533 int8u configurationVersion;
3534 int8u chromaFormat, bitDepthLumaMinus8, bitDepthChromaMinus8;
3535 int8u general_profile_space, general_profile_idc, general_level_idc;
3536 int8u numOfArrays, constantFrameRate, numTemporalLayers;
3537 bool general_tier_flag, temporalIdNested;
3538 Get_B1 (configurationVersion, "configurationVersion");
3539 BS_Begin();
3540 Get_S1 (2, general_profile_space, "general_profile_space");
3541 Get_SB ( general_tier_flag, "general_tier_flag");
3542 Get_S1 (5, general_profile_idc, "general_profile_idc");
3543 BS_End();
3544 Get_B4 (general_profile_compatibility_flags, "general_profile_compatibility_flags");
3545 Get_B6 (general_constraint_indicator_flags, "general_constraint_indicator_flags");
3546 Get_B1 (general_level_idc, "general_level_idc");
3547 BS_Begin();
3548 Mark_1_NoTrustError();
3549 Mark_1_NoTrustError();
3550 Mark_1_NoTrustError();
3551 Mark_1_NoTrustError();
3552 Skip_S2(12, "min_spatial_segmentation_idc");
3553 BS_End();
3554 BS_Begin();
3555 Mark_1_NoTrustError();
3556 Mark_1_NoTrustError();
3557 Mark_1_NoTrustError();
3558 Mark_1_NoTrustError();
3559 Mark_1_NoTrustError();
3560 Mark_1_NoTrustError();
3561 Skip_S1(2, "parallelismType");
3562 BS_End();
3563 BS_Begin();
3564 Mark_1_NoTrustError();
3565 Mark_1_NoTrustError();
3566 Mark_1_NoTrustError();
3567 Mark_1_NoTrustError();
3568 Mark_1_NoTrustError();
3569 Mark_1_NoTrustError();
3570 Get_S1 (2, chromaFormat, "chromaFormat");
3571 BS_End();
3572 BS_Begin();
3573 Mark_1_NoTrustError();
3574 Mark_1_NoTrustError();
3575 Mark_1_NoTrustError();
3576 Mark_1_NoTrustError();
3577 Mark_1_NoTrustError();
3578 Get_S1 (3, bitDepthLumaMinus8, "bitDepthLumaMinus8");
3579 BS_End();
3580 BS_Begin();
3581 Mark_1_NoTrustError();
3582 Mark_1_NoTrustError();
3583 Mark_1_NoTrustError();
3584 Mark_1_NoTrustError();
3585 Mark_1_NoTrustError();
3586 Get_S1 (3, bitDepthChromaMinus8, "bitDepthChromaMinus8");
3587 BS_End();
3588 Skip_B2( "avgFrameRate");
3589 BS_Begin();
3590 Get_S1 (2, constantFrameRate, "constantFrameRate");
3591 Get_S1 (3, numTemporalLayers, "numTemporalLayers");
3592 Get_SB ( temporalIdNested, "temporalIdNested");
3593 Get_S1 (2, lengthSizeMinusOne, "lengthSizeMinusOne");
3594 BS_End();
3595 Get_B1 (numOfArrays, "numOfArrays");
3596 for (size_t ArrayPos=0; ArrayPos<numOfArrays; ArrayPos++)
3597 {
3598 Element_Begin1("Array");
3599 int16u numNalus;
3600 int8u NAL_unit_type;
3601 BS_Begin();
3602 Skip_SB( "array_completeness");
3603 Mark_0_NoTrustError();
3604 Get_S1 (6, NAL_unit_type, "NAL_unit_type");
3605 BS_End();
3606 Get_B2 (numNalus, "numNalus");
3607 for (size_t NaluPos=0; NaluPos<numNalus; NaluPos++)
3608 {
3609 Element_Begin1("nalUnit");
3610 int16u nalUnitLength;
3611 Get_B2 (nalUnitLength, "nalUnitLength");
3612 if (nalUnitLength<2 || Element_Offset+nalUnitLength>Element_Size)
3613 {
3614 Trusted_IsNot("Size is wrong");
3615 break; //There is an error
3616 }
3617
3618 //Header
3619 int8u nal_unit_type, nuh_temporal_id_plus1;
3620 BS_Begin();
3621 Mark_0 ();
3622 Get_S1 (6, nal_unit_type, "nal_unit_type");
3623 Get_S1 (6, nuh_layer_id, "nuh_layer_id");
3624 Get_S1 (3, nuh_temporal_id_plus1, "nuh_temporal_id_plus1");
3625 if (nuh_temporal_id_plus1==0)
3626 Trusted_IsNot("nuh_temporal_id_plus1 is invalid");
3627 BS_End();
3628
3629 //Data
3630 int64u Element_Offset_Save=Element_Offset;
3631 int64u Element_Size_Save=Element_Size;
3632 Buffer_Offset+=(size_t)Element_Offset_Save;
3633 Element_Offset=0;
3634 Element_Size=nalUnitLength-2;
3635 Element_Code=nal_unit_type;
3636 Data_Parse();
3637 Buffer_Offset-=(size_t)Element_Offset_Save;
3638 Element_Offset=Element_Offset_Save+nalUnitLength-2;
3639 Element_Size=Element_Size_Save;
3640
3641 Element_End0();
3642 }
3643 Element_End0();
3644 }
3645
3646 MustParse_VPS_SPS_PPS=false;
3647 FILLING_BEGIN_PRECISE();
3648 Accept("HEVC");
3649 FILLING_END();
3650 }
3651
3652 //---------------------------------------------------------------------------
VPS_SPS_PPS_FromMatroska()3653 void File_Hevc::VPS_SPS_PPS_FromMatroska()
3654 {
3655 //Parsing
3656 int8u Profile, Level, vid_parameter_set_count, seq_parameter_set_count, pic_parameter_set_count;
3657 if (SizedBlocks)
3658 Skip_B1( "Version");
3659 Get_B1 (Profile, "Profile");
3660 Skip_B1( "Compatible profile");
3661 Get_B1 (Level, "Level");
3662 BS_Begin();
3663 Skip_S1(6, "Reserved");
3664 Get_S1 (2, lengthSizeMinusOne, "Size of NALU length minus 1");
3665 Skip_S1(3, "Reserved");
3666 Get_S1 (5, vid_parameter_set_count, MustParse_VPS_SPS_PPS_FromFlv?"vid_parameter_set+seq_parameter_set count":"vid_parameter_set count");
3667 BS_End();
3668 for (int8u Pos=0; Pos<vid_parameter_set_count; Pos++)
3669 {
3670 Element_Begin1("nalUnit");
3671 int16u nalUnitLength;
3672 Get_B2 (nalUnitLength, "nalUnitLength");
3673 if (nalUnitLength<2 || Element_Offset+nalUnitLength>Element_Size)
3674 {
3675 Trusted_IsNot("Size is wrong");
3676 break; //There is an error
3677 }
3678
3679 //Header
3680 int8u nal_unit_type, nuh_temporal_id_plus1;
3681 BS_Begin();
3682 Mark_0 ();
3683 Get_S1 (6, nal_unit_type, "nal_unit_type");
3684 Get_S1 (6, nuh_layer_id, "nuh_layer_id");
3685 Get_S1 (3, nuh_temporal_id_plus1, "nuh_temporal_id_plus1");
3686 if (nuh_temporal_id_plus1==0)
3687 Trusted_IsNot("nuh_temporal_id_plus1 is invalid");
3688 BS_End();
3689
3690 //Data
3691 int64u Element_Offset_Save=Element_Offset;
3692 int64u Element_Size_Save=Element_Size;
3693 Buffer_Offset+=(size_t)Element_Offset_Save;
3694 Element_Offset=0;
3695 Element_Size=nalUnitLength-2;
3696 Element_Code=nal_unit_type;
3697 Data_Parse();
3698 Buffer_Offset-=(size_t)Element_Offset_Save;
3699 Element_Offset=Element_Offset_Save+nalUnitLength-2;
3700 Element_Size=Element_Size_Save;
3701
3702 Element_End0();
3703 }
3704 if (MustParse_VPS_SPS_PPS_FromFlv)
3705 seq_parameter_set_count=0;
3706 else
3707 {
3708 BS_Begin();
3709 Skip_S1(3, "Reserved");
3710 Get_S1 (5, seq_parameter_set_count, "seq_parameter_set count");
3711 BS_End();
3712 }
3713 for (int8u Pos=0; Pos<seq_parameter_set_count; Pos++)
3714 {
3715 Element_Begin1("nalUnit");
3716 int16u nalUnitLength;
3717 Get_B2 (nalUnitLength, "nalUnitLength");
3718 if (nalUnitLength<2 || Element_Offset+nalUnitLength>Element_Size)
3719 {
3720 Trusted_IsNot("Size is wrong");
3721 break; //There is an error
3722 }
3723
3724 //Header
3725 int8u nal_unit_type, nuh_temporal_id_plus1;
3726 BS_Begin();
3727 Mark_0 ();
3728 Get_S1 (6, nal_unit_type, "nal_unit_type");
3729 Get_S1 (6, nuh_layer_id, "nuh_layer_id");
3730 Get_S1 (3, nuh_temporal_id_plus1, "nuh_temporal_id_plus1");
3731 if (nuh_temporal_id_plus1==0)
3732 Trusted_IsNot("nuh_temporal_id_plus1 is invalid");
3733 BS_End();
3734
3735 //Data
3736 int64u Element_Offset_Save=Element_Offset;
3737 int64u Element_Size_Save=Element_Size;
3738 Buffer_Offset+=(size_t)Element_Offset_Save;
3739 Element_Offset=0;
3740 Element_Size=nalUnitLength-2;
3741 Element_Code=nal_unit_type;
3742 Data_Parse();
3743 Buffer_Offset-=(size_t)Element_Offset_Save;
3744 Element_Offset=Element_Offset_Save+nalUnitLength-2;
3745 Element_Size=Element_Size_Save;
3746
3747 Element_End0();
3748 }
3749 Get_B1 (pic_parameter_set_count, "pic_parameter_set count");
3750 for (int8u Pos=0; Pos<pic_parameter_set_count; Pos++)
3751 {
3752 Element_Begin1("nalUnit");
3753 int16u nalUnitLength;
3754 Get_B2 (nalUnitLength, "nalUnitLength");
3755 if (nalUnitLength<2 || Element_Offset+nalUnitLength>Element_Size)
3756 {
3757 Trusted_IsNot("Size is wrong");
3758 break; //There is an error
3759 }
3760
3761 //Header
3762 int8u nal_unit_type, nuh_temporal_id_plus1;
3763 BS_Begin();
3764 Mark_0 ();
3765 Get_S1 (6, nal_unit_type, "nal_unit_type");
3766 Get_S1 (6, nuh_layer_id, "nuh_layer_id");
3767 Get_S1 (3, nuh_temporal_id_plus1, "nuh_temporal_id_plus1");
3768 if (nuh_temporal_id_plus1==0)
3769 Trusted_IsNot("nuh_temporal_id_plus1 is invalid");
3770 BS_End();
3771
3772 //Data
3773 int64u Element_Offset_Save=Element_Offset;
3774 int64u Element_Size_Save=Element_Size;
3775 Buffer_Offset+=(size_t)Element_Offset_Save;
3776 Element_Offset=0;
3777 Element_Size=nalUnitLength-2;
3778 Element_Code=nal_unit_type;
3779 Data_Parse();
3780 Buffer_Offset-=(size_t)Element_Offset_Save;
3781 Element_Offset=Element_Offset_Save+nalUnitLength-2;
3782 Element_Size=Element_Size_Save;
3783
3784 Element_End0();
3785 }
3786 if (Element_Offset<Element_Size)
3787 Skip_XX(Element_Size-Element_Offset, "Padding?");
3788
3789 //Filling
3790 MustParse_VPS_SPS_PPS=false;
3791 FILLING_BEGIN_PRECISE();
3792 Accept("HEVC");
3793 FILLING_END();
3794 }
3795
3796 //---------------------------------------------------------------------------
EndOfxPS(const char * FlagName,const char * DataName)3797 void File_Hevc::EndOfxPS(const char* FlagName, const char* DataName)
3798 {
3799 TESTELSE_SB_SKIP( FlagName);
3800 Skip_BS(Data_BS_Remain(), DataName);
3801 RiskCalculationN++; //xxx_extension_flag is set, we can not check the end of the content, so a bit risky
3802 RiskCalculationD++;
3803 TESTELSE_SB_ELSE( FlagName);
3804 rbsp_trailing_bits();
3805 TESTELSE_SB_END();
3806 }
3807
3808 //---------------------------------------------------------------------------
rbsp_trailing_bits()3809 void File_Hevc::rbsp_trailing_bits()
3810 {
3811 size_t IsRisky;
3812 size_t Remain=Data_BS_Remain();
3813 if (!Remain)
3814 IsRisky=1; //rbsp_stop_one_bit is missing
3815 else if (Remain>8)
3816 IsRisky=1+Remain/80; //there is lot of unexpected content, not normal, so highly risky (risk weight based on remaining content size)
3817 else
3818 {
3819 int8u RealValue;
3820 const int8u ExpectedValue=1<<(Remain-1);
3821 Peek_S1(Remain, RealValue);
3822 if (RealValue==ExpectedValue)
3823 {
3824 // Conform to specs
3825 IsRisky=0;
3826 Mark_1();
3827 while (Data_BS_Remain())
3828 Mark_0();
3829 }
3830 else
3831 IsRisky=1; //there is some unexpected content, not normal, so highly risky
3832 }
3833 if (IsRisky)
3834 {
3835 Skip_BS(Remain, "Unknown");
3836 RiskCalculationN+=IsRisky;
3837 RiskCalculationD+=IsRisky;
3838 }
3839 else
3840 RiskCalculationD++;
3841 }
3842
3843 } //NameSpace
3844
3845 #endif //MEDIAINFO_HEVC_YES
3846