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 // Pre-compilation
9 #include "MediaInfo/PreComp.h"
10 #ifdef __BORLANDC__
11 #pragma hdrstop
12 #endif
13 //---------------------------------------------------------------------------
14
15 //---------------------------------------------------------------------------
16 #include "MediaInfo/Setup.h"
17 //---------------------------------------------------------------------------
18
19 //---------------------------------------------------------------------------
20 #if defined(MEDIAINFO_SMPTEST0337_YES)
21 //---------------------------------------------------------------------------
22
23 //---------------------------------------------------------------------------
24 #include "MediaInfo/Audio/File_SmpteSt0337.h"
25 #if defined(MEDIAINFO_AAC_YES)
26 #include "MediaInfo/Audio/File_Aac.h"
27 #endif
28 #if defined(MEDIAINFO_AC3_YES)
29 #include "MediaInfo/Audio/File_Ac3.h"
30 #endif
31 #if defined(MEDIAINFO_AC4_YES)
32 #include "MediaInfo/Audio/File_Ac4.h"
33 #endif
34 #if defined(MEDIAINFO_ADM_YES)
35 #include "MediaInfo/Audio/File_Adm.h"
36 #endif
37 #if defined(MEDIAINFO_DOLBYE_YES)
38 #include "MediaInfo/Audio/File_DolbyE.h"
39 #endif
40 #if defined(MEDIAINFO_MPEGA_YES)
41 #include "MediaInfo/Audio/File_Mpega.h"
42 #endif
43 #if MEDIAINFO_EVENTS
44 #include "MediaInfo/MediaInfo_Events.h"
45 #endif // MEDIAINFO_EVENTS
46 #if MEDIAINFO_SEEK
47 #include "MediaInfo/MediaInfo_Internal.h"
48 #endif // MEDIAINFO_SEEK
49 #if defined(MEDIAINFO_ADM_YES)
50 #include <zlib.h>
51 #endif
52 #include "MediaInfo/File_Unknown.h"
53 #include "MediaInfo/MediaInfo_Config_MediaInfo.h"
54 //---------------------------------------------------------------------------
55
56 namespace MediaInfoLib
57 {
58
59 //***************************************************************************
60 // Infos
61 //***************************************************************************
62
63 //---------------------------------------------------------------------------
64 static const char* Smpte_St0337_data_type[]= // SMPTE ST 338
65 {
66 "",
67 "AC-3",
68 "Time stamp",
69 "Pause",
70 "MPEG Audio",
71 "MPEG Audio",
72 "MPEG Audio",
73 "AAC",
74 "MPEG Audio",
75 "MPEG Audio",
76 "AAC",
77 "AAC",
78 "",
79 "",
80 "",
81 "",
82 "E-AC-3",
83 "DTS",
84 "WMA",
85 "AAC",
86 "AAC",
87 "E-AC-3",
88 "",
89 "",
90 "AC-4",
91 "MPEG-H 3D Audio",
92 "Utility",
93 "KLV",
94 "Dolby E",
95 "Captioning",
96 "User defined",
97 "Extended",
98 "ADM",
99 };
100
101 //---------------------------------------------------------------------------
102 static stream_t Smpte_St0337_data_type_StreamKind[sizeof(Smpte_St0337_data_type)/sizeof(char*)]= // SMPTE 338M
103 {
104 Stream_Max,
105 Stream_Audio,
106 Stream_Max,
107 Stream_Max,
108 Stream_Audio,
109 Stream_Audio,
110 Stream_Audio,
111 Stream_Max,
112 Stream_Audio,
113 Stream_Audio,
114 Stream_Max,
115 Stream_Max,
116 Stream_Max,
117 Stream_Max,
118 Stream_Max,
119 Stream_Max,
120 Stream_Max,
121 Stream_Max,
122 Stream_Max,
123 Stream_Max,
124 Stream_Max,
125 Stream_Max,
126 Stream_Max,
127 Stream_Max,
128 Stream_Max,
129 Stream_Max,
130 Stream_Max,
131 Stream_Menu,
132 Stream_Audio,
133 Stream_Text,
134 Stream_Max,
135 Stream_Max,
136 Stream_Audio,
137 };
138
139 #if defined(MEDIAINFO_ADM_YES)
140 static const char* Smpte_St0337_Adm_multiple_chunk_flag[4]=
141 {
142 "Full",
143 "First",
144 "Intermediate",
145 "Last",
146 };
147 static const char* Smpte_St0337_Adm_format_type[2]=
148 {
149 "UTF-8",
150 "UTF-8 gzip",
151 };
152 #endif
153
154 //***************************************************************************
155 // Constructor/Destructor
156 //***************************************************************************
157
158 //---------------------------------------------------------------------------
File_SmpteSt0337()159 File_SmpteSt0337::File_SmpteSt0337()
160 :File_Pcm_Base()
161 {
162 // Configuration
163 #if MEDIAINFO_EVENTS
164 ParserIDs[0]=MediaInfo_Parser_Aes3;
165 #endif // MEDIAINFO_EVENTS
166 MustSynchronize=true;
167 Buffer_TotalBytes_FirstSynched_Max=256*1024;
168 PTS_DTS_Needed=true;
169
170 // In
171 Container_Bits=0;
172 Endianness=0x00;
173 Aligned=false;
174
175 // Temp
176 FrameRate=0;
177 Stream_Bits=0;
178 data_type=(int32u)-1;
179 GuardBand_Before=0;
180 GuardBand_After=0;
181 NullPadding_Size=0;
182
183 // Parser
184 Parser=NULL;
185
186 #if MEDIAINFO_SEEK
187 Duration_Detected=false;
188 #endif // MEDIAINFO_SEEK
189 }
190
191 //---------------------------------------------------------------------------
~File_SmpteSt0337()192 File_SmpteSt0337::~File_SmpteSt0337()
193 {
194 delete Parser; // Parser=NULL;
195 }
196
197 //***************************************************************************
198 // Streams management
199 //***************************************************************************
200
201 //---------------------------------------------------------------------------
Streams_Accept()202 void File_SmpteSt0337::Streams_Accept()
203 {
204 Fill(Stream_General, 0, General_Format, "SMPTE ST 337");
205 Fill(Stream_General, 0, General_OverallBitRate_Mode, "CBR");
206 }
207
208 //---------------------------------------------------------------------------
Streams_Fill()209 void File_SmpteSt0337::Streams_Fill()
210 {
211 if (Parser && Parser->Status[IsAccepted])
212 {
213 Fill(Parser);
214 Merge(*Parser);
215
216 if (Parser->Count_Get(Stream_Audio))
217 {
218 FrameRate=Retrieve(Stream_Audio, 0, Audio_FrameRate).To_float64();
219 float64 FrameRate_Int=float64_int64s(FrameRate);
220 if (FrameRate>=FrameRate_Int/1.0015 && FrameRate<=FrameRate_Int/1.0005)
221 FrameRate=FrameRate_Int/1.001;
222 }
223 }
224 else if (data_type<sizeof(Smpte_St0337_data_type_StreamKind)/sizeof(stream_t))
225 {
226 if (Retrieve(Stream_Audio, 0, Audio_Format).empty() && Smpte_St0337_data_type_StreamKind[data_type]!=Stream_Max)
227 {
228 Stream_Prepare(Smpte_St0337_data_type_StreamKind[data_type]);
229 Fill(StreamKind_Last, 0, Fill_Parameter(StreamKind_Last, Generic_Format), Smpte_St0337_data_type[data_type]);
230 Fill(StreamKind_Last, 0, Fill_Parameter(StreamKind_Last, Generic_Codec), Smpte_St0337_data_type[data_type]);
231 }
232 }
233
234 // Bit rate
235 if (FrameRate)
236 {
237 size_t StartPosToClear=0;
238 float64 FrameSize=0;
239
240 if (FrameSizes.size()==1)
241 {
242 FrameSize=FrameSizes.begin()->first;
243 }
244 else if (FrameSizes.size()==2 && ((--FrameSizes.end())->first-FrameSizes.begin()->first)*4==Container_Bits && FrameSizes.begin()->second*3<=(--FrameSizes.end())->second*2 && (FrameSizes.begin()->second+1)*3>=(--FrameSizes.end())->second*2)
245 {
246 // Maybe NTSC frame rate and 48 kHz.
247 FrameSize=FrameSizes.begin()->first+((float64)Container_Bits)/4*3/5; //2x small then 3x big
248 }
249 else
250 {
251 int64u FrameSize_Total=0;
252 int64u FrameSize_Count=0;
253 for (std::map<int64u, int64u>::iterator F=FrameSizes.begin(); F!=FrameSizes.end(); ++F)
254 {
255 FrameSize_Total+=F->first*F->second;
256 FrameSize_Count+=F->second;
257 }
258 if (FrameSize_Count>=10)
259 FrameSize=((float64)FrameSize_Total/FrameSize_Count);
260 }
261
262 if (FrameSize)
263 {
264 float64 BitRate=FrameSize*8*FrameRate;
265 float64 BitRate_Theory=Container_Bits*2*48000;
266 if (BitRate>=BitRate_Theory*0.999 && BitRate<=BitRate_Theory*1.001)
267 BitRate=BitRate_Theory;
268 Fill(Stream_General, 0, General_OverallBitRate, BitRate, 0, true);
269 Fill(Stream_Audio, 0, Audio_BitRate_Encoded, BitRate, 0, true);
270 StartPosToClear=1;
271 }
272
273 //Underlying encoded bit rate has no meaning
274 if (StartPosToClear)
275 {
276 for (size_t i=StartPosToClear; i<Count_Get(Stream_Audio); i++)
277 Fill(Stream_Audio, i, Audio_BitRate_Encoded, 0, 10, true);
278 }
279 else
280 {
281 for (size_t i=0; i<Count_Get(Stream_Audio); i++)
282 Clear(Stream_Audio, i, Audio_BitRate_Encoded);
283 }
284 }
285
286 for (size_t Pos=0; Pos<Count_Get(StreamKind_Last); Pos++)
287 {
288 if (!IsSub || Retrieve_Const(StreamKind_Last, Pos, "Metadata_MuxingMode").empty())
289 {
290 if (!IsSub && StreamKind_Last==Stream_Audio && Retrieve_Const(StreamKind_Last, Pos, "Format").empty())
291 {
292 Fill(Stream_Audio, Pos, Audio_Format, "PCM");
293 Fill(Stream_Audio, Pos, Audio_Channel_s_, 2);
294 }
295 if (Endianness=='L' && Retrieve(StreamKind_Last, Pos, "Format_Settings_Endianness")==__T("Little"))
296 Endianness='B';
297 switch (Endianness)
298 {
299 case 'B' :
300 Fill(StreamKind_Last, Pos, "Format_Settings", "Big");
301 Fill(StreamKind_Last, Pos, "Format_Settings_Endianness", "Big", Unlimited, true, true);
302 break;
303 case 'L' :
304 Fill(StreamKind_Last, Pos, "Format_Settings", "Little");
305 Fill(StreamKind_Last, Pos, "Format_Settings_Endianness", "Little", Unlimited, true, true);
306 break;
307 default : ;
308 }
309 Fill(StreamKind_Last, Pos, "Format_Settings_Mode", Container_Bits);
310 if (Retrieve(StreamKind_Last, Pos, Fill_Parameter(StreamKind_Last, Generic_BitDepth)).empty())
311 Fill(StreamKind_Last, Pos, Fill_Parameter(StreamKind_Last, Generic_BitDepth), Stream_Bits);
312 if (Retrieve(StreamKind_Last, Pos, Fill_Parameter(StreamKind_Last, Generic_BitRate_Mode))!=__T("CBR"))
313 Fill(StreamKind_Last, Pos, Fill_Parameter(StreamKind_Last, Generic_BitRate_Mode), "CBR");
314 }
315
316 if (IsSub && Retrieve_Const(StreamKind_Last, Pos, "Metadata_MuxingMode").empty())
317 Fill(StreamKind_Last, Pos, "MuxingMode", "SMPTE ST 337");
318 }
319 }
320
321 //---------------------------------------------------------------------------
Streams_Finish()322 void File_SmpteSt0337::Streams_Finish()
323 {
324 if (Parser && Parser->Status[IsAccepted])
325 {
326 Finish(Parser);
327 for (size_t Pos=0; Pos<Count_Get(Stream_Audio); Pos++)
328 {
329 if (!Parser->Retrieve(Stream_Audio, Pos, Audio_Duration).empty())
330 Fill(Stream_Audio, Pos, Audio_Duration, Parser->Retrieve(Stream_Audio, Pos, Audio_Duration), true);
331 if (!Parser->Retrieve(Stream_Audio, Pos, Audio_FrameCount).empty())
332 Fill(Stream_Audio, Pos, Audio_FrameCount, Parser->Retrieve(Stream_Audio, Pos, Audio_FrameCount), true);
333
334 if (!IsSub)
335 {
336 if (Retrieve(StreamKind_Last, Pos, Fill_Parameter(Stream_Audio, Generic_FrameCount)).empty() && File_Size!=(int64u)-1 && FrameSizes.size()==1)
337 Fill(StreamKind_Last, Pos, Fill_Parameter(StreamKind_Last, Generic_FrameCount), File_Size/FrameSizes.begin()->first);
338 if (Retrieve(StreamKind_Last, Pos, Fill_Parameter(StreamKind_Last, Generic_Duration)).empty())
339 Fill(StreamKind_Last, Pos, Fill_Parameter(StreamKind_Last, Generic_Duration), Retrieve(Stream_General, 0, General_Duration));
340 }
341 }
342 }
343
344 if (!IsSub && File_Size!=(int64u)-1)
345 {
346 Fill(Stream_Audio, 0, Audio_StreamSize_Encoded, File_Size, 10, true);
347 for (size_t Pos=1; Pos<Count_Get(Stream_Audio); Pos++)
348 Fill(Stream_Audio, Pos, Audio_StreamSize_Encoded, 0, 10, true);
349 }
350 }
351
352 //***************************************************************************
353 // Buffer - Global
354 //***************************************************************************
355
356 #if MEDIAINFO_SEEK
357 //---------------------------------------------------------------------------
Read_Buffer_Unsynched()358 void File_SmpteSt0337::Read_Buffer_Unsynched()
359 {
360 if (Frame_Count_NotParsedIncluded!=(int64u)-1 && FrameRate)
361 {
362 Frame_Count_NotParsedIncluded=float64_int64s(File_GoTo/FrameRate);
363 FrameInfo.DTS=Frame_Count_NotParsedIncluded*1000000000/48000;
364 }
365
366 if (Parser)
367 Parser->Open_Buffer_Unsynch();
368 }
369 #endif // MEDIAINFO_SEEK
370
371 //---------------------------------------------------------------------------
372 #if MEDIAINFO_SEEK
Read_Buffer_Seek(size_t Method,int64u Value,int64u ID)373 size_t File_SmpteSt0337::Read_Buffer_Seek (size_t Method, int64u Value, int64u ID)
374 {
375 // Init
376 if (!Duration_Detected)
377 {
378 MediaInfo_Internal MI;
379 MI.Option(__T("File_KeepInfo"), __T("1"));
380 Ztring ParseSpeed_Save=MI.Option(__T("ParseSpeed_Get"), __T(""));
381 Ztring Demux_Save=MI.Option(__T("Demux_Get"), __T(""));
382 MI.Option(__T("ParseSpeed"), __T("0"));
383 MI.Option(__T("Demux"), Ztring());
384 size_t MiOpenResult=MI.Open(File_Name);
385 MI.Option(__T("ParseSpeed"), ParseSpeed_Save); // This is a global value, need to reset it. TODO: local value
386 MI.Option(__T("Demux"), Demux_Save); // This is a global value, need to reset it. TODO: local value
387 if (!MiOpenResult)
388 return 0;
389
390 FrameRate=MI.Get(Stream_Audio, 0, __T("FrameRate")).To_float64();
391
392 Duration_Detected=true;
393 }
394
395 // Parsing
396 switch (Method)
397 {
398 case 0 :
399 if (FrameRate)
400 {
401 float64 FrameSize=3072000/FrameRate;
402 int64u FrameCount=float64_int64s(Value/FrameSize);
403 Value=float64_int64s(FrameCount*FrameSize);
404 }
405 GoTo(Value);
406 Open_Buffer_Unsynch();
407 return 1;
408 case 1 :
409 return Read_Buffer_Seek(0, File_Size*Value/10000, ID);
410 case 2 : // Timestamp
411 {
412 if (FrameRate)
413 return (size_t)-1; // Not supported
414
415 {
416 float64 FrameSize=3072000/FrameRate;
417 Unsynch_Frame_Count=float64_int64s(((float64)Value)/1000000000*FrameRate);
418 GoTo(float64_int64s(Unsynch_Frame_Count*FrameSize));
419 Open_Buffer_Unsynch();
420 return 1;
421 }
422 }
423 case 3 : // FrameNumber
424 {
425 if (FrameRate)
426 return (size_t)-1; // Not supported
427
428 {
429 float64 FrameSize=3072000/FrameRate;
430 Unsynch_Frame_Count=Value;
431 GoTo(float64_int64s(Unsynch_Frame_Count*FrameSize));
432 Open_Buffer_Unsynch();
433 return 1;
434 }
435 }
436 default : return (size_t)-1; // Not supported
437 }
438 }
439 #endif // MEDIAINFO_SEEK
440
441 //***************************************************************************
442 // Buffer - Synchro
443 //***************************************************************************
444
445 //---------------------------------------------------------------------------
Synchronize()446 bool File_SmpteSt0337::Synchronize()
447 {
448 // Guard band
449 size_t Buffer_Offset_Base=Buffer_Offset;
450
451 // Synchronizing
452 while (Buffer_Offset+16<=Buffer_Size)
453 {
454 if (!Status[IsAccepted] && File_Offset_FirstSynched==(int64u)-1 && Buffer_TotalBytes+Buffer_Offset>=Buffer_TotalBytes_FirstSynched_Max)
455 {
456 Reject();
457 return false;
458 }
459
460 if ((Container_Bits==0 || Container_Bits==16) && (!Aligned || ((Buffer_TotalBytes+Buffer_Offset)%4)==0))
461 {
462 if (Buffer[Buffer_Offset ]==0xF8
463 && Buffer[Buffer_Offset+1]==0x72
464 && Buffer[Buffer_Offset+2]==0x4E
465 && Buffer[Buffer_Offset+3]==0x1F) // 16-bit, BE
466 {
467 Container_Bits=16;
468 Stream_Bits=16;
469 Endianness='B'; // BE
470 break; // while()
471 }
472 if (Buffer[Buffer_Offset ]==0x72
473 && Buffer[Buffer_Offset+1]==0xF8
474 && Buffer[Buffer_Offset+2]==0x1F
475 && Buffer[Buffer_Offset+3]==0x4E) // 16-bit, LE
476 {
477 Container_Bits=16;
478 Stream_Bits=16;
479 Endianness='L'; // LE
480 break; // while()
481 }
482 }
483 if ((Container_Bits==0 || Container_Bits==20) && (!Aligned || ((Buffer_TotalBytes+Buffer_Offset)%5)==0))
484 {
485 if (Buffer[Buffer_Offset ]==0x6F
486 && Buffer[Buffer_Offset+1]==0x87
487 && Buffer[Buffer_Offset+2]==0x25
488 && Buffer[Buffer_Offset+3]==0x4E
489 && Buffer[Buffer_Offset+4]==0x1F) // 20-bit, BE
490 {
491 Container_Bits=20;
492 Stream_Bits=20;
493 Endianness='B'; // BE
494 break; // while()
495 }
496 }
497 if ((Container_Bits==0 || Container_Bits==20) && (!Aligned || ((Buffer_TotalBytes+Buffer_Offset)%5)==0))
498 {
499 if (Buffer[Buffer_Offset ]==0x72
500 && Buffer[Buffer_Offset+1]==0xF8
501 && Buffer[Buffer_Offset+2]==0xF6
502 && Buffer[Buffer_Offset+3]==0xE1
503 && Buffer[Buffer_Offset+4]==0x54) // 20-bit, LE
504 {
505 Container_Bits=20;
506 Stream_Bits=20;
507 Endianness='L'; // BE
508 break; // while()
509 }
510 }
511 if ((Container_Bits==0 || Container_Bits==24) && (!Aligned || ((Buffer_TotalBytes+Buffer_Offset)%6)==0))
512 {
513 if (Buffer[Buffer_Offset ]==0x96
514 && Buffer[Buffer_Offset+1]==0xF8
515 && Buffer[Buffer_Offset+2]==0x72
516 && Buffer[Buffer_Offset+3]==0xA5
517 && Buffer[Buffer_Offset+4]==0x4E
518 && Buffer[Buffer_Offset+5]==0x1F) // 24-bit, BE
519 {
520 Container_Bits=24;
521 Stream_Bits=24;
522 Endianness='B'; // BE
523 break; // while()
524 }
525 if (Buffer[Buffer_Offset ]==0x72
526 && Buffer[Buffer_Offset+1]==0xF8
527 && Buffer[Buffer_Offset+2]==0x96
528 && Buffer[Buffer_Offset+3]==0x1F
529 && Buffer[Buffer_Offset+4]==0x4E
530 && Buffer[Buffer_Offset+5]==0xA5) // 24-bit, LE
531 {
532 Container_Bits=24;
533 Stream_Bits=24;
534 Endianness='L'; // LE
535 break; // while()
536 }
537 if (Buffer[Buffer_Offset ]==0x00
538 && Buffer[Buffer_Offset+1]==0xF8
539 && Buffer[Buffer_Offset+2]==0x72
540 && Buffer[Buffer_Offset+3]==0x00
541 && Buffer[Buffer_Offset+4]==0x4E
542 && Buffer[Buffer_Offset+5]==0x1F) // 16-bit in 24-bit, BE
543 {
544 Container_Bits=24;
545 Stream_Bits=16;
546 Endianness='B'; // BE
547 NullPadding_Size=1;
548 break; // while()
549 }
550 if (Buffer[Buffer_Offset ]==0x00
551 && Buffer[Buffer_Offset+1]==0x72
552 && Buffer[Buffer_Offset+2]==0xF8
553 && Buffer[Buffer_Offset+3]==0x00
554 && Buffer[Buffer_Offset+4]==0x1F
555 && Buffer[Buffer_Offset+5]==0x4E) // 16-bit in 24-bit, LE
556 {
557 Container_Bits=24;
558 Stream_Bits=16;
559 Endianness='L'; // LE
560 NullPadding_Size=1;
561 break; // while()
562 }
563 if (Buffer[Buffer_Offset ]==0x6F
564 && Buffer[Buffer_Offset+1]==0x87
565 && Buffer[Buffer_Offset+2]==0x20
566 && Buffer[Buffer_Offset+3]==0x54
567 && Buffer[Buffer_Offset+4]==0xE1
568 && Buffer[Buffer_Offset+5]==0xF0) // 20-bit in 24-bit, BE
569 {
570 Container_Bits=24;
571 Stream_Bits=20;
572 Endianness='B'; // BE
573 break; // while()
574 }
575 if (Buffer[Buffer_Offset ]==0x20
576 && Buffer[Buffer_Offset+1]==0x87
577 && Buffer[Buffer_Offset+2]==0x6F
578 && Buffer[Buffer_Offset+3]==0xF0
579 && Buffer[Buffer_Offset+4]==0xE1
580 && Buffer[Buffer_Offset+5]==0x54) // 20-bit in 24-bit, LE
581 {
582 Container_Bits=24;
583 Stream_Bits=20;
584 Endianness='L'; // LE
585 break; // while()
586 }
587 }
588 if ((Container_Bits==0 || Container_Bits==32) && (!Aligned || ((Buffer_TotalBytes+Buffer_Offset)%8)==0))
589 {
590 if (Buffer[Buffer_Offset ]==0x00
591 && Buffer[Buffer_Offset+1]==0x00
592 && Buffer[Buffer_Offset+2]==0xF8
593 && Buffer[Buffer_Offset+3]==0x72
594 && Buffer[Buffer_Offset+4]==0x00
595 && Buffer[Buffer_Offset+5]==0x00
596 && Buffer[Buffer_Offset+6]==0x4E
597 && Buffer[Buffer_Offset+7]==0x1F) // 16-bit in 32-bit, BE
598 {
599 Container_Bits=32;
600 Stream_Bits=16;
601 Endianness='B'; // BE
602 NullPadding_Size=2;
603 break; // while()
604 }
605 if (Buffer[Buffer_Offset ]==0x00
606 && Buffer[Buffer_Offset+1]==0x00
607 && Buffer[Buffer_Offset+2]==0x72
608 && Buffer[Buffer_Offset+3]==0xF8
609 && Buffer[Buffer_Offset+4]==0x00
610 && Buffer[Buffer_Offset+5]==0x00
611 && Buffer[Buffer_Offset+6]==0x1F
612 && Buffer[Buffer_Offset+7]==0x4E) // 16-bit in 32-bit, LE
613 {
614 Container_Bits=32;
615 Stream_Bits=16;
616 Endianness='L'; // LE
617 NullPadding_Size=2;
618 break; // while()
619 }
620 if (Buffer[Buffer_Offset ]==0x00
621 && Buffer[Buffer_Offset+1]==0x6F
622 && Buffer[Buffer_Offset+2]==0x87
623 && Buffer[Buffer_Offset+3]==0x20
624 && Buffer[Buffer_Offset+4]==0x00
625 && Buffer[Buffer_Offset+5]==0x54
626 && Buffer[Buffer_Offset+6]==0xE1
627 && Buffer[Buffer_Offset+7]==0xF0) // 20-bit in 32-bit, BE
628 {
629 Container_Bits=32;
630 Stream_Bits=20;
631 Endianness='B'; // BE
632 NullPadding_Size=1;
633 break; // while()
634 }
635 if (Buffer[Buffer_Offset ]==0x00
636 && Buffer[Buffer_Offset+1]==0x20
637 && Buffer[Buffer_Offset+2]==0x87
638 && Buffer[Buffer_Offset+3]==0x6F
639 && Buffer[Buffer_Offset+4]==0x00
640 && Buffer[Buffer_Offset+5]==0xF0
641 && Buffer[Buffer_Offset+6]==0xE1
642 && Buffer[Buffer_Offset+7]==0x54) // 20-bit in 32-bit, LE
643 {
644 Container_Bits=32;
645 Stream_Bits=20;
646 Endianness='L'; // LE
647 NullPadding_Size=1;
648 break; // while()
649 }
650 if (Buffer[Buffer_Offset ]==0x00
651 && Buffer[Buffer_Offset+1]==0x96
652 && Buffer[Buffer_Offset+2]==0xF8
653 && Buffer[Buffer_Offset+3]==0x72
654 && Buffer[Buffer_Offset+4]==0x00
655 && Buffer[Buffer_Offset+5]==0xA5
656 && Buffer[Buffer_Offset+6]==0x4E
657 && Buffer[Buffer_Offset+7]==0x1F) // 24-bit in 32-bit, BE
658 {
659 Container_Bits=32;
660 Stream_Bits=24;
661 Endianness='B'; // BE
662 NullPadding_Size=1;
663 break; // while()
664 }
665 if (Buffer[Buffer_Offset ]==0x00
666 && Buffer[Buffer_Offset+1]==0x72
667 && Buffer[Buffer_Offset+2]==0xF8
668 && Buffer[Buffer_Offset+3]==0x96
669 && Buffer[Buffer_Offset+4]==0x00
670 && Buffer[Buffer_Offset+5]==0x1F
671 && Buffer[Buffer_Offset+6]==0x4E
672 && Buffer[Buffer_Offset+7]==0xA5) // 24-bit in 32-bit, LE
673 {
674 Container_Bits=32;
675 Stream_Bits=24;
676 Endianness='L'; // LE
677 NullPadding_Size=1;
678 break; // while()
679 }
680 }
681
682 if (Container_Bits>=4 && Aligned)
683 Buffer_Offset+=Container_Bits/4;
684 else
685 Buffer_Offset++;
686 }
687
688 // Parsing last bytes if needed
689 if (Buffer_Offset+16>Buffer_Size)
690 {
691 if (!Status[IsAccepted])
692 GuardBand_Before+=Buffer_Offset;
693 return false;
694 }
695
696 if (!Status[IsAccepted])
697 Accept("SMPTE ST 337");
698
699 // Guard band
700 GuardBand_Before+=Buffer_Offset-Buffer_Offset_Base;
701 if (GuardBand_After)
702 {
703 if (GuardBand_Before>GuardBand_After)
704 GuardBand_Before-=GuardBand_After;
705 else
706 GuardBand_Before=0;
707 GuardBand_After=0;
708 }
709
710 // Synched
711 return true;
712 }
713
714 //---------------------------------------------------------------------------
Synched_Test()715 bool File_SmpteSt0337::Synched_Test()
716 {
717 // Guard band
718 size_t Buffer_Offset_Base=Buffer_Offset;
719
720 // Skip NULL padding
721 size_t Buffer_Offset_Temp=Buffer_Offset;
722 if (Aligned)
723 {
724 if (Container_Bits==16)
725 {
726 while ((Buffer_TotalBytes+Buffer_Offset_Temp)%4) // Padding in part of the AES3 block
727 {
728 if (Buffer_Offset_Temp+1>Buffer_Size)
729 {
730 Element_WaitForMoreData();
731 return false;
732 }
733 if (Buffer[Buffer_Offset_Temp])
734 {
735 Trusted_IsNot("Bad sync");
736 return true;
737 }
738 Buffer_Offset_Temp++;
739 }
740 while(Buffer_Offset_Temp+4<=Buffer_Size && CC4(Buffer+Buffer_Offset_Temp)==0x00000000)
741 Buffer_Offset_Temp+=4;
742 if (Buffer_Offset_Temp+4>Buffer_Size)
743 {
744 Element_WaitForMoreData();
745 return false;
746 }
747 }
748 if (Container_Bits==20)
749 {
750 while ((Buffer_TotalBytes+Buffer_Offset_Temp)%5) // Padding in part of the AES3 block
751 {
752 if (Buffer_Offset_Temp+1>Buffer_Size)
753 {
754 Element_WaitForMoreData();
755 return false;
756 }
757 if (Buffer[Buffer_Offset_Temp])
758 {
759 Trusted_IsNot("Bad sync");
760 return true;
761 }
762 Buffer_Offset_Temp++;
763 }
764 while(Buffer_Offset_Temp+5<=Buffer_Size && CC5(Buffer+Buffer_Offset_Temp)==0x0000000000LL)
765 Buffer_Offset_Temp+=5;
766 if (Buffer_Offset_Temp+5>Buffer_Size)
767 {
768 Element_WaitForMoreData();
769 return false;
770 }
771 }
772 if (Container_Bits==24)
773 {
774 while ((Buffer_TotalBytes+Buffer_Offset_Temp)%6) // Padding in part of the AES3 block
775 {
776 if (Buffer_Offset_Temp+1>Buffer_Size)
777 {
778 Element_WaitForMoreData();
779 return false;
780 }
781 if (Buffer[Buffer_Offset_Temp])
782 {
783 Trusted_IsNot("Bad sync");
784 return true;
785 }
786 Buffer_Offset_Temp++;
787 }
788 while(Buffer_Offset_Temp+6<=Buffer_Size && CC6(Buffer+Buffer_Offset_Temp)==0x000000000000LL)
789 Buffer_Offset_Temp+=6;
790 if (Buffer_Offset_Temp+6>Buffer_Size)
791 {
792 Element_WaitForMoreData();
793 return false;
794 }
795 }
796 else if (Container_Bits==32)
797 {
798 while ((Buffer_TotalBytes+Buffer_Offset_Temp)%8) // Padding in part of the AES3 block
799 {
800 if (Buffer_Offset_Temp+1>Buffer_Size)
801 {
802 Element_WaitForMoreData();
803 return false;
804 }
805 if (Buffer[Buffer_Offset_Temp])
806 {
807 Trusted_IsNot("Bad sync");
808 return true;
809 }
810 Buffer_Offset_Temp++;
811 }
812 while(Buffer_Offset_Temp+8<=Buffer_Size && CC8(Buffer+Buffer_Offset_Temp)==0x0000000000000000LL)
813 Buffer_Offset_Temp+=8;
814 if (Buffer_Offset_Temp+8>Buffer_Size)
815 {
816 Element_WaitForMoreData();
817 return false;
818 }
819 }
820 }
821 else
822 {
823 while(Buffer_Offset_Temp+NullPadding_Size<Buffer_Size && !Buffer[Buffer_Offset_Temp+NullPadding_Size])
824 Buffer_Offset_Temp++;
825 if (Buffer_Offset_Temp+NullPadding_Size>=Buffer_Size)
826 {
827 Element_WaitForMoreData();
828 return false;
829 }
830 }
831
832 #if MEDIAINFO_TRACE
833 if (Buffer_Offset_Temp-Buffer_Offset)
834 {
835 Element_Size=Buffer_Offset_Temp-Buffer_Offset;
836 Skip_XX(Buffer_Offset_Temp-Buffer_Offset, "Guard band");
837 }
838 #endif // MEDIAINFO_TRACE
839 Buffer_Offset=Buffer_Offset_Temp;
840
841 // Must have enough buffer for having header
842 if (Buffer_Offset+16>Buffer_Size)
843 return false;
844
845 // Quick test of synchro
846 switch (Endianness)
847 {
848 case 'B' :
849 switch (Container_Bits)
850 {
851 case 16 : if (CC4(Buffer+Buffer_Offset)!=0xF8724E1F) {Synched=false; return true;} break;
852 case 20 : if (CC5(Buffer+Buffer_Offset)!=0x6F87254E1FLL) {Synched=false; return true;} break;
853 case 24 :
854 switch (Stream_Bits)
855 {
856 case 16 : if (CC6(Buffer+Buffer_Offset)!=0x00F872004E1FLL) {Synched=false; return true;} break;
857 case 20 : if (CC6(Buffer+Buffer_Offset)!=0x6F872054E1F0LL) {Synched=false; return true;} break;
858 case 24 : if (CC6(Buffer+Buffer_Offset)!=0x96F872A54E1FLL) {Synched=false; return true;} break;
859 default : ;
860 }
861 break;
862 case 32 :
863 switch (Stream_Bits)
864 {
865 case 16 : if (CC8(Buffer+Buffer_Offset)!=0x0000F87200004E1FLL) {Synched=false; return true;} break;
866 case 20 : if (CC8(Buffer+Buffer_Offset)!=0x006F87200054E1F0LL) {Synched=false; return true;} break;
867 case 24 : if (CC8(Buffer+Buffer_Offset)!=0x0096F87200A5F41FLL) {Synched=false; return true;} break;
868 default : ;
869 }
870 break;
871 default : ;
872 }
873 break;
874 case 'L' :
875 switch (Container_Bits)
876 {
877 case 16 : if (CC4(Buffer+Buffer_Offset)!=0x72F81F4E) {Synched=false; return true;} break;
878 case 20 : if (CC5(Buffer+Buffer_Offset)!=0x72F8F6E154LL) {Synched=false; return true;} break;
879 case 24 :
880 switch (Stream_Bits)
881 {
882 case 16 : if (CC6(Buffer+Buffer_Offset)!=0x0072F8001F4ELL) {Synched=false; return true;} break;
883 case 20 : if (CC6(Buffer+Buffer_Offset)!=0x20876FF0E154LL) {Synched=false; return true;} break;
884 case 24 : if (CC6(Buffer+Buffer_Offset)!=0x72F8961F4EA5LL) {Synched=false; return true;} break;
885 default : ;
886 }
887 break;
888 case 32 :
889 switch (Stream_Bits)
890 {
891 case 16 : if (CC8(Buffer+Buffer_Offset)!=0x000072F800001F4ELL) {Synched=false; return true;} break;
892 case 20 : if (CC8(Buffer+Buffer_Offset)!=0x0020876F00F0E154LL) {Synched=false; return true;} break;
893 case 24 : if (CC8(Buffer+Buffer_Offset)!=0x0072F896001F4EA5LL) {Synched=false; return true;} break;
894 default : ;
895 }
896 break;
897 default : ;
898 }
899 break;
900 default : ; // Should never happen
901 }
902
903 // Guard band
904 GuardBand_Before+=Buffer_Offset-Buffer_Offset_Base;
905 if (GuardBand_After)
906 {
907 if (GuardBand_Before>GuardBand_After)
908 GuardBand_Before-=GuardBand_After;
909 else
910 GuardBand_Before=0;
911 GuardBand_After=0;
912 }
913
914 // We continue
915 return true;
916 }
917
918 //---------------------------------------------------------------------------
Synched_Init()919 void File_SmpteSt0337::Synched_Init()
920 {
921 if (Frame_Count_NotParsedIncluded==(int64u)-1)
922 Frame_Count_NotParsedIncluded=0;
923 if (!IsSub)
924 {
925 FrameInfo.DTS=0; //No DTS in container
926 FrameInfo.PTS=0; //No PTS in container
927 }
928 }
929
930 //***************************************************************************
931 // Per element
932 //***************************************************************************
933
934 //---------------------------------------------------------------------------
Header_Parse()935 void File_SmpteSt0337::Header_Parse()
936 {
937 // Parsing
938 int32u Size=0;
939 switch (Endianness)
940 {
941 case 'B' :
942 switch (Container_Bits)
943 {
944 case 16 : Size=BigEndian2int16u(Buffer+Buffer_Offset+6) ; break;
945 case 20 : Size=BigEndian2int24u(Buffer+Buffer_Offset+7)&0x0FFFFF; break;
946 case 24 :
947 switch (Stream_Bits)
948 {
949 case 16 : Size=BigEndian2int16u(Buffer+Buffer_Offset+9) ; break;
950 case 20 : Size=BigEndian2int24u(Buffer+Buffer_Offset+9)>>4; break;
951 case 24 : Size=BigEndian2int24u(Buffer+Buffer_Offset+9) ; break;
952 default : ;
953 }
954 break;
955 case 32 :
956 switch (Stream_Bits)
957 {
958 case 16 : Size=BigEndian2int16u(Buffer+Buffer_Offset+0xE) ; break;
959 case 20 : Size=BigEndian2int24u(Buffer+Buffer_Offset+0xD)>>4; break;
960 case 24 : Size=BigEndian2int24u(Buffer+Buffer_Offset+0xD) ; break;
961 default : ;
962 }
963 break;
964 default : ;
965 }
966 break;
967 case 'L' :
968 switch (Container_Bits)
969 {
970 case 16 : Size=LittleEndian2int16u(Buffer+Buffer_Offset+6) ; break;
971 case 20 : Size=LittleEndian2int24u(Buffer+Buffer_Offset+7)>>4; break;
972 case 24 :
973 switch (Stream_Bits)
974 {
975 case 16 : Size=LittleEndian2int16u(Buffer+Buffer_Offset+0xA) ; break;
976 case 20 : Size=LittleEndian2int24u(Buffer+Buffer_Offset+0x9)>>4; break;
977 case 24 : Size=LittleEndian2int24u(Buffer+Buffer_Offset+0x9) ; break;
978 default : ;
979 }
980 break;
981 case 32 :
982 switch (Stream_Bits)
983 {
984 case 16 : Size=LittleEndian2int16u(Buffer+Buffer_Offset+0xE) ; break;
985 case 20 : Size=LittleEndian2int24u(Buffer+Buffer_Offset+0xD)>>4; break;
986 case 24 : Size=LittleEndian2int24u(Buffer+Buffer_Offset+0xD) ; break;
987 default : ;
988 }
989 break;
990 default : ;
991 }
992 break;
993 default : ; // Should never happen
994 }
995
996 // Adaptation
997 if (Container_Bits!=Stream_Bits)
998 {
999 Size*=Container_Bits; Size/=Stream_Bits;
1000 }
1001
1002 // Coherency test
1003 if (!IsSub && !Status[IsAccepted])
1004 {
1005 size_t Offset=Buffer_Offset+(size_t)(Container_Bits*4/8+Size/8);
1006 while (Offset<Buffer_Size && Buffer[Offset]==0x00)
1007 Offset++;
1008 if (Offset+Container_Bits/4>Buffer_Size)
1009 {
1010 Element_WaitForMoreData();
1011 return;
1012 }
1013 Offset/=Container_Bits/4;
1014 Offset*=Container_Bits/4;
1015 bool IsOK=true;
1016 for (int8u Pos=0; Pos<Container_Bits/4; Pos++)
1017 if (Buffer[Buffer_Offset+Pos]!=Buffer[Offset+Pos])
1018 {
1019 IsOK=false;
1020 break;
1021 }
1022 if (!IsOK)
1023 {
1024 Trusted_IsNot("Bad sync");
1025 Buffer_Offset++;
1026 return;
1027 }
1028 }
1029
1030 // Filling
1031 Padding=(int8u)(Size%Container_Bits);
1032 if (Padding)
1033 Size+=Container_Bits-Padding;
1034 Header_Fill_Size(Container_Bits*4/8+Size/8);
1035 Header_Fill_Code(0, "SMPTE ST 337");
1036 }
1037
1038 //---------------------------------------------------------------------------
Data_Parse()1039 void File_SmpteSt0337::Data_Parse()
1040 {
1041 #if MEDIAINFO_DEMUX
1042 FrameInfo.PTS=FrameInfo.DTS;
1043 Demux_random_access=true;
1044 Element_Code=(int64u)-1;
1045 #endif //MEDIAINFO_DEMUX
1046
1047 // Adapting
1048 const int8u* Save_Buffer=NULL;
1049 size_t Save_Buffer_Offset=0;
1050 size_t Save_Buffer_Size=0;
1051 int64u Save_Element_Size=0;
1052
1053 if (Endianness=='L'|| Container_Bits!=Stream_Bits)
1054 {
1055 int8u* Info=new int8u[(size_t)Element_Size];
1056 int8u* Info_Temp=Info;
1057
1058 if (Endianness=='L' && Container_Bits==16 && Stream_Bits==16)
1059 {
1060 // Source: 16LE / L1L0 L3L2 R1R0 R3R2
1061 // Dest : 16BE / L3L2 L1L0 R3R2 R1R0
1062 while (Element_Offset+4<=Element_Size)
1063 {
1064 size_t Buffer_Pos=Buffer_Offset+(size_t)Element_Offset;
1065
1066 *(Info_Temp++)= Buffer[Buffer_Pos+1] ;
1067 *(Info_Temp++)= Buffer[Buffer_Pos ] ;
1068 *(Info_Temp++)= Buffer[Buffer_Pos+3] ;
1069 *(Info_Temp++)= Buffer[Buffer_Pos+2] ;
1070
1071 Element_Offset+=4;
1072 }
1073 if (Element_Offset+2<=Element_Size) // Only in half of the AES3 stream
1074 {
1075 size_t Buffer_Pos=Buffer_Offset+(size_t)Element_Offset;
1076
1077 *(Info_Temp++)= Buffer[Buffer_Pos+1] ;
1078 *(Info_Temp++)= Buffer[Buffer_Pos ] ;
1079
1080 Element_Offset+=2;
1081 }
1082 }
1083
1084 if (Endianness=='L' && Container_Bits==20 && Stream_Bits==20)
1085 {
1086 // Source: 20LE / L1L0 L3L2 R0L4 R2R1 R4R3
1087 // Dest : 20BE / L4L3 L2L1 L0R4 R3R2 R1R0
1088 while (Element_Offset+5<=Element_Size)
1089 {
1090 size_t Buffer_Pos=Buffer_Offset+(size_t)Element_Offset;
1091
1092 *(Info_Temp++)=(Buffer[Buffer_Pos+2]<<4 ) | (Buffer[Buffer_Pos+1]>>4 );
1093 *(Info_Temp++)=(Buffer[Buffer_Pos+1]<<4 ) | (Buffer[Buffer_Pos+0]>>4 );
1094 *(Info_Temp++)=(Buffer[Buffer_Pos+0]<<4 ) | (Buffer[Buffer_Pos+4]>>4 );
1095 *(Info_Temp++)=(Buffer[Buffer_Pos+4]<<4 ) | (Buffer[Buffer_Pos+3]>>4 );
1096 *(Info_Temp++)=(Buffer[Buffer_Pos+3]<<4 ) | (Buffer[Buffer_Pos+2]>>4 );
1097
1098 Element_Offset+=5;
1099 }
1100 }
1101
1102 if (Endianness=='L' && Container_Bits==24 && Stream_Bits==16)
1103 {
1104 // Source: XXXX L1L0 L3L2 XXXX R1R0 R3R2
1105 // Dest : 16BE / L3L2 L1L0 R3R2 R1R0
1106 while (Element_Offset+6<=Element_Size)
1107 {
1108 size_t Buffer_Pos=Buffer_Offset+(size_t)Element_Offset;
1109
1110 *(Info_Temp++)= Buffer[Buffer_Pos+2] ;
1111 *(Info_Temp++)= Buffer[Buffer_Pos+1] ;
1112 *(Info_Temp++)= Buffer[Buffer_Pos+5] ;
1113 *(Info_Temp++)= Buffer[Buffer_Pos+4] ;
1114
1115 Element_Offset+=6;
1116 }
1117 }
1118
1119 if (Endianness=='L' && Container_Bits==24 && Stream_Bits==20)
1120 {
1121 // Source: L0XX L2L1 L4L3 R0XX R2R1 R4R3
1122 // Dest : 20BE / L4L3 L2L1 L0R4 R3R2 R1R0
1123 while (Element_Offset+6<=Element_Size)
1124 {
1125 size_t Buffer_Pos=Buffer_Offset+(size_t)Element_Offset;
1126
1127 *(Info_Temp++)= Buffer[Buffer_Pos+2] ;
1128 *(Info_Temp++)= Buffer[Buffer_Pos+1] ;
1129 *(Info_Temp++)=(Buffer[Buffer_Pos ]&0xF0) | (Buffer[Buffer_Pos+5]>>4 );
1130 *(Info_Temp++)=(Buffer[Buffer_Pos+5]<<4 ) | (Buffer[Buffer_Pos+4]>>4 );
1131 *(Info_Temp++)=(Buffer[Buffer_Pos+4]<<4 ) | (Buffer[Buffer_Pos+3]>>4 );
1132
1133 Element_Offset+=6;
1134 }
1135 if (Element_Offset+3<=Element_Size)
1136 {
1137 size_t Buffer_Pos=Buffer_Offset+(size_t)Element_Offset;
1138
1139 *(Info_Temp++)= Buffer[Buffer_Pos+2] ;
1140 *(Info_Temp++)= Buffer[Buffer_Pos+1] ;
1141 *(Info_Temp++)=(Buffer[Buffer_Pos ]&0xF0) ;
1142 }
1143 }
1144
1145 if (Endianness=='L' && Container_Bits==24 && Stream_Bits==24)
1146 {
1147 // Source: 24LE / L1L0 L3L2 L5L3 R1R0 R3R2 R5R4
1148 // Dest : 24BE / L5L3 L3L2 L1L0 R5R4 R3R2 R1R0
1149 while (Element_Offset+6<=Element_Size)
1150 {
1151 size_t Buffer_Pos=Buffer_Offset+(size_t)Element_Offset;
1152
1153 *(Info_Temp++)= Buffer[Buffer_Pos+2] ;
1154 *(Info_Temp++)= Buffer[Buffer_Pos+1] ;
1155 *(Info_Temp++)= Buffer[Buffer_Pos ] ;
1156 *(Info_Temp++)= Buffer[Buffer_Pos+5] ;
1157 *(Info_Temp++)= Buffer[Buffer_Pos+4] ;
1158 *(Info_Temp++)= Buffer[Buffer_Pos+3] ;
1159
1160 Element_Offset+=6;
1161 }
1162 }
1163
1164 if (Endianness=='L' && Container_Bits==32 && Stream_Bits==16)
1165 {
1166 // Source: XXXX XXXX L1L0 L3L2 XXXX XXXX R1R0 R3R2
1167 // Dest : 16BE / L3L2 L1L0 R3R2 R1R0
1168 while (Element_Offset+8<=Element_Size)
1169 {
1170 size_t Buffer_Pos=Buffer_Offset+(size_t)Element_Offset;
1171
1172 *(Info_Temp++)= Buffer[Buffer_Pos+3] ;
1173 *(Info_Temp++)= Buffer[Buffer_Pos+2] ;
1174 *(Info_Temp++)= Buffer[Buffer_Pos+7] ;
1175 *(Info_Temp++)= Buffer[Buffer_Pos+6] ;
1176
1177 Element_Offset+=8;
1178 }
1179 }
1180 if (Endianness=='L' && Container_Bits==32 && Stream_Bits==20)
1181 {
1182 // Source: XXXX L0XX L2L1 L4L3 XXXX R0XX R2R1 R4R3
1183 // Dest : 20BE / L4L3 L2L1 L0R4 R3R2 R1R0
1184 while (Element_Offset+8<=Element_Size)
1185 {
1186 size_t Buffer_Pos=Buffer_Offset+(size_t)Element_Offset;
1187
1188 *(Info_Temp++)= Buffer[Buffer_Pos+3] ;
1189 *(Info_Temp++)= Buffer[Buffer_Pos+2] ;
1190 *(Info_Temp++)=(Buffer[Buffer_Pos+1]&0xF0) | (Buffer[Buffer_Pos+7]>>4 );
1191 *(Info_Temp++)=(Buffer[Buffer_Pos+7]<<4 ) | (Buffer[Buffer_Pos+6]>>4 );
1192 *(Info_Temp++)=(Buffer[Buffer_Pos+6]<<4 ) | (Buffer[Buffer_Pos+5]>>4 );
1193
1194 Element_Offset+=8;
1195 }
1196 }
1197
1198 if (Endianness=='L' && Container_Bits==32 && Stream_Bits==24)
1199 {
1200 // Source: XXXX L1L0 L3L2 L5L3 XXXX R1R0 R3R2 R5R4
1201 // Dest : 24BE / L5L3 L3L2 L1L0 R5R4 R3R2 R1R0
1202 while (Element_Offset+8<=Element_Size)
1203 {
1204 size_t Buffer_Pos=Buffer_Offset+(size_t)Element_Offset;
1205
1206 *(Info_Temp++)= Buffer[Buffer_Pos+3] ;
1207 *(Info_Temp++)= Buffer[Buffer_Pos+2] ;
1208 *(Info_Temp++)= Buffer[Buffer_Pos+1] ;
1209 *(Info_Temp++)= Buffer[Buffer_Pos+7] ;
1210 *(Info_Temp++)= Buffer[Buffer_Pos+6] ;
1211 *(Info_Temp++)= Buffer[Buffer_Pos+5] ;
1212
1213 Element_Offset+=8;
1214 }
1215 }
1216
1217 if (Endianness=='B' && Container_Bits==24 && Stream_Bits==20)
1218 {
1219 // Source: L4L3 L2L1 L0XX R4R3 R2R1 R0XX
1220 // Dest : 20BE / L4L3 L2L1 L0R4 R3R2 R1R0
1221 while (Element_Offset+6<=Element_Size)
1222 {
1223 size_t Buffer_Pos=Buffer_Offset+(size_t)Element_Offset;
1224
1225 *(Info_Temp++)= Buffer[Buffer_Pos ] ;
1226 *(Info_Temp++)= Buffer[Buffer_Pos+1] ;
1227 *(Info_Temp++)=(Buffer[Buffer_Pos+2]&0xF0) | (Buffer[Buffer_Pos+3]>>4 );
1228 *(Info_Temp++)=(Buffer[Buffer_Pos+3]<<4 ) | (Buffer[Buffer_Pos+4]>>4 );
1229 *(Info_Temp++)=(Buffer[Buffer_Pos+4]<<4 ) | (Buffer[Buffer_Pos+5]>>4 );
1230
1231 Element_Offset+=6;
1232 }
1233 }
1234
1235 Save_Buffer=Buffer;
1236 Save_Buffer_Offset=Buffer_Offset;
1237 Save_Buffer_Size=Buffer_Size;
1238 Save_Element_Size=Element_Size;
1239 File_Offset+=Buffer_Offset;
1240 Buffer=Info;
1241 Buffer_Offset=0;
1242 Buffer_Size=Info_Temp-Info;
1243 Element_Offset=0;
1244 Element_Size=Buffer_Size;
1245 }
1246
1247 // Parsing
1248 int32u length_code;
1249 int8u data_stream_number;
1250 int32u data_type_New;
1251 int8u data_type_dependent;
1252 int8u* UncompressedData=NULL;
1253 size_t UncompressedData_Size=0;
1254 string MuxingMode;
1255 Element_Begin1("Header");
1256 BS_Begin();
1257 Skip_S3(Stream_Bits, "Pa");
1258 Skip_S3(Stream_Bits, "Pb");
1259 Element_Begin1("Pc");
1260 Get_S1 ( 3, data_stream_number, "data_stream_number");
1261 Get_S1 ( 5, data_type_dependent, "data_type_dependent");
1262 Skip_SB( "error_flag");
1263 Info_S1( 2, data_mode, "data_mode"); Param_Info2(16+4*data_mode, " bits");
1264 Get_S4 ( 5, data_type_New, "data_type"); Param_Info1(Smpte_St0337_data_type[data_type_New]);
1265 if (Stream_Bits>16)
1266 Skip_S1(Stream_Bits-16, "reserved");
1267 Element_End0();
1268 Get_S3 (Stream_Bits, length_code, "length_code"); Param_Info2(length_code/8, " bytes");
1269 if (data_type_New==31)
1270 {
1271 if (Stream_Bits>16)
1272 Skip_S1(Stream_Bits-16, "reserved");
1273 Get_S4 (16, data_type_New, "data_type");
1274 data_type_New+=32;
1275 Skip_S3(Stream_Bits, "reserved");
1276 if (data_type_New==32+1) // ADM
1277 {
1278 int8u multiple_chunk_flag=data_type_dependent>>3; //2-bit
1279 bool format_flag=((data_type_dependent>>2)&1)?true:false; //1-bit
1280 bool assemble_flag=((data_type_dependent>>1)&1)?true:false; //1-bit
1281 bool changedMetadata_flag=(data_type_dependent&1)?true:false; //1-bit
1282 Param_Info1(Smpte_St0337_Adm_multiple_chunk_flag[multiple_chunk_flag]);
1283 int8u format_type=0, Track_ID=0, track_numbers=0, in_timeline_flag=0;
1284 if (format_flag)
1285 {
1286 Element_Begin1("format_info");
1287 Skip_S2(12, "reserved");
1288 Get_S1 (4, format_type, "format_type"); Param_Info1C(format_type<sizeof(Smpte_St0337_Adm_format_type)/sizeof(const char*), Smpte_St0337_Adm_format_type[format_type]);
1289 if (Stream_Bits>16)
1290 Skip_S1(Stream_Bits-16, "reserved");
1291 }
1292 if (assemble_flag)
1293 {
1294 Element_Begin1("assemble_info");
1295 Skip_S2(2, "reserved");
1296 Get_S1 (6, Track_ID, "Track_ID");
1297 Get_S1 (6, track_numbers, "track_numbers");
1298 Get_S1 (2, in_timeline_flag, "in_timeline_flag"); Param_Info1(Smpte_St0337_Adm_multiple_chunk_flag[in_timeline_flag]);
1299 if (Stream_Bits>16)
1300 Skip_S1(Stream_Bits-16, "reserved");
1301 Element_End0();
1302 }
1303 MuxingMode=string("SMPTE ST 337 / SMPTE ST 2116");
1304 if (!data_stream_number && !multiple_chunk_flag && !in_timeline_flag && format_type<=1)
1305 {
1306 MuxingMode+=" Level ";
1307 MuxingMode+='A';
1308 if (format_type==1)
1309 MuxingMode+='X';
1310 if (track_numbers<10)
1311 MuxingMode+='1'+track_numbers;
1312 else
1313 {
1314 MuxingMode+='1';
1315 MuxingMode+='0'-10+track_numbers;
1316 }
1317 }
1318 if (Parser || data_stream_number || multiple_chunk_flag || in_timeline_flag || format_type>1 || Track_ID || track_numbers)
1319 {
1320 Skip_BS(Data_BS_Remain(), "Data (Unsupported)");
1321 }
1322 else if (format_type==1)
1323 {
1324 int8u* Compressed=new int8u[Data_BS_Remain()/8];
1325 size_t Compressed_Offset=0;
1326 while (Data_BS_Remain())
1327 {
1328 int64u Data;
1329 Get_S6(Stream_Bits*2, Data, "Data");
1330 for (int8u i=0; i<Stream_Bits/4; i++)
1331 {
1332 Compressed[Compressed_Offset++]=(int8u)(Data>>((Stream_Bits/4-i-1)*8));
1333 }
1334 }
1335 BS_End();
1336
1337 // Adapting
1338 const int8u* Save_Buffer=Buffer;
1339 size_t Save_Buffer_Offset=Buffer_Offset;
1340 size_t Save_Buffer_Size=Buffer_Size;
1341 int64u Save_Element_Size=Element_Size;
1342 Buffer=Compressed;
1343 Buffer_Offset=0;
1344 Buffer_Size=Compressed_Offset;
1345 Element_Offset=0;
1346 Element_Size=Buffer_Size;
1347
1348 //Uncompress init
1349 z_stream strm;
1350 strm.next_in=(Bytef*)Compressed;;
1351 strm.avail_in=Compressed_Offset;
1352 strm.next_out=NULL;
1353 strm.avail_out=0;
1354 strm.total_out=0;
1355 strm.zalloc=Z_NULL;
1356 strm.zfree=Z_NULL;
1357 inflateInit2(&strm, 15+16); // 15 + 16 are magic values for gzip
1358
1359 //Prepare out
1360 strm.avail_out=0x10000; //Blocks of 64 KiB, arbitrary chosen, as a begin
1361 strm.next_out=(Bytef*)new Bytef[strm.avail_out];
1362
1363 //Parse compressed data, with handling of the case the output buffer is not big enough
1364 for (;;)
1365 {
1366 //inflate
1367 int inflate_Result=inflate(&strm, Z_NO_FLUSH);
1368 if (inflate_Result<0)
1369 break;
1370
1371 //Check if we need to stop
1372 if (strm.avail_out || inflate_Result)
1373 break;
1374
1375 //Need to increase buffer
1376 size_t UncompressedData_NewMaxSize=strm.total_out*4;
1377 int8u* UncompressedData_New=new int8u[UncompressedData_NewMaxSize];
1378 memcpy(UncompressedData_New, strm.next_out-strm.total_out, strm.total_out);
1379 delete[] strm.next_out; strm.next_out=UncompressedData_New;
1380 strm.next_out=strm.next_out+strm.total_out;
1381 strm.avail_out=UncompressedData_NewMaxSize-strm.total_out;
1382 }
1383 UncompressedData=strm.next_out-strm.total_out;
1384 UncompressedData_Size=strm.total_out;
1385
1386 // Adapting
1387 Buffer=Save_Buffer;
1388 Buffer_Offset=Save_Buffer_Offset;
1389 Buffer_Size=Save_Buffer_Size;
1390 Element_Offset=Save_Element_Size;
1391 Element_Size=Save_Element_Size;
1392 }
1393 Element_End0();
1394 }
1395 }
1396 BS_End();
1397 Element_End0();
1398
1399 if (data_type_New!=data_type)
1400 {
1401 delete Parser; Parser=NULL;
1402 data_type=data_type_New;
1403 }
1404 if (Parser==NULL)
1405 {
1406 switch(data_type)
1407 {
1408 // SMPTE ST338
1409 case 1 : // AC-3
1410 case 16 : // E-AC-3 (professional)
1411 case 21 : // E-AC-3 (consumer)
1412 Parser=new File_Ac3();
1413 ((File_Ac3*)Parser)->Frame_Count_Valid=2;
1414 #if MEDIAINFO_DEMUX
1415 if (Config->Demux_Unpacketize_Get())
1416 {
1417 Demux_UnpacketizeContainer=false; //No demux from this parser
1418 Demux_Level=4; //Intermediate
1419 Parser->Demux_Level=2; //Container
1420 Parser->Demux_UnpacketizeContainer=true;
1421 }
1422 #endif //MEDIAINFO_DEMUX
1423 break;
1424 case 4 : // MPEG-1 Layer 1
1425 case 5 : // MPEG-1 Layer 2/3, MPEG-2 Layer 1/2/3 without extension
1426 case 6 : // MPEG-2 Layer 1/2/3 with extension
1427 case 8 : // MPEG-2 Layer 1 low frequency
1428 case 9 : // MPEG-2 Layer 2/3 low frequency
1429 Parser=new File_Mpega();
1430 break;
1431 case 7 : // MPEG-2 AAC in ADTS
1432 case 19 : // MPEG-2 AAC in ADTS low frequency
1433 #if defined(MEDIAINFO_AAC_YES)
1434 Parser=new File_Aac();
1435 ((File_Aac*)Parser)->Mode=File_Aac::Mode_ADTS;
1436 #else
1437 {
1438 //Filling
1439 File__Analyze* Parser=new File_Unknown();
1440 Open_Buffer_Init(Parser);
1441 Parser->Stream_Prepare(Stream_Audio);
1442 Parser->Fill(Stream_Audio, 0, Audio_Format, "AAC");
1443 Parser->Fill(Stream_Audio, 0, Audio_MuxingMode, "ADTS");
1444 }
1445 #endif //defined(MEDIAINFO_AAC_YES)
1446 break;
1447 case 10 : // MPEG-4 AAC in ADTS or LATM
1448 case 11 : // MPEG-4 AAC in ADTS or LATM
1449 #if defined(MEDIAINFO_AAC_YES)
1450 Parser=new File_Aac();
1451 #else
1452 {
1453 //Filling
1454 File__Analyze* Parser=new File_Unknown();
1455 Open_Buffer_Init(Parser);
1456 Parser->Stream_Prepare(Stream_Audio);
1457 Parser->Fill(Stream_Audio, 0, Audio_Format, "AAC");
1458 }
1459 #endif //defined(MEDIAINFO_AAC_YES)
1460 break;
1461 case 24 : // AC-4
1462 Parser=new File_Ac4();
1463 ((File_Ac4*)Parser)->Frame_Count_Valid=1;
1464 break;
1465 case 28 : // Dolby E
1466 #if defined(MEDIAINFO_DOLBYE_YES)
1467 Parser=new File_DolbyE();
1468 #else
1469 {
1470 //Filling
1471 File__Analyze* Parser=new File_Unknown();
1472 Open_Buffer_Init(Parser);
1473 Parser->Stream_Prepare(Stream_Audio);
1474 Parser->Fill(Stream_Audio, 0, Audio_Format, "DDE");
1475 }
1476 #endif
1477 break;
1478 case 32+1 : // ADM
1479 #if defined(MEDIAINFO_ADM_YES)
1480 {
1481 if (UncompressedData || Element_Offset<Element_Size)
1482 {
1483 Parser=new File_Adm();
1484 ((File_Adm*)Parser)->MuxingMode=MuxingMode;
1485 }
1486 else
1487 {
1488 //Unsupported features are present
1489 Parser=new File_Unknown();
1490 Open_Buffer_Init(Parser);
1491 Parser->Accept();
1492 Parser->Stream_Prepare(Stream_Audio);
1493 Parser->Fill(Stream_Audio, 0, "Metadata_Format", "ADM");
1494 Parser->Fill(Stream_Audio, 0, "Metadata_MuxingMode", MuxingMode);
1495 Parser->Finish();
1496 }
1497 #else
1498 {
1499 //Filling
1500 Parser=new File_Unknown();
1501 Open_Buffer_Init(Parser);
1502 Parser->Accept();
1503 Parser->Stream_Prepare(Stream_Audio);
1504 Parser->Fill(Stream_Audio, 0, "Metadata_Format", "ADM");
1505 Parser->Finish();
1506 }
1507 #endif
1508 }
1509 break;
1510 default : ;
1511 }
1512
1513 if (Parser)
1514 {
1515 Open_Buffer_Init(Parser);
1516 }
1517 }
1518
1519 #if MEDIAINFO_DEMUX
1520 if (Save_Buffer)
1521 {
1522 std::swap(Buffer, Save_Buffer);
1523 std::swap(Buffer_Offset, Save_Buffer_Offset);
1524 std::swap(Buffer_Size, Save_Buffer_Size);
1525 std::swap(Element_Size, Save_Element_Size);
1526 File_Offset-=Buffer_Offset;
1527 }
1528
1529 if (data_type==28) //If Dolby E, we must demux the SMPTE ST 337 header too (TODO: add an option for forcing SMPTE ST 337 header)
1530 {
1531 int64u Demux_Element_Offset=Element_Offset;
1532 Element_Offset=0;
1533
1534 if (Container_Bits==20)
1535 {
1536 //We must pad to 24 bits
1537 int8u* Info2=new int8u[(size_t)Element_Size*6/5];
1538 size_t Info2_Offset=0;
1539 const int8u* Demux_Buffer=Buffer+Buffer_Offset;
1540 size_t Demux_Buffer_Size=(size_t)Element_Size;
1541 size_t Demux_Buffer_Pos=0;
1542
1543 // Source: 20LE L1L0 L3L2 R0L4 R2R1 R4R3
1544 // Dest : L0XX L2L1 L4L3 R0XX R2R1 R4R3
1545 while (Demux_Buffer_Pos+5<=Demux_Buffer_Size)
1546 {
1547 Info2[Info2_Offset+0]= Demux_Buffer[Demux_Buffer_Pos+0]<<4 ;
1548 Info2[Info2_Offset+1]=(Demux_Buffer[Demux_Buffer_Pos+1]<<4 ) | (Demux_Buffer[Demux_Buffer_Pos+0]>>4 );
1549 Info2[Info2_Offset+2]=(Demux_Buffer[Demux_Buffer_Pos+2]<<4 ) | (Demux_Buffer[Demux_Buffer_Pos+1]>>4 );
1550 Info2[Info2_Offset+3]= Demux_Buffer[Demux_Buffer_Pos+2]&0xF0 ;
1551 Info2[Info2_Offset+4]= Demux_Buffer[Demux_Buffer_Pos+3] ;
1552 Info2[Info2_Offset+5]= Demux_Buffer[Demux_Buffer_Pos+4] ;
1553
1554 Info2_Offset+=6;
1555 Demux_Buffer_Pos+=5;
1556 }
1557
1558 Demux(Info2, Info2_Offset, ContentType_MainStream);
1559
1560 delete[] Info2;
1561 }
1562 else
1563 Demux(Buffer+Buffer_Offset, (size_t)Element_Size, ContentType_MainStream);
1564
1565 Element_Offset=Demux_Element_Offset;
1566 }
1567 else
1568 Demux(Buffer+Buffer_Offset+Container_Bits/2, (size_t)(Element_Size-Container_Bits/2), ContentType_MainStream);
1569
1570 if (Save_Buffer)
1571 {
1572 File_Offset+=Buffer_Offset;
1573 std::swap(Buffer, Save_Buffer);
1574 std::swap(Buffer_Offset, Save_Buffer_Offset);
1575 std::swap(Buffer_Size, Save_Buffer_Size);
1576 std::swap(Element_Size, Save_Element_Size);
1577 }
1578 #endif //MEDIAINFO_DEMUX
1579
1580 // Guard band
1581 GuardBand_After=0;
1582
1583 if (Parser && !Parser->Status[IsFinished])
1584 {
1585 #if defined(MEDIAINFO_DOLBYE_YES)
1586 switch(data_type)
1587 {
1588 case 28 :
1589 ((File_DolbyE*)Parser)->GuardBand_Before=GuardBand_Before;
1590 ((File_DolbyE*)Parser)->GuardBand_Before*=Stream_Bits;
1591 ((File_DolbyE*)Parser)->GuardBand_Before/=Container_Bits;
1592 break;
1593 default : ;
1594 }
1595 #endif
1596
1597 Parser->FrameInfo=FrameInfo;
1598 if (UncompressedData)
1599 {
1600 Open_Buffer_Continue(Parser, UncompressedData, UncompressedData_Size);
1601 delete[] UncompressedData;
1602 }
1603 else
1604 {
1605 int64u Element_Size_Temp=Element_Size-Padding/8;
1606 if (Element_Offset<Element_Size_Temp)
1607 Open_Buffer_Continue(Parser, Buffer+Buffer_Offset+(size_t)Element_Offset, (size_t)(Element_Size_Temp-Element_Offset));
1608 }
1609 Element_Offset=Element_Size;
1610 #if MEDIAINFO_DEMUX
1611 FrameInfo.DUR=Parser->FrameInfo.DUR;
1612 if (FrameInfo.DUR!=(int64u)-1)
1613 {
1614 if (FrameInfo.DTS!=(int64u)-1)
1615 FrameInfo.DTS+=FrameInfo.DUR;
1616 if (FrameInfo.PTS!=(int64u)-1)
1617 FrameInfo.PTS+=FrameInfo.DUR;
1618 }
1619 else
1620 {
1621 FrameInfo.DTS=(int64u)-1;
1622 FrameInfo.PTS=(int64u)-1;
1623 }
1624 #endif // MEDIAINFO_DEMUX
1625
1626 #if defined(MEDIAINFO_DOLBYE_YES)
1627 switch (data_type)
1628 {
1629 case 28 :
1630 GuardBand_After=((File_DolbyE*)Parser)->GuardBand_After;
1631 GuardBand_After*=Container_Bits;
1632 GuardBand_After/=Stream_Bits;
1633 break;
1634 default : ;
1635 }
1636 #endif
1637 }
1638 else
1639 {
1640 Skip_XX(Element_Size-Element_Offset, "Data");
1641 }
1642
1643 if (Save_Buffer)
1644 {
1645 delete[] Buffer;
1646 Buffer=Save_Buffer;
1647 Buffer_Offset=Save_Buffer_Offset;
1648 Buffer_Size=Save_Buffer_Size;
1649 File_Offset-=Buffer_Offset;
1650 Element_Size=Save_Element_Size;
1651 }
1652
1653 FILLING_BEGIN();
1654 if (Frame_Count) // Ignore first GuardBand_Before
1655 FrameSizes[(IsSub && !GuardBand_Before && !GuardBand_After)?Buffer_Size:(GuardBand_Before+Element_Size+GuardBand_After)]++;
1656
1657 Frame_Count++;
1658 if (Frame_Count_NotParsedIncluded!=(int64u)-1)
1659 Frame_Count_NotParsedIncluded++;
1660
1661 if (Parser==NULL || (Frame_Count>=2 && Parser->Status[IsFilled]))
1662 {
1663 Fill("SMPTE ST 337");
1664 if (!IsSub && Config->ParseSpeed<1.0)
1665 {
1666 Open_Buffer_Unsynch();
1667 Finish();
1668 }
1669 }
1670 if (Parser==NULL || (Frame_Count>=2 && Parser->Status[IsFinished]))
1671 Finish("SMPTE ST 337");
1672 FILLING_END();
1673
1674 // Guard band
1675 GuardBand_Before=0;
1676 }
1677
1678 //***************************************************************************
1679 // C++
1680 //***************************************************************************
1681
1682 } // NameSpace
1683
1684 #endif // MEDIAINFO_SMPTEST0337_YES
1685