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_DTS_YES)
21 //---------------------------------------------------------------------------
22
23 //---------------------------------------------------------------------------
24 #include "MediaInfo/Audio/File_Dts.h"
25 #include "ZenLib/Utils.h"
26 #include "ZenLib/BitStream.h"
27 #include "MediaInfo/MediaInfo_Config_MediaInfo.h"
28 #if MEDIAINFO_EVENTS
29 #include "MediaInfo/MediaInfo_Events.h"
30 #endif //MEDIAINFO_EVENTS
31 #include <algorithm>
32 using namespace ZenLib;
33 using namespace std;
34 //---------------------------------------------------------------------------
35
36 namespace MediaInfoLib
37 {
38
39 //***************************************************************************
40 // Infos
41 //***************************************************************************
42
43 //---------------------------------------------------------------------------
44 static const char* DTS_FrameType[]=
45 {
46 "Termination",
47 "Normal",
48 };
49
50 //---------------------------------------------------------------------------
51 static const int32u DTS_SamplingRate[]=
52 {
53 0, 8000, 16000, 32000, 0, 0, 11025, 22050,
54 44100, 0, 0, 12000, 24000, 48000, 96000, 192000,
55 };
56
57 //---------------------------------------------------------------------------
58 static const int32u DTS_BitRate[]=
59 {
60 32000, 56000, 64000, 96000, 112000, 128000, 192000, 224000,
61 256000, 320000, 384000, 448000, 512000, 576000, 640000, 754500,
62 960000, 1024000, 1152000, 1280000, 1344000, 1408000, 1411200, 1472000,
63 1509750, 1920000, 2048000, 3072000, 3840000, 0, 0, 0,
64 };
65
66 //---------------------------------------------------------------------------
67 static const int8u DTS_Channels[]=
68 {
69 1, 2, 2, 2, 2, 3, 3, 4,
70 4, 5, 6, 6, 6, 7, 8, 8,
71 };
72
73 //---------------------------------------------------------------------------
74 static const int8u DTS_Resolution[]=
75 {16, 20, 24, 24};
76
77 //---------------------------------------------------------------------------
78 const char* DTS_ChannelPositions[16]=
79 {
80 "Front: C",
81 "Front: C C",
82 "Front: L R",
83 "Front: L R",
84 "Front: L R",
85 "Front: L C R",
86 "Front: L R, Back: C",
87 "Front: L C R, Back: C",
88 "Front: L R, Side: L R",
89 "Front: L C R, Side: L R",
90 "Front: L C C R, Side: L R",
91 "Front: L C R, Side: L R",
92 "Front: L R, Side: L R, Back: L R",
93 "Front: L C R, Side: L R, Back: L R",
94 "Front: L R, Side: L R, Back: L C C R",
95 "Front: L C R, Side: L R, Back: L C R",
96 };
97
98 //---------------------------------------------------------------------------
99 const char* DTS_ChannelPositions2[16]=
100 {
101 "1/0/0",
102 "2/0/0",
103 "2/0/0",
104 "2/0/0",
105 "2/0/0",
106 "3/0/0",
107 "2/1/0",
108 "3/1/0",
109 "2/2/0",
110 "3/2/0",
111 "4/2/0",
112 "3/2/0",
113 "2/2/2",
114 "3/2/2",
115 "2/2/4",
116 "3/2/3",
117 };
118
119 //---------------------------------------------------------------------------
120 static const char* DTS_ChannelLayout[16]=
121 {
122 "C",
123 "M M",
124 "L R",
125 "L R",
126 "Lt Rt",
127 "C L R",
128 "L R Cs",
129 "C L R Cs",
130 "L R Ls Rs",
131 "C L R Ls Rs",
132 "Cl Cr L R Ls Rs",
133 "C L R Ls Rs",
134 "C L R Ls Rs Rls Rrs",
135 "C L R Ls Rs Rls Rrs",
136 "L R Ls Rs Rls Cs Cs Rrs",
137 "C L R Ls Rs Rls Cs Rrs",
138 };
139
140 //---------------------------------------------------------------------------
141 static const char* DTS_ExtensionAudioDescriptor[]=
142 {
143 "Channel Extension",
144 "Reserved",
145 "Frequency Extension",
146 "Channel Extension + Frequency Extension",
147 "",
148 "",
149 "",
150 "",
151 };
152
153 //---------------------------------------------------------------------------
154 static const char* DTS_HD_RefClockCode[]=
155 {
156 "1/32000",
157 "1/44100",
158 "1/48000",
159 "",
160 };
161
162 //---------------------------------------------------------------------------
DTS_HD_SpeakerActivityMask(int16u SpeakerActivityMask,bool AddCs=false,bool AddLrsRrs=false)163 std::string DTS_HD_SpeakerActivityMask (int16u SpeakerActivityMask, bool AddCs=false, bool AddLrsRrs=false)
164 {
165 std::string Text;
166 if ((SpeakerActivityMask&0x0003)==0x0003)
167 Text+="Front: L C R";
168 else
169 {
170 if (SpeakerActivityMask&0x0001)
171 Text+="Front: C";
172 if (SpeakerActivityMask&0x0002)
173 Text+="Front: L R";
174 }
175
176 if (SpeakerActivityMask&0x0004)
177 Text+=", Side: L R";
178
179 if (SpeakerActivityMask&0x0010 || AddCs)
180 Text+=", Back: C";
181
182 if ((SpeakerActivityMask&0x00A0)==0x00A0)
183 Text+=", High: L C R";
184 else
185 {
186 if (SpeakerActivityMask&0x0020 || AddLrsRrs)
187 Text+=", High: L R";
188 if (SpeakerActivityMask&0x0080)
189 Text+=", High: C";
190 }
191
192 if (SpeakerActivityMask&0x0800)
193 Text+=", Side: L R";
194
195 if (SpeakerActivityMask&0x0040)
196 Text+=", Back: L R";
197
198 if (SpeakerActivityMask&0x0100)
199 Text+=", TopCtrSrrd";
200 if (SpeakerActivityMask&0x0200)
201 Text+=", Ctr: L R";
202 if (SpeakerActivityMask&0x0400)
203 Text+=", Wide: L R";
204 if (SpeakerActivityMask&0x2000)
205 Text+=", HiSide: L R";
206
207 if ((SpeakerActivityMask&0xC000)==0x0C000)
208 Text+=", HiRear: L C R";
209 else
210 {
211 if (SpeakerActivityMask&0x4000)
212 Text+=", HiRear: C";
213 if (SpeakerActivityMask&0x8000)
214 Text+=", HiRear: L R";
215 }
216
217 if (SpeakerActivityMask&0x0008)
218 Text+=", LFE";
219 if (SpeakerActivityMask&0x1000)
220 Text+=", LFE2";
221
222 return Text;
223 }
224
225 //---------------------------------------------------------------------------
DTS_HD_SpeakerActivityMask2(int16u SpeakerActivityMask,bool AddCs=false,bool AddLrsRrs=false)226 std::string DTS_HD_SpeakerActivityMask2 (int16u SpeakerActivityMask, bool AddCs=false, bool AddLrsRrs=false)
227 {
228 std::string Text;
229 if ((SpeakerActivityMask&0x0003)==0x0003)
230 Text+="3";
231 else
232 {
233 if (SpeakerActivityMask&0x0001)
234 Text+="1";
235 else if (SpeakerActivityMask&0x0002)
236 Text+="2";
237 else
238 Text+="0";
239 }
240
241 if (SpeakerActivityMask&0x0004)
242 Text+="/2";
243 else if ((SpeakerActivityMask&0x0840)==0x0000)
244 Text+="/0";
245
246 if (SpeakerActivityMask&0x0010 || AddCs)
247 Text+="/1";
248 else if ((SpeakerActivityMask&0x0840)==0x0000)
249 Text+="/0";
250
251 if ((SpeakerActivityMask&0x00A0)==0x00A0)
252 Text+=".3";
253 else
254 {
255 if (SpeakerActivityMask&0x0020 || AddLrsRrs)
256 Text+=".2";
257 if (SpeakerActivityMask&0x0080)
258 Text+=".2";
259 }
260
261 if (SpeakerActivityMask&0x0800)
262 Text+="/2";
263 if (SpeakerActivityMask&0x0040)
264 Text+="/2";
265
266 if (SpeakerActivityMask&0x0100)
267 Text+=".1";
268 if (SpeakerActivityMask&0x0200)
269 Text+=".2";
270 if (SpeakerActivityMask&0x0400)
271 Text+=".2";
272 if (SpeakerActivityMask&0x2000)
273 Text+=".2";
274
275 if ((SpeakerActivityMask&0xC000)==0x0C000)
276 Text+=".3";
277 else
278 {
279 if (SpeakerActivityMask&0x4000)
280 Text+=".1";
281 if (SpeakerActivityMask&0x8000)
282 Text+=".2";
283 }
284
285 if (SpeakerActivityMask&0x0008)
286 Text+=".1";
287 if (SpeakerActivityMask&0x1000)
288 Text+=".1";
289
290 return Text;
291 }
292
293 //---------------------------------------------------------------------------
DTS_HD_SpeakerActivityMask_ChannelLayout(int16u SpeakerActivityMask,bool AddCs=false,bool AddLrsRrs=false)294 std::string DTS_HD_SpeakerActivityMask_ChannelLayout (int16u SpeakerActivityMask, bool AddCs=false, bool AddLrsRrs=false)
295 {
296 std::string Text;
297 if (SpeakerActivityMask&0x0001)
298 Text+=" C";
299 if (SpeakerActivityMask&0x0002)
300 Text+=" L R";
301 if (SpeakerActivityMask&0x0004)
302 Text+=" Ls Rs";
303 if (SpeakerActivityMask&0x0008)
304 Text+=" LFE";
305 if (SpeakerActivityMask&0x0010 || AddCs)
306 Text+=" Cs";
307 if (SpeakerActivityMask&0x0020)
308 Text+=" Lh Rh";
309 if (SpeakerActivityMask&0x0040 || AddLrsRrs)
310 Text+=" Lsr Rsr";
311 if (SpeakerActivityMask&0x0080)
312 Text+=" Ch";
313 if (SpeakerActivityMask&0x0100)
314 Text+=" Oh";
315 if (SpeakerActivityMask&0x0200)
316 Text+=" Lc Rc";
317 if (SpeakerActivityMask&0x0400)
318 Text+=" Lw Rw";
319 if (SpeakerActivityMask&0x0800)
320 Text+=" Lss Rss";
321 if (SpeakerActivityMask&0x1000)
322 Text+=" LFE2";
323 if (SpeakerActivityMask&0x2000)
324 Text+=" Lhs Rhs";
325 if (SpeakerActivityMask&0x4000)
326 Text+=" Chr";
327 if (SpeakerActivityMask&0x8000)
328 Text+=" Lhr";
329
330 if (!Text.empty())
331 Text.erase(0, 1);
332 return Text;
333 }
334
335 //---------------------------------------------------------------------------
336 static const char* DTS_HD_TypeDescriptor[]=
337 {
338 "Music",
339 "Effects",
340 "Dialog",
341 "Commentary",
342 "Visually Impaired",
343 "Hearing Impaired",
344 "Isolated Music Object",
345 "Music and Effects",
346 "Dialog and Commentary",
347 "Effects and Commentary",
348 "Isolated Music Object and Commentary",
349 "Isolated Music Object and Effects",
350 "Karaoke",
351 "Music, Effects, Dialog",
352 "Complete Audio Presentation",
353 "",
354 };
355
356 //---------------------------------------------------------------------------
357 static int32u DTS_HD_MaximumSampleRate[]=
358 {
359 8000,
360 16000,
361 32000,
362 64000,
363 128000,
364 22050,
365 44100,
366 88200,
367 176400,
368 352800,
369 12000,
370 24000,
371 48000,
372 96000,
373 192000,
374 384000,
375 };
376
377 //***************************************************************************
378 // Constructor/Destructor
379 //***************************************************************************
380
381 //---------------------------------------------------------------------------
File_Dts()382 File_Dts::File_Dts()
383 :File__Analyze()
384 {
385 //Configuration
386 ParserName="Dts";
387 #if MEDIAINFO_EVENTS
388 ParserIDs[0]=MediaInfo_Parser_Dts;
389 StreamIDs_Width[0]=0;
390 #endif //MEDIAINFO_EVENTS
391 #if MEDIAINFO_TRACE
392 Trace_Layers_Update(8); //Stream
393 #endif //MEDIAINFO_TRACE
394 MustSynchronize=true;
395 Buffer_TotalBytes_FirstSynched_Max=32*1024;
396 PTS_DTS_Needed=true;
397 StreamSource=IsStream;
398
399 //In
400 Frame_Count_Valid=0;
401
402 //Buffer
403 Save_Buffer=NULL;
404
405 //Temp
406 HD_size=0;
407 Primary_Frame_Byte_Size=0;
408 HD_SpeakerActivityMask=(int16u)-1;
409 channel_arrangement=(int8u)-1;
410 channel_arrangement_XCh=(int8u)-1;
411 sample_frequency=(int8u)-1;
412 sample_frequency_X96k=(int8u)-1;
413 bit_rate=(int8u)-1;
414 lfe_effects=(int8u)-1;
415 bits_per_sample=(int8u)-1;
416 ExtensionAudioDescriptor=(int8u)-1;
417 HD_BitResolution=(int8u)-1;
418 HD_MaximumSampleRate=(int8u)-1;
419 HD_TotalNumberChannels=(int8u)-1;
420 HD_ExSSFrameDurationCode=(int8u)-1;
421 ExtendedCoding=false;
422 ES=false;
423 Core_Exists=false;
424 }
425
426 //***************************************************************************
427 // Streams management
428 //***************************************************************************
429
430 //---------------------------------------------------------------------------
Streams_Fill_Extension()431 void File_Dts::Streams_Fill_Extension()
432 {
433 bool AddCs=false;
434 //bool AddLrsRrs=false;
435 //bool AddX=false;
436
437 if (HD_TotalNumberChannels!=(int8u)-1)
438 {
439 int8u i=HD_TotalNumberChannels;
440 int8u Core_Core_Channels=DTS_Channels[Core_Core_AMODE];
441 if (Presence[presence_Core_Core] && Core_Core_LFF)
442 Core_Core_Channels++;
443
444 if (Presence[presence_Core_XXCh] && i<Core_Core_Channels+Core_XXCh_nuNumChSetsInXXCh)
445 {
446 //switch (Core_XXCh_nuNumChSetsInXXCh)
447 //{
448 // case 1: AddCs=true; break;
449 // case 2: AddLrsRrs=true; break;
450 // default: AddX=true;
451 //}
452
453 //i=Core_Core_Channels+Core_XXCh_nuNumChSetsInXXCh;
454 }
455 if (Presence[presence_Core_XCh] && i<Core_Core_Channels+Core_XCh_AMODE)
456 {
457 //AddCs=true;
458
459 //i=Core_Core_Channels+Core_XCh_AMODE;
460 }
461 if (!Presence[presence_Core_XCh] && ES && i<Core_Core_Channels+1)
462 {
463 AddCs=true;
464
465 i=Core_Core_Channels+1; // Must count the Matrixed additional channels
466 }
467
468 Data[Channels].push_back(Ztring::ToZtring(i));
469 }
470 else
471 {
472 Data[Channels].push_back(Ztring());
473 }
474 if (HD_SpeakerActivityMask!=(int16u)-1) // && !AddX)
475 {
476 Data[ChannelPositions].push_back(DTS_HD_SpeakerActivityMask(HD_SpeakerActivityMask, AddCs).c_str()); //AddLrsRrs
477 Data[ChannelPositions2].push_back(DTS_HD_SpeakerActivityMask2(HD_SpeakerActivityMask, AddCs).c_str()); //AddLrsRrs
478 Data[ChannelLayout].push_back(DTS_HD_SpeakerActivityMask_ChannelLayout(HD_SpeakerActivityMask, AddCs).c_str()); //AddLrsRrs
479 }
480 else
481 {
482 Data[ChannelPositions].push_back(Ztring());
483 Data[ChannelPositions2].push_back(Ztring());
484 Data[ChannelLayout].push_back(Ztring());
485 }
486 if (HD_BitResolution!=(int8u)-1)
487 {
488 Data[BitDepth].push_back(Ztring::ToZtring(HD_BitResolution));
489 }
490 else
491 {
492 Data[BitDepth].push_back(Ztring());
493 }
494 if (HD_MaximumSampleRate!=(int8u)-1)
495 {
496 Data[SamplingRate].push_back(Ztring::ToZtring(DTS_HD_MaximumSampleRate[HD_MaximumSampleRate]));
497 }
498 else
499 {
500 Data[SamplingRate].push_back(Ztring());
501 }
502 Data[BitRate].push_back(Ztring::ToZtring(BitRate_Get(true), 0));
503 Data[BitRate_Mode].push_back(__T("CBR"));
504 Data[Compression_Mode].push_back(__T("Lossy"));
505 }
506
507 //---------------------------------------------------------------------------
Streams_Fill_Core_ES()508 void File_Dts::Streams_Fill_Core_ES()
509 {
510 Streams_Fill_Core();
511
512 if (!ES && !Presence[presence_Core_XCh])
513 return;
514
515 int8u Channels_Before=Data[Channels][Data[Channels].size()-1].To_int8u();
516 Data[Channels].pop_back();
517 Data[ChannelPositions].pop_back();
518 Data[ChannelPositions2].pop_back();
519 Data[ChannelLayout].pop_back();
520
521 Data[Channels].push_back(Ztring::ToZtring(Channels_Before+(Presence[presence_Core_XCh]?Core_XCh_AMODE:1)));
522 if (Core_Core_AMODE == 9 && (!Presence[presence_Core_XCh] || Core_XCh_AMODE == 1))
523 {
524 Data[ChannelPositions].push_back(Ztring(__T("Front: L C R, Side: L R, Back: C"))+(Core_Core_LFF?__T(", LFE"):__T("")));
525 Data[ChannelPositions2].push_back(Ztring(__T("3/2/1"))+(Core_Core_LFF?__T(".1"):__T("")));
526 Data[ChannelLayout].push_back(Ztring(__T("C L R Ls Rs Cs"))+(Core_Core_LFF?__T(" LFE"):__T("")));
527 }
528 else if (Core_Core_AMODE == 9 && (Presence[presence_Core_XCh] && Core_XCh_AMODE == 2))
529 {
530 Data[ChannelPositions].push_back(Ztring(__T("Front: L C R, Side: L R, Back: L R"))+(Core_Core_LFF?__T(", LFE"):__T("")));
531 Data[ChannelPositions2].push_back(Ztring(__T("3/2/2"))+(Core_Core_LFF?__T(".1"):__T("")));
532 Data[ChannelLayout].push_back(Ztring(__T("C L R Ls Rs Lrs Rrs"))+(Core_Core_LFF?__T(" LFE"):__T("")));
533 }
534 else
535 {
536 Ztring Debug=__T("Debug, Core_Core_AMODE=")+Ztring::ToZtring(Core_Core_AMODE);
537 if(Presence[presence_Core_XCh])
538 Debug +=__T(", Core_XCh_AMODE=")+Ztring::ToZtring(Core_XCh_AMODE);
539 Debug +=__T(", Core_Core_LFF=")+Ztring::ToZtring(Core_Core_LFF);
540 Data[ChannelPositions].push_back(Debug);
541 Data[ChannelPositions2].push_back(Debug);
542 Data[ChannelLayout].push_back(Debug);
543 }
544 }
545
546 //---------------------------------------------------------------------------
Streams_Fill_Core()547 void File_Dts::Streams_Fill_Core()
548 {
549 Ztring Core_BitRate;
550 if (bit_rate<25)
551 Core_BitRate=Ztring::ToZtring(BitRate_Get(), 0);
552 else if (bit_rate==29)
553 Core_BitRate=__T("Open");
554 else
555 Core_BitRate=__T("Unknown");
556
557 if (Core_Core_AMODE<16)
558 {
559 Data[Channels].push_back(Ztring::ToZtring(DTS_Channels[Core_Core_AMODE]+(Core_Core_LFF?1:0)));
560 Data[ChannelPositions].push_back(Ztring().From_UTF8(DTS_ChannelPositions[Core_Core_AMODE])+(Core_Core_LFF?__T(", LFE"):__T("")));
561 Data[ChannelPositions2].push_back(Ztring().From_UTF8(DTS_ChannelPositions2[Core_Core_AMODE])+(Core_Core_LFF?__T(".1"):__T(".0")));
562 Data[ChannelLayout].push_back(Ztring().From_UTF8(DTS_ChannelLayout[Core_Core_AMODE])+(Core_Core_LFF?__T(" LFE"):__T("")));
563 }
564 else
565 {
566 Data[Channels].push_back(__T("User Defined"));
567 Data[ChannelPositions].push_back(Ztring(__T("User Defined"))+(Core_Core_LFF?__T(", LFE"):__T("")));
568 Data[ChannelPositions2].push_back(Ztring(__T("User Defined"))+(Core_Core_LFF?__T(".1"):__T(".0")));
569 Data[ChannelLayout].push_back(Ztring(__T("User Defined"))+(Core_Core_LFF?__T(" LFE"):__T("")));
570 }
571 Data[BitDepth].push_back(Ztring::ToZtring(DTS_Resolution[bits_per_sample]));
572 Data[SamplingRate].push_back(Ztring::ToZtring(DTS_SamplingRate[sample_frequency]));
573 Data[BitRate].push_back(Core_BitRate);
574 Data[BitRate_Mode].push_back(__T("CBR"));
575 Data[Compression_Mode].push_back(__T("Lossy"));
576 }
577
578 //---------------------------------------------------------------------------
Streams_Fill()579 void File_Dts::Streams_Fill()
580 {
581 Fill(Stream_General, 0, General_Format, "DTS");
582
583 Stream_Prepare(Stream_Audio);
584 Fill(Stream_Audio, 0, Audio_Format, "DTS");
585
586 // DTS:X
587 if (Presence[presence_Extended_XLL] && Extension_XLL_X_Yes && !Extension_XLL_X_No)
588 Presence.set(presence_Extended_XLL_X);
589 if (Presence[presence_Extended_XLL_X])
590 {
591 Data[Profiles].push_back(__T("X"));
592
593 Data[Channels].push_back(__T("Object Based"));
594 Data[ChannelPositions].push_back(__T("Object Based"));
595 Data[ChannelPositions2].push_back(__T("Object Based"));
596 Data[ChannelLayout].push_back(__T("Object Based"));
597 Data[BitDepth].push_back(Ztring());
598 Data[SamplingRate].push_back(Ztring());
599 Data[BitRate].push_back(__T("Unknown"));
600 Data[BitRate_Mode].push_back(__T("VBR"));
601 Data[Compression_Mode].push_back(Ztring());
602 }
603
604 // DTS-HD MA
605 if (Presence[presence_Extended_XLL])
606 {
607 Data[Profiles].push_back(__T("MA"));
608
609 Streams_Fill_Extension();
610 Data[BitRate].pop_back();
611 Data[BitRate_Mode].pop_back();
612 Data[Compression_Mode].pop_back();
613
614 Data[BitRate].push_back(__T("Unknown"));
615 Data[BitRate_Mode].push_back(__T("VBR"));
616 Data[Compression_Mode].push_back(__T("Lossless"));
617 }
618
619 // DTS Express
620 if (Presence[presence_Extended_LBR])
621 {
622 Data[Profiles].push_back(__T("Express"));
623
624 Streams_Fill_Extension();
625 }
626
627 // DTS-HD HRA
628 if (Presence[presence_Extended_XBR]
629 || Presence[presence_Extended_X96]
630 || Presence[presence_Extended_XXCh]
631 || Presence[presence_Core_XXCh])
632 {
633 Data[Profiles].push_back(__T("HRA"));
634
635 if (Presence[presence_Extended_XBR]
636 || Presence[presence_Extended_X96]
637 || Presence[presence_Extended_XXCh])
638 Streams_Fill_Extension();
639 else
640 {
641 Streams_Fill_Core_ES();
642
643 if (Presence[presence_Extended_X96])
644 {
645 Data[SamplingRate].pop_back();
646
647 Data[SamplingRate].push_back(Ztring::ToZtring(96000));
648 }
649 }
650 }
651
652 // DTS-HD 96/24
653 else
654 if (Presence[presence_Core_X96])
655 {
656 Data[Profiles].push_back(__T("96/24"));
657
658 if (Presence[presence_Extended_X96])
659 Streams_Fill_Extension();
660 else
661 {
662 Streams_Fill_Core_ES();
663 Data[SamplingRate].pop_back();
664
665 Data[SamplingRate].push_back(Ztring::ToZtring(96000));
666 }
667 }
668
669 // DTS-ES
670 if (ES || Presence[presence_Core_XCh])
671 {
672 if (!ES)
673 Data[Profiles].push_back(__T("ES Discrete without ES Matrix"));
674 else if (Presence[presence_Core_XCh])
675 Data[Profiles].push_back(__T("ES Discrete"));
676 else
677 Data[Profiles].push_back(__T("ES Matrix"));
678 Streams_Fill_Core_ES();
679 }
680
681 // Core
682 if (Presence[presence_Core_Core])
683 {
684 Data[Profiles].push_back(__T("Core"));
685 Streams_Fill_Core();
686 }
687
688 // Cleanup up
689 for (size_t Pos=0; Pos<10; ++Pos)
690 {
691 Data[Pos].Separator_Set(0, __T(" / "));
692 if (Data[Pos].size()>1)
693 {
694 bool IsNotSame=false;
695 for (size_t i=1; i<Data[Pos].size(); ++i)
696 if (Data[Pos][i]!=Data[Pos][0])
697 IsNotSame=true;
698 if (!IsNotSame)
699 Data[Pos].resize(1);
700 }
701 }
702 if (Data[Profiles].size()==1 && Data[Profiles][0]==__T("Core"))
703 Data[Profiles].clear(); //Core is the default one
704
705 // Filling
706 bool LegacyStreamDisplay=MediaInfoLib::Config.LegacyStreamDisplay_Get();
707 Fill(Stream_Audio, 0, Audio_Format_Profile, Data[Profiles].Read());
708 Fill(Stream_Audio, 0, Audio_Codec, (Data[Profiles].Find(__T("MA"))!=string::npos || Data[Profiles].Find(__T("HRA"))!=string::npos)?"DTS-HD":"DTS");
709 Fill(Stream_General, 0, General_Format_Profile, Retrieve(Stream_Audio, 0, Audio_Format_Profile));
710 Fill(Stream_Audio, 0, Audio_Channel_s_, LegacyStreamDisplay?Data[Channels].Read():Data[Channels].Read(0));
711 Fill(Stream_Audio, 0, Audio_ChannelPositions, LegacyStreamDisplay?Data[ChannelPositions].Read():Data[ChannelPositions].Read(0));
712 Fill(Stream_Audio, 0, Audio_ChannelPositions_String2, LegacyStreamDisplay?Data[ChannelPositions2].Read():Data[ChannelPositions2].Read(0));
713 Fill(Stream_Audio, 0, Audio_ChannelLayout, LegacyStreamDisplay?Data[ChannelLayout].Read():Data[ChannelLayout].Read(0));
714 Fill(Stream_Audio, 0, Audio_BitDepth, LegacyStreamDisplay?Data[BitDepth].Read():Data[BitDepth].Read(0));
715 Fill(Stream_Audio, 0, Audio_SamplingRate, LegacyStreamDisplay?Data[SamplingRate].Read():Data[SamplingRate].Read(0));
716 Fill(Stream_Audio, 0, Audio_BitRate, LegacyStreamDisplay?Data[BitRate].Read():(Data[BitRate].Read(0)==__T("Unknown")?Ztring():Data[BitRate].Read(0)));
717 Fill(Stream_Audio, 0, Audio_BitRate_Mode, LegacyStreamDisplay?Data[BitRate_Mode].Read():Data[BitRate_Mode].Read(0));
718 Fill(Stream_General, 0, General_OverallBitRate_Mode, Retrieve(Stream_Audio, 0, Audio_BitRate_Mode));
719 Fill(Stream_Audio, 0, Audio_Compression_Mode, LegacyStreamDisplay?Data[Compression_Mode].Read():Data[Compression_Mode].Read(0), true);
720
721 // Cleanup up
722 for (size_t Pos=0; Pos<10; ++Pos)
723 Data[Pos].clear();
724
725 //Samples per frame (to be done after SamplingRate filling because it is used during Fill())
726 if (Presence[presence_Core_Core])
727 Fill(Stream_Audio, 0, Audio_SamplesPerFrame, Number_Of_PCM_Sample_Blocks*32); // Samples per Core frames. TODO: samples per HD frames (interesting?)
728 }
729
730 //---------------------------------------------------------------------------
Streams_Finish()731 void File_Dts::Streams_Finish()
732 {
733 Fill(Stream_Audio, 0, Audio_Format_Settings_Endianness, BigEndian?"Big":"Little", Unlimited, true, true);
734 Fill(Stream_Audio, 0, Audio_Format_Settings_Mode, Word?"16":"14", Unlimited, true, true);
735
736 if (FrameInfo.PTS!=(int64u)-1 && FrameInfo.PTS>PTS_Begin)
737 {
738 Fill(Stream_Audio, 0, Audio_Duration, ((float64)(FrameInfo.PTS-PTS_Begin))/1000000, 0, true);
739 float64 SamplesPerFrame=Retrieve(Stream_Audio, 0, Audio_SamplesPerFrame).To_float64();
740 float64 SamplingRate=Retrieve(Stream_Audio, 0, Audio_SamplingRate).To_float64();
741 if (SamplesPerFrame && SamplingRate)
742 Fill(Stream_Audio, 0, Audio_FrameCount, ((float64)(FrameInfo.PTS-PTS_Begin))/1000000000/(SamplesPerFrame/SamplingRate), 0, true);
743 }
744 }
745
746 //***************************************************************************
747 // Buffer - File header
748 //***************************************************************************
749
750 //---------------------------------------------------------------------------
FileHeader_Begin()751 bool File_Dts::FileHeader_Begin()
752 {
753 //Must have enough buffer for having header
754 if (Buffer_Size<4)
755 return false; //Must wait for more data
756
757 //False positives detection: Detect WAV files, the parser can't detect it easily, there is only 70 bytes of beginning for saying WAV
758 switch (CC4(Buffer))
759 {
760 case 0x52494646 : //"RIFF"
761 case 0x000001FD : //MPEG-PS private
762 Finish("DTS");
763 return false;
764 default : ;
765 }
766
767 //All should be OK...
768 if (!Frame_Count_Valid)
769 Frame_Count_Valid=Config->ParseSpeed>=0.3?32:2;
770 return true;
771 }
772
773 //***************************************************************************
774 // Buffer - Synchro
775 //***************************************************************************
776
777 //---------------------------------------------------------------------------
Synchronize()778 bool File_Dts::Synchronize()
779 {
780 //Synchronizing
781 while (Buffer_Offset+6<=Buffer_Size)
782 {
783 if (!FrameSynchPoint_Test())
784 return false; //Need more data
785 if (Synched)
786 break;
787 Buffer_Offset++;
788 }
789
790 //Parsing last bytes if needed
791 if (Buffer_Offset+6>Buffer_Size)
792 {
793 if (Buffer_Offset+5==Buffer_Size)
794 {
795 int64u Value=CC5(Buffer+Buffer_Offset);
796 if ((Value&0xFFFFFFFFFCLL)!=0x7FFE8001FCLL //16 bits and big endian Core
797 && (Value&0xFFFFFFFF00LL)!=0xFE7F018000LL //16 bits and little endian Core
798 && (Value&0xFFFFFFFFF7LL)!=0x1FFFE80007LL //14 bits and big endian Core
799 && (Value&0xFFFFFFFFF0LL)!=0xFF1F00E8F0LL //14 bits and little endian Core
800 && (Value&0xFFFFFFFF00LL)!=0x6458202500LL) //16 bits and big endian HD
801 Buffer_Offset++;
802 }
803 if (Buffer_Offset+4==Buffer_Size)
804 {
805 int32u Value=CC4(Buffer+Buffer_Offset);
806 if (Value!=0x7FFE8001 //16 bits and big endian Core
807 && Value!=0xFE7F0180 //16 bits and little endian Core
808 && Value!=0x1FFFE800 //14 bits and big endian Core
809 && Value!=0xFF1F00E8 //14 bits and little endian Core
810 && Value!=0x64582025) //16 bits and big endian HD
811 Buffer_Offset++;
812 }
813 if (Buffer_Offset+3==Buffer_Size)
814 {
815 int32u Value=CC3(Buffer+Buffer_Offset);
816 if (Value!=0x7FFE80 //16 bits and big endian Core
817 && Value!=0xFE7F01 //16 bits and little endian Core
818 && Value!=0x1FFFE8 //14 bits and big endian Core
819 && Value!=0xFF1F00 //14 bits and little endian Core
820 && Value!=0x645820) //16 bits and big endian HD
821 Buffer_Offset++;
822 }
823 if (Buffer_Offset+2==Buffer_Size)
824 {
825 int16u Value=CC2(Buffer+Buffer_Offset);
826 if (Value!=0x7FFE //16 bits and big endian Core
827 && Value!=0xFE7F //16 bits and little endian Core
828 && Value!=0x1FFF //14 bits and big endian Core
829 && Value!=0xFF1F //14 bits and little endian Core
830 && Value!=0x6458) //16 bits and big endian HD
831 Buffer_Offset++;
832 }
833 if (Buffer_Offset+1==Buffer_Size)
834 {
835 int8u Value=CC1(Buffer+Buffer_Offset);
836 if (Value!=0x7F //16 bits and big endian Core
837 && Value!=0xFE //16 bits and little endian Core
838 && Value!=0x1F //14 bits and big endian Core
839 && Value!=0xFF //14 bits and little endian Core
840 && Value!=0x64) //16 bits and big endian HD
841 Buffer_Offset++;
842 }
843 return false;
844 }
845
846 //Synched
847 return true;
848 }
849
850 //---------------------------------------------------------------------------
Synched_Test()851 bool File_Dts::Synched_Test()
852 {
853 //Padding
854 while (Buffer_Offset<Buffer_Size && Buffer[Buffer_Offset]==0x00)
855 Buffer_Offset++;
856
857 //Must have enough buffer for having header
858 if (Buffer_Offset+6>Buffer_Size)
859 return false;
860
861 //Quick test of synchro
862 if (!FrameSynchPoint_Test())
863 return false; //Need more data
864 if (!Synched)
865 return true;
866
867 //We continue
868 return true;
869 }
870
871 //---------------------------------------------------------------------------
Read_Buffer_Unsynched()872 void File_Dts::Read_Buffer_Unsynched()
873 {
874 FrameInfo=frame_info();
875 }
876
877 //***************************************************************************
878 // Buffer - Demux
879 //***************************************************************************
880
881 //---------------------------------------------------------------------------
882 #if MEDIAINFO_DEMUX
Demux_UnpacketizeContainer_Test()883 bool File_Dts::Demux_UnpacketizeContainer_Test()
884 {
885 int32u Value=CC4(Buffer+Buffer_Offset);
886 if (Value==0x7FFE8001)
887 {
888 int16u Size=((BigEndian2int24u(Buffer+Buffer_Offset+5)>>4)&0x3FFF)+1;
889 Demux_Offset=Buffer_Offset+Size;
890
891 if (Buffer_Offset+Size>Buffer_Size && File_Offset+Buffer_Size!=File_Size)
892 return false; //No complete frame
893
894 Demux_UnpacketizeContainer_Demux();
895 }
896
897 return true;
898 }
899 #endif //MEDIAINFO_DEMUX
900
901 //***************************************************************************
902 // Buffer - Per element
903 //***************************************************************************
904
905 //---------------------------------------------------------------------------
Header_Parse()906 void File_Dts::Header_Parse()
907 {
908 Header_Fill_Size(Original_Size);
909 }
910
911 //***************************************************************************
912 // Elements
913 //***************************************************************************
914
915 //---------------------------------------------------------------------------
Data_Parse()916 void File_Dts::Data_Parse()
917 {
918 if (Save_Buffer)
919 {
920 File_Offset+=Buffer_Offset;
921 swap(Buffer, Save_Buffer);
922 swap(Buffer_Offset, Save_Buffer_Offset);
923 swap(Buffer_Size, Save_Buffer_Size);
924 if (!Word)
925 Element_Size=Element_Size*14/16;
926 }
927
928 //Parsing
929 int32u Sync;
930 Get_B4 (Sync, "Sync");
931 if (Sync==0x64582025)
932 {
933 //HD
934 Element_Name("HD");
935 Element_Code=1;
936
937 int16u header_size;
938 int8u SubStreamIndex, NumAssets, NumAudioPresent;
939 bool isBlownUpHeader, StaticFieldsPresent;
940 Skip_B1( "Unknown");
941 BS_Begin();
942 Get_S1 (2, SubStreamIndex, "Substream index");
943 Get_SB (isBlownUpHeader, "Is blown up header");
944 if (isBlownUpHeader)
945 {
946 Get_S2 (12, header_size, "Header size"); header_size++; Param_Info2(header_size, " bytes");
947 Get_S3 (20, HD_size, "HD block size"); HD_size++; Param_Info2(HD_size, " bytes");
948 }
949 else
950 {
951 Get_S2 ( 8, header_size, "Header size"); header_size++; Param_Info2(header_size, " bytes");
952 Get_S3 (16, HD_size, "HD block size"); HD_size++; Param_Info2(HD_size, " bytes");
953 }
954 TESTELSE_SB_GET(StaticFieldsPresent, "Static fields present");
955 std::vector<int32u> ActiveExSSMasks;
956 Info_S1(2, RefClockCode, "Reference clock code"); Param_Info1(DTS_HD_RefClockCode[RefClockCode]);
957 Get_S1 (3, HD_ExSSFrameDurationCode, "ExSS frame duration code"); HD_ExSSFrameDurationCode++; Param_Info1(HD_ExSSFrameDurationCode);
958 TEST_SB_SKIP( "Timestamp flag");
959 Skip_S5(36, "Timestamp");
960 TEST_SB_END();
961 Get_S1 (3, NumAudioPresent, "Num audio present"); NumAudioPresent++; Param_Info2(NumAudioPresent, " channels");
962 Get_S1 (3, NumAssets, "Num assets"); NumAssets++; Param_Info2(NumAssets, " assets");
963 Element_Begin1("Active masks");
964 for (int8u Pos=0; Pos<NumAudioPresent; Pos++)
965 {
966 int32u ActiveExSSMask;
967 Get_S4 (SubStreamIndex+1, ActiveExSSMask, "Active ExSS mask");
968 ActiveExSSMasks.push_back(ActiveExSSMask);
969 }
970 Element_End0();
971 Element_Begin1("Active masks 2");
972 for (int8u Pos=0; Pos<NumAudioPresent; Pos++)
973 for (int8u Pos2=0; Pos2<SubStreamIndex+1; Pos2+=2)
974 if (ActiveExSSMasks[Pos]%2)
975 Skip_S1(8, "Active ExSS Mask");
976 Element_End0();
977 TEST_SB_SKIP( "Mix metadata Enabled");
978 int8u Bits4MixOutMask, NumMixOutConfigs;
979 Skip_S1(2, "Mix metadata adjustment level");
980 Get_S1 (2, Bits4MixOutMask, "Bits4Mix out mask"); Bits4MixOutMask=4+Bits4MixOutMask*4; Param_Info2(Bits4MixOutMask, " bits");
981 Get_S1 (2, NumMixOutConfigs, "Number of mix out configs"); NumMixOutConfigs++; Param_Info2(NumMixOutConfigs, " configs");
982 for (int8u Pos=0; Pos<NumMixOutConfigs; Pos++)
983 Skip_S1(Bits4MixOutMask, "MixOutChMask");
984 TEST_SB_END();
985 TESTELSE_SB_ELSE("Static fields present");
986 NumAudioPresent=1;
987 NumAssets=1;
988 TESTELSE_SB_END();
989 Asset_Sizes.clear();
990 Element_Begin1("Sizes");
991 for (int8u Pos=0; Pos<NumAssets; Pos++)
992 {
993 int32u Size;
994 if (isBlownUpHeader)
995 {
996 Get_S3 (20, Size, "Size"); Size++; Param_Info2(Size, " bytes");
997 }
998 else
999 {
1000 Get_S3 (16, Size, "Size"); Size++; Param_Info2(Size, " bytes");
1001 }
1002 Asset_Sizes.push_back(Size);
1003 }
1004 Element_End0();
1005 for (int8u Asset_Pos=0; Asset_Pos<NumAssets; Asset_Pos++)
1006 {
1007 Element_Begin1("Asset");
1008 int16u AssetSize;
1009 Get_S2 (9, AssetSize, "Asset size");
1010 AssetSize++; Param_Info2(AssetSize, " bytes?");
1011 Skip_S1(3, "Descriptor data for asset index");
1012 if (StaticFieldsPresent)
1013 {
1014 TEST_SB_SKIP( "Asset type descriptor present");
1015 Info_S1( 4, TypeDescriptor, "Asset type descriptor"); Param_Info1(DTS_HD_TypeDescriptor[TypeDescriptor]);
1016 TEST_SB_END();
1017 TEST_SB_SKIP( "Language descriptor present");
1018 Info_S3(24, LanguageDescriptor, "Language descriptor"); Param_Info1(Ztring().From_CC3(LanguageDescriptor));
1019 TEST_SB_END();
1020 TEST_SB_SKIP( "Info text present");
1021 int16u InfoTextByteSize;
1022 Get_S2(10, InfoTextByteSize, "Info text size"); InfoTextByteSize++; Param_Info2(InfoTextByteSize, "bytes");
1023 for (int16u Pos=0; Pos<InfoTextByteSize; Pos++)
1024 Skip_S1(8, "Info text");
1025 TEST_SB_END();
1026 Get_S1 (5, HD_BitResolution, "Bit resolution"); HD_BitResolution++; Param_Info2(HD_BitResolution, " bits");
1027 Get_S1 (4, HD_MaximumSampleRate, "Maximum sample rate"); Param_Info2(DTS_HD_MaximumSampleRate[HD_MaximumSampleRate], " Hz");
1028 Get_S1 (8, HD_TotalNumberChannels, "Total number of channels"); HD_TotalNumberChannels++; Param_Info2(HD_TotalNumberChannels, " channels");
1029 TEST_SB_SKIP( "1 to 1 map channels to speakers");
1030 int8u SpeakerActivityMaskBits, SpeakerRemapSetsCount;
1031 if (HD_TotalNumberChannels>2)
1032 Skip_SB( "Embedded stereo flag"); //else is 0
1033 if (HD_TotalNumberChannels>6)
1034 Skip_SB( "Embedded 6 Channels flag"); //else is 0
1035 TESTELSE_SB_SKIP( "Speaker mask enabled");
1036 Get_S1 (2, SpeakerActivityMaskBits, "Speaker activity mask bits"); Param_Info2(4+SpeakerActivityMaskBits*4, " bits");
1037 SpeakerActivityMaskBits=4+SpeakerActivityMaskBits*4;
1038 Get_S2 (SpeakerActivityMaskBits, HD_SpeakerActivityMask, "Speaker activity mask"); Param_Info1(DTS_HD_SpeakerActivityMask(HD_SpeakerActivityMask).c_str());
1039 TESTELSE_SB_ELSE( "Speaker mask enabled");
1040 SpeakerActivityMaskBits=0;
1041 TESTELSE_SB_END();
1042 Get_S1 (3, SpeakerRemapSetsCount, "Speaker remap sets count");
1043 for (int8u Pos=0; Pos<SpeakerRemapSetsCount; Pos++)
1044 Skip_S2(SpeakerActivityMaskBits, "Standard speaker layout mask");
1045 for (int8u Pos=0; Pos<SpeakerRemapSetsCount; Pos++)
1046 {
1047 int8u NumDecCh4Remap;
1048 Get_S1(5, NumDecCh4Remap, "NumDecCh4Remap");
1049 //Not finnished!
1050 }
1051 TEST_SB_END();
1052 Element_End0();
1053 }
1054 }
1055 BS_End();
1056 Skip_XX(header_size-Element_Offset, "Unknown");
1057 }
1058 else
1059 {
1060 //Frame
1061 Element_Name("Frame");
1062 Element_Code=0;
1063
1064 int8u EncoderSoftwareRevision;
1065 bool crc_present;
1066 BS_Begin();
1067 Info_SB( FrameType, "Frame Type"); Param_Info1(DTS_FrameType[FrameType]);
1068 Skip_S1( 5, "Deficit Sample Count");
1069 Get_SB ( crc_present, "CRC Present");
1070 Get_S2 ( 7, Number_Of_PCM_Sample_Blocks, "Number of PCM Sample Blocks");
1071 Number_Of_PCM_Sample_Blocks++;
1072 Get_S2 (14, Primary_Frame_Byte_Size, "Primary Frame Byte Size minus 1");
1073 Primary_Frame_Byte_Size++;
1074 if (!Word)
1075 Primary_Frame_Byte_Size=Primary_Frame_Byte_Size*16/14; //Word is on 14 bits
1076 Param_Info2(Primary_Frame_Byte_Size, " bytes");
1077 Get_S1 ( 6, channel_arrangement, "Audio Channel Arrangement"); Param_Info2(DTS_Channels[channel_arrangement], " channels");
1078 Core_Core_AMODE=channel_arrangement;
1079 Get_S1 ( 4, sample_frequency, "Core Audio Sampling Frequency"); Param_Info2(DTS_SamplingRate[sample_frequency], " Hz");
1080 Get_S1 ( 5, bit_rate, "Transmission Bit Rate"); Param_Info2(DTS_BitRate[bit_rate], " bps");
1081 Skip_SB( "Embedded Down Mix Enabled");
1082 Skip_SB( "Embedded Dynamic Range");
1083 Skip_SB( "Embedded Time Stamp");
1084 Skip_SB( "Auxiliary Data");
1085 Skip_SB( "HDCD");
1086 Get_S1 ( 3, ExtensionAudioDescriptor, "Extension Audio Descriptor"); Param_Info1(DTS_ExtensionAudioDescriptor[ExtensionAudioDescriptor]);
1087 Get_SB ( ExtendedCoding, "Extended Coding");
1088 Skip_SB( "Audio Sync Word Insertion");
1089 Get_S1 ( 2, lfe_effects, "Low Frequency Effects");
1090 Core_Core_LFF=lfe_effects;
1091 Skip_SB( "Predictor History");
1092 if (crc_present)
1093 Skip_S2(16, "Header CRC Check");
1094 Skip_SB( "Multirate Interpolator");
1095 Get_S1 ( 4, EncoderSoftwareRevision, "Encoder Software Revision");
1096 Skip_S1( 2, "Copy History");
1097 Get_S1 ( 2, bits_per_sample, "Source PCM Resolution"); Param_Info1(Ztring::ToZtring(DTS_Resolution[bits_per_sample])+__T(" bits"));
1098 Get_SB ( ES, "ES");
1099 Skip_SB( "Front Sum/Difference");
1100 Skip_SB( "Surrounds Sum/Difference");
1101 Skip_S1( 4, "Dialog Normalisation Parameter");
1102 switch (EncoderSoftwareRevision)
1103 {
1104 case 6 :
1105 Skip_S1( 4, "Dialog Normalisation Parameter");
1106 break;
1107 case 7 :
1108 Skip_S1( 4, "Dialog Normalisation Parameter");
1109 break;
1110 default :
1111 Skip_S1( 4, "Unspecified");
1112 break;
1113 }
1114 BS_End();
1115 }
1116
1117 //Name
1118 Element_Info1(Ztring::ToZtring(Frame_Count));
1119
1120 //PTS
1121 Element_Info1C((FrameInfo.PTS!=(int64u)-1), __T("PTS ")+Ztring().Duration_From_Milliseconds(float64_int64s(((float64)FrameInfo.PTS)/1000000)));
1122
1123 //Counting
1124 if (File_Offset+Buffer_Offset+Element_Size==File_Size)
1125 Frame_Count_Valid=Frame_Count; //Finish frames in case of there are less than Frame_Count_Valid frames
1126 if (Element_Code==0 || !Core_Exists)
1127 {
1128 if (Frame_Count==0)
1129 PTS_Begin=FrameInfo.PTS;
1130 Frame_Count++;
1131 Frame_Count_InThisBlock++;
1132 float64 BitRate=BitRate_Get();
1133 if (BitRate)
1134 {
1135 FrameInfo.DUR=float64_int64s(((float64)(Element_Size+Header_Size))*8/BitRate*1000000000);
1136 if (FrameInfo.DTS!=(int64u)-1)
1137 FrameInfo.DTS+=FrameInfo.DUR;
1138 if (FrameInfo.PTS!=(int64u)-1)
1139 FrameInfo.PTS+=FrameInfo.DUR;
1140 }
1141 }
1142
1143 //If filled
1144 if (Status[IsFilled])
1145 {
1146 //Little Endian and 14-bit streams management
1147 if (Save_Buffer)
1148 {
1149 delete[] Buffer;
1150 Buffer=Save_Buffer; Save_Buffer=NULL;
1151 Buffer_Offset=Save_Buffer_Offset;
1152 Buffer_Size=Save_Buffer_Size;
1153 File_Offset-=Buffer_Offset;
1154 if (!Word)
1155 Element_Size=Element_Size*16/14;
1156 }
1157
1158 Skip_XX(Element_Size-Element_Offset, "Data");
1159 return;
1160 }
1161
1162 //Parsing
1163 switch(Element_Code)
1164 {
1165 case 0 : Core(); break;
1166 case 1 : HD(); break;
1167 default : Skip_XX(Element_Size, "Data");
1168 }
1169
1170 //Little Endian and 14-bit streams management
1171 if (Save_Buffer)
1172 {
1173 delete[] Buffer;
1174 Buffer=Save_Buffer; Save_Buffer=NULL;
1175 Buffer_Offset=Save_Buffer_Offset;
1176 Buffer_Size=Save_Buffer_Size;
1177 File_Offset-=Buffer_Offset;
1178 if (!Word)
1179 Element_Size=Element_Size*16/14;
1180 }
1181 }
1182
1183 //***************************************************************************
1184 // Elements
1185 //***************************************************************************
1186
1187 //---------------------------------------------------------------------------
Core()1188 void File_Dts::Core()
1189 {
1190 Element_Name("Frame");
1191
1192 //It exists (not in XSA streams)
1193 Core_Exists=true;
1194 Presence.set(presence_Core_Core);
1195
1196 //Looking for extensions
1197 int64u Core_Size=Element_Size, XCh_Sync=Element_Size, XXCh_Sync=Element_Size, X96k_Sync=Element_Size;
1198 if (ExtendedCoding)
1199 {
1200 //XCh
1201 if (ExtensionAudioDescriptor==0 || ExtensionAudioDescriptor==3)
1202 for (size_t Pos=0; Pos+4<=Element_Size; Pos++)
1203 if (CC4(Buffer+Buffer_Offset+Pos)==0x5A5A5A5A)
1204 XCh_Sync=Pos;
1205
1206 //XXCh
1207 if (ExtensionAudioDescriptor==6)
1208 for (size_t Pos=0; Pos+4<=Element_Size; Pos++)
1209 if (CC4(Buffer+Buffer_Offset+Pos)==0x47004A03)
1210 XXCh_Sync=Pos;
1211
1212 //X96k
1213 if (ExtensionAudioDescriptor==2 || ExtensionAudioDescriptor==3)
1214 for (size_t Pos=0; Pos+4<=Element_Size; Pos++)
1215 if (CC4(Buffer+Buffer_Offset+Pos)==0x1D95F262)
1216 X96k_Sync=Pos;
1217
1218 //Finding core size
1219 if (XCh_Sync<Core_Size)
1220 Core_Size=XCh_Sync;
1221 if (XXCh_Sync<Core_Size)
1222 Core_Size=XXCh_Sync;
1223 if (X96k_Sync<Core_Size)
1224 Core_Size=X96k_Sync;
1225 }
1226
1227 //Parsing
1228 Skip_XX(Core_Size-Element_Offset, "Core data");
1229 if (ExtendedCoding && (ExtensionAudioDescriptor==2 || ExtensionAudioDescriptor==3))
1230 {
1231 Element_Begin0();
1232 Skip_B4( "Magic");
1233 Core_X96k(XCh_Sync-Element_Offset);
1234 Element_End0();
1235 }
1236 if (ExtendedCoding && (ExtensionAudioDescriptor==0 || ExtensionAudioDescriptor==3))
1237 {
1238 Element_Begin0();
1239 Skip_B4( "Magic");
1240 Core_XCh(Element_Size-Element_Offset);
1241 Element_End0();
1242 }
1243 if (ExtendedCoding && ExtensionAudioDescriptor==6)
1244 {
1245 Element_Begin0();
1246 Skip_B4( "Magic");
1247 Core_XXCh(Element_Size-Element_Offset);
1248 Element_End0();
1249 }
1250
1251 //Filling
1252 FILLING_BEGIN();
1253 if (!Status[IsAccepted] && Frame_Count>=2) //TODO: find a better way to accept stream in short files so with only few frames
1254 Accept("DTS");
1255 if (!Status[IsFilled] && Frame_Count>=Frame_Count_Valid)
1256 {
1257 Fill("DTS");
1258
1259 //No more need data
1260 if (!IsSub && Config->ParseSpeed<1.0)
1261 Finish("DTS");
1262 }
1263 FILLING_END();
1264 }
1265
1266 //---------------------------------------------------------------------------
Core_XCh(int64u Size)1267 void File_Dts::Core_XCh(int64u Size)
1268 {
1269 //Parsing
1270 Element_Name("XCh (6.1 channels)");
1271 int16u XChFSIZE;
1272 int8u AMODE;
1273 BS_Begin();
1274 Get_S2 (10, XChFSIZE, "Primary Frame Byte Size");
1275 Get_S1 ( 4, AMODE, "Extension Channel Arrangement");
1276 BS_End();
1277 if (XChFSIZE==Element_Size-(Element_Offset-6))
1278 XChFSIZE--; //Compatibility reason (from specs)
1279 if ((int64u)XChFSIZE+1-6<=Size-2)
1280 Skip_XX(XChFSIZE+1-6, "XCh data");
1281 else
1282 Skip_XX(Size-2, "XCh data (with problem)");
1283
1284 FILLING_BEGIN();
1285 channel_arrangement_XCh=AMODE;
1286 Presence.set(presence_Core_XCh);
1287 Core_XCh_AMODE=AMODE;
1288 FILLING_END();
1289 }
1290
1291 //---------------------------------------------------------------------------
Core_XXCh(int64u Size)1292 void File_Dts::Core_XXCh(int64u Size)
1293 {
1294 Element_Name("XXCh (6.1 or 7.1 channels)");
1295 int8u ChannelsAdded;
1296 BS_Begin();
1297 Skip_S1 (6, "nuHeaderSizeXXCh minus 1");
1298 Skip_S1 (1, "bCRCPresent4ChSetHeaderXXCh minus 1");
1299 Skip_S1 (5, "nuBits4SpkrMaskXXCh minus 1");
1300 Get_S1 (2, ChannelsAdded, "nuNumChSetsInXXCh minus 1");
1301 Skip_S1 (2, "?");
1302 BS_End();
1303 Skip_XX(Size-2, "Data");
1304
1305 FILLING_BEGIN();
1306 channel_arrangement_XCh=ChannelsAdded+1;
1307 Core_XXCh_nuNumChSetsInXXCh=ChannelsAdded+1;
1308 Presence.set(presence_Core_XXCh);
1309 FILLING_END();
1310 }
1311
1312 //---------------------------------------------------------------------------
Core_X96k(int64u Size)1313 void File_Dts::Core_X96k(int64u Size)
1314 {
1315 //Parsing
1316 Element_Name("X96k (96 KHz)");
1317 int16u FSIZE96;
1318 int8u REVNO;
1319 BS_Begin();
1320 Get_S2 (12, FSIZE96, "96 kHz Extension Frame Byte Data Size");
1321 Get_S1 ( 4, REVNO, "Revision Number");
1322 BS_End();
1323 Skip_XX(Size-2, "X96k data"); //FSIZE96 is until end, not X96k size
1324
1325 FILLING_BEGIN();
1326 sample_frequency_X96k=14; //96KHz
1327 Profile="96/24";
1328 Presence.set(presence_Core_X96);
1329 FILLING_END();
1330 }
1331
1332 //---------------------------------------------------------------------------
HD()1333 void File_Dts::HD()
1334 {
1335 //Parsing
1336 while (Element_Offset<Element_Size)
1337
1338 {
1339 //Looking for size
1340 int64u Next=Element_Offset+4;
1341 while (Next+4<=Element_Size)
1342 {
1343 int32u CC=CC4(Buffer+Buffer_Offset+(size_t)Next);
1344 if (CC==0x0A801921
1345 || CC==0x1D95F262
1346 || CC==0x41A29547
1347 || CC==0x47004A03
1348 || CC==0x5A5A5A5A
1349 || CC==0x655E315E)
1350 break;
1351 Next++;
1352 }
1353 if (Next+4>Element_Size)
1354 Next=Element_Size;
1355
1356 Element_Begin0();
1357 int32u Magic;
1358 Get_B4 (Magic, "Magic");
1359 switch (Magic)
1360 {
1361 case 0x0A801921 : HD_XSA(Next-Element_Offset); break;
1362 case 0x1D95F262 : HD_X96k(Next-Element_Offset); break;
1363 case 0x41A29547 : HD_XLL(Next-Element_Offset); break;
1364 case 0x47004A03 : HD_XXCh(Next-Element_Offset); break;
1365 case 0x5A5A5A5A : HD_XCh(Next-Element_Offset); break;
1366 case 0x655E315E : HD_XBR(Next-Element_Offset); break;
1367 default :
1368 //Magic value is unknown
1369 if (Profile.empty())
1370 Profile="HD";
1371 Skip_XX(Next-Element_Offset, "Data");
1372 }
1373 Element_End0();
1374 }
1375
1376 //Filling
1377 FILLING_BEGIN();
1378 if (Count_Get(Stream_Audio)==0 && Frame_Count>=Frame_Count_Valid)
1379 {
1380 Accept("DTS");
1381 Fill("DTS");
1382
1383 //No more need data
1384 if (!IsSub && Config->ParseSpeed<1.0)
1385 Finish("DTS");
1386 }
1387 FILLING_END();
1388 }
1389
1390 //---------------------------------------------------------------------------
HD_XCh(int64u Size)1391 void File_Dts::HD_XCh(int64u Size)
1392 {
1393 //Parsing
1394 Element_Name("XCh (6.1 channels)");
1395 Skip_XX(Size, "Data");
1396
1397 FILLING_BEGIN();
1398 channel_arrangement_XCh=1;
1399 if (Profile.empty())
1400 Profile="HRA";
1401 FILLING_END();
1402 }
1403
1404 //---------------------------------------------------------------------------
HD_XXCh(int64u Size)1405 void File_Dts::HD_XXCh(int64u Size)
1406 {
1407 Element_Name("XXCh (6.1 or 7.1 channels)");
1408 int8u ChannelsAdded;
1409 BS_Begin();
1410 Skip_S1 (8, "?");
1411 Get_S1 (2, ChannelsAdded, "Channels added?");
1412 Skip_S1 (6, "?");
1413 BS_End();
1414 Skip_XX(Size-2, "Data");
1415
1416 FILLING_BEGIN();
1417 channel_arrangement_XCh=ChannelsAdded;
1418 if (Profile.empty())
1419 Profile="HRA";
1420 Presence.set(presence_Extended_XXCh);
1421 FILLING_END();
1422 }
1423
1424 //---------------------------------------------------------------------------
HD_X96k(int64u Size)1425 void File_Dts::HD_X96k(int64u Size)
1426 {
1427 //Parsing
1428 Element_Name("X96k (96 KHz)");
1429 Skip_XX(Size, "Data");
1430
1431 FILLING_BEGIN();
1432 sample_frequency=14; //96KHz
1433 Profile="HRA";
1434 Presence.set(presence_Extended_X96);
1435 FILLING_END();
1436 }
1437
1438 //---------------------------------------------------------------------------
HD_XLL(int64u Size)1439 void File_Dts::HD_XLL(int64u Size)
1440 {
1441 Element_Name("XLL (LossLess)");
1442
1443 // Quick and dirty search of DTS:X pattern
1444 if (!Presence[presence_Extended_XLL])
1445 {
1446 Extension_XLL_X_No=0;
1447 Extension_XLL_X_Yes=0;
1448 }
1449 if (!Presence[presence_Extended_XLL_X] && (!Extension_XLL_X_No || !Extension_XLL_X_Yes) && (Extension_XLL_X_No<8 || Extension_XLL_X_Yes<8)) //Limiting the parsing to a couple of frames for performance reasons and stop if there is a risk of false positive
1450 {
1451 bool IsX=false;
1452 const int8u* cur = Buffer + Buffer_Offset + (size_t)Element_Offset;
1453 const int8u* end = cur + (size_t)Size-3;
1454 for (; cur<end; ++cur)
1455 if (*cur == 0x02 && !*(cur + 1) && *(cur + 2) == 0x08 && *(cur + 3) == 0x50)
1456 {
1457 IsX=true;
1458 break;
1459 }
1460
1461 if (IsX)
1462 {
1463 Extension_XLL_X_Yes++;
1464 if (Extension_XLL_X_Yes>=8 && !Extension_XLL_X_No)
1465 Presence.set(presence_Extended_XLL_X);
1466 }
1467 else
1468 Extension_XLL_X_No++;
1469 }
1470
1471 // Parsing
1472 Skip_XX(Size, "Data");
1473
1474 FILLING_BEGIN();
1475 Profile="MA";
1476 Presence.set(presence_Extended_XLL);
1477 FILLING_END();
1478 }
1479
1480 //---------------------------------------------------------------------------
HD_XBR(int64u Size)1481 void File_Dts::HD_XBR(int64u Size)
1482 {
1483 Element_Name("XBR (BitRate extension)");
1484 Skip_XX(Size, "Data");
1485
1486 FILLING_BEGIN();
1487 Profile="HRA";
1488 Presence.set(presence_Extended_XBR);
1489 FILLING_END();
1490 }
1491
1492 //---------------------------------------------------------------------------
HD_XSA(int64u Size)1493 void File_Dts::HD_XSA(int64u Size)
1494 {
1495 Element_Name("LBR (low bitrate)");
1496 Skip_XX(Size, "Data");
1497
1498 FILLING_BEGIN();
1499 Profile="Express";
1500 Presence.set(presence_Extended_LBR);
1501 FILLING_END();
1502 }
1503
1504 //***************************************************************************
1505 // Helpers
1506 //***************************************************************************
1507
1508 //---------------------------------------------------------------------------
BitRate_Get(bool WithHD)1509 float64 File_Dts::BitRate_Get(bool WithHD)
1510 {
1511 if (bit_rate<29 || Profile==__T("Express"))
1512 {
1513 float64 BitRate;
1514 if (Profile==__T("Express"))
1515 BitRate=0; //No core bitrate
1516 else if (DTS_SamplingRate[sample_frequency])
1517 BitRate=((float64)Primary_Frame_Byte_Size)*8/(Number_Of_PCM_Sample_Blocks*32)*DTS_SamplingRate[sample_frequency]; //(float64)DTS_BitRate[bit_rate];
1518 else
1519 BitRate=0; //Problem
1520 if (WithHD && HD_ExSSFrameDurationCode!=(int8u)-1)
1521 {
1522 int32u SamplePerFrames=HD_ExSSFrameDurationCode;
1523 switch (HD_MaximumSampleRate)
1524 {
1525 case 0 : // 8000
1526 case 10 : // 12000
1527 SamplePerFrames*= 128; break;
1528 case 1 : // 16000
1529 case 5 : // 22050
1530 case 11 : // 24000
1531 SamplePerFrames*= 256; break;
1532 case 2 : // 32000
1533 case 6 : // 44100
1534 case 12 : // 48000
1535 SamplePerFrames*= 512; break;
1536 case 3 : // 64000
1537 case 7 : // 88200
1538 case 13 : // 96000
1539 SamplePerFrames*=1024; break;
1540 case 4 : //128000
1541 case 8 : //176400
1542 case 14 : //192000
1543 SamplePerFrames*=2048; break;
1544 case 9 : //352800
1545 case 15 : //384000
1546 SamplePerFrames*=4096; break;
1547 default : SamplePerFrames= 0; break; //Can never happen (4 bits)
1548 }
1549 if (SamplePerFrames)
1550 BitRate+=((float64)HD_size)*8*DTS_HD_MaximumSampleRate[HD_MaximumSampleRate]/SamplePerFrames;
1551 }
1552 //if (Primary_Frame_Byte_Size && Profile==__T("HRA"))
1553 // BitRate*=1+((float64)HD_size)/Primary_Frame_Byte_Size; //HD block are not in the nominal bitrate
1554 return BitRate;
1555 }
1556 else
1557 return 0;
1558 }
1559
1560 //---------------------------------------------------------------------------
FrameSynchPoint_Test()1561 bool File_Dts::FrameSynchPoint_Test()
1562 {
1563 if (Save_Buffer)
1564 return true; //Test already made by Synchronize()
1565
1566 int64u Value=CC6(Buffer+Buffer_Offset);
1567 if ((Value&0xFFFFFFFFFC00LL)==0x7FFE8001FC00LL //16 bits and big endian Core
1568 || (Value&0xFFFFFFFF00FCLL)==0xFE7F018000FCLL //16 bits and little endian Core
1569 || (Value&0xFFFFFFFFF7F0LL)==0x1FFFE80007F0LL //14 bits and big endian Core
1570 || (Value&0xFFFFFFFFF0F7LL)==0xFF1F00E8F007LL //14 bits and little endian Core
1571 || (Value&0xFFFFFFFF0000LL)==0x645820250000LL) //16 bits and big endian HD
1572 {
1573 //Configuration - 14 bits or Little Endian
1574 switch (Buffer[Buffer_Offset])
1575 {
1576 default : Word=true; BigEndian=true; break; //16 bits and big endian bitstream
1577 case 0xFE : Word=true; BigEndian=false; break; //16 bits and little endian bitstream
1578 case 0x1F : Word=false; BigEndian=true; break; //14 bits and big endian bitstream
1579 case 0xFF : Word=false; BigEndian=false; break; //14 bits and little endian bitstream
1580 }
1581
1582 int32u Size;
1583 if (Buffer[Buffer_Offset]==0x64) //HD
1584 {
1585 if (Buffer_Offset+10>Buffer_Size)
1586 return false; //Need more data
1587
1588 bool isBlownUpHeader=(Buffer[Buffer_Offset+5]&0x20)?true:false;
1589 if (isBlownUpHeader)
1590 Size=((Buffer[Buffer_Offset+6]&0x01)<<19)
1591 | ( Buffer[Buffer_Offset+7] <<11)
1592 | ( Buffer[Buffer_Offset+8] << 3)
1593 | ( Buffer[Buffer_Offset+9] >> 5);
1594 else
1595 Size=((Buffer[Buffer_Offset+6]&0x1F)<<11)
1596 | ( Buffer[Buffer_Offset+7] << 3)
1597 | ( Buffer[Buffer_Offset+8] >> 5);
1598 Size++;
1599 Original_Size=Size;
1600 }
1601 else
1602 {
1603 if (Word)
1604 {
1605 if (Buffer_Offset+8>Buffer_Size)
1606 return false; //Need more data
1607
1608 if (BigEndian)
1609 Size=((Buffer[Buffer_Offset+5]&0x03)<<12)
1610 | ( Buffer[Buffer_Offset+6] << 4)
1611 | ( Buffer[Buffer_Offset+7] >> 4);
1612 else
1613 Size=((Buffer[Buffer_Offset+4]&0x03)<<12)
1614 | ( Buffer[Buffer_Offset+7] << 4)
1615 | ( Buffer[Buffer_Offset+6] >> 4);
1616 Size++;
1617 Original_Size=Size;
1618 }
1619 else
1620 {
1621 if (Buffer_Offset+10>Buffer_Size)
1622 return false; //Need more data
1623
1624 if (BigEndian)
1625 Size=((Buffer[Buffer_Offset+6]&0x03)<<12)
1626 | ( Buffer[Buffer_Offset+7] << 4)
1627 | ((Buffer[Buffer_Offset+8]&0x3C)>> 2);
1628 else
1629 Size=((Buffer[Buffer_Offset+7]&0x03)<<12)
1630 | ( Buffer[Buffer_Offset+6] << 4)
1631 | ((Buffer[Buffer_Offset+9]&0x3C)>> 2);
1632 Size++;
1633 Original_Size=Size*16/14;
1634 }
1635 }
1636 if (Buffer_Offset+Original_Size>Buffer_Size)
1637 return false; //Need more data
1638
1639 if (!Word || !BigEndian)
1640 {
1641 Save_Buffer=Buffer;
1642 Save_Buffer_Offset=Buffer_Offset;
1643 Save_Buffer_Size=Buffer_Size;
1644
1645 //Preparing new buffer
1646 if (Word)
1647 {
1648 int8u* Buffer_Little=new int8u[Size];
1649 for (size_t Pos=0; Pos+1<Size; Pos+=2)
1650 {
1651 Buffer_Little[Pos+1]=Save_Buffer[Buffer_Offset+Pos ];
1652 Buffer_Little[Pos ]=Save_Buffer[Buffer_Offset+Pos+1];
1653 }
1654 Save_Buffer=Buffer_Little;
1655 Save_Buffer_Offset=0;
1656 Save_Buffer_Size=Size;
1657 }
1658 else
1659 {
1660 int8u* Dest=new int8u[Size];
1661 for (size_t Pos=0; Pos+8<=Original_Size; Pos+=8)
1662 {
1663 int64u Value;
1664 if (BigEndian)
1665 Value =(((int64u)( BigEndian2int16u(Buffer+Buffer_Offset+Pos )&0x3FFF))<<42)
1666 | (((int64u)( BigEndian2int16u(Buffer+Buffer_Offset+Pos+2)&0x3FFF))<<28)
1667 | (((int64u)( BigEndian2int16u(Buffer+Buffer_Offset+Pos+4)&0x3FFF))<<14)
1668 | (((int64u)( BigEndian2int16u(Buffer+Buffer_Offset+Pos+6)&0x3FFF)) );
1669 else
1670 Value =(((int64u)(LittleEndian2int16u(Buffer+Buffer_Offset+Pos )&0x3FFF))<<42)
1671 | (((int64u)(LittleEndian2int16u(Buffer+Buffer_Offset+Pos+2)&0x3FFF))<<28)
1672 | (((int64u)(LittleEndian2int16u(Buffer+Buffer_Offset+Pos+4)&0x3FFF))<<14)
1673 | (((int64u)(LittleEndian2int16u(Buffer+Buffer_Offset+Pos+6)&0x3FFF)) );
1674 int56u2BigEndian(Dest+Pos*14/16, Value);
1675 }
1676 Save_Buffer=Dest;
1677 Save_Buffer_Offset=0;
1678 Save_Buffer_Size=Size;
1679 }
1680 }
1681
1682 Synched=true;
1683 }
1684 else
1685 Synched=false;
1686
1687 return true;
1688 }
1689
1690 //---------------------------------------------------------------------------
1691 } //NameSpace
1692
1693 #endif //MEDIAINFO_DTS_YES
1694
1695