1 /* Copyright (c) MediaArea.net SARL. All Rights Reserved.
2 *
3 * Use of this source code is governed by a BSD-style license that can
4 * be found in the License.html file in the root of the source tree.
5 */
6
7 //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
8 //
9 // Elements part
10 //
11 //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
12
13 //---------------------------------------------------------------------------
14 // Pre-compilation
15 #include "MediaInfo/PreComp.h"
16 #ifdef __BORLANDC__
17 #pragma hdrstop
18 #endif
19 //---------------------------------------------------------------------------
20
21 //---------------------------------------------------------------------------
22 #include "MediaInfo/Setup.h"
23 //---------------------------------------------------------------------------
24
25 //---------------------------------------------------------------------------
26 #ifdef MEDIAINFO_WM_YES
27 //---------------------------------------------------------------------------
28
29 //---------------------------------------------------------------------------
30 #include "MediaInfo/Multiple/File_Wm.h"
31 #if defined(MEDIAINFO_VC1_YES)
32 #include "MediaInfo/Video/File_Vc1.h"
33 #endif
34 #if defined(MEDIAINFO_MPEGV_YES)
35 #include "MediaInfo/Video/File_Mpegv.h"
36 #endif
37 #if defined(MEDIAINFO_AC3_YES)
38 #include "MediaInfo/Audio/File_Ac3.h"
39 #endif
40 #if defined(MEDIAINFO_MPEGA_YES)
41 #include "MediaInfo/Audio/File_Mpega.h"
42 #endif
43 #include "MediaInfo/MediaInfo_Config_MediaInfo.h"
44 #if MEDIAINFO_DEMUX
45 #include "ThirdParty/base64/base64.h"
46 #endif //MEDIAINFO_DEMUX
47 #include "ZenLib/Utils.h"
48 using namespace ZenLib;
49 //---------------------------------------------------------------------------
50
51 namespace MediaInfoLib
52 {
53
54 //***************************************************************************
55 // Constants
56 //***************************************************************************
57
Wm_CodecList_Kind(int32u Kind)58 static const char* Wm_CodecList_Kind(int32u Kind)
59 {
60 switch (Kind)
61 {
62 case 0x01 : return "Video";
63 case 0x02 : return "Audio";
64 default : return "";
65 }
66 }
67
Wm_BannerImageData_Type(int32u Type)68 static const char* Wm_BannerImageData_Type(int32u Type)
69 {
70 switch (Type)
71 {
72 case 0x00 : return "";
73 case 0x01 : return "Bitmap";
74 case 0x02 : return "JPEG";
75 case 0x03 : return "GIF";
76 default : return "";
77 }
78 }
79
80 #define UUID(NAME, PART1, PART2, PART3, PART4, PART5) \
81 const int64u NAME =((int64u(0x##PART1))&0xFF)<<56 | ((int64u(0x##PART1)>>8)&0xFF)<<48 | ((int64u(0x##PART1)>>16)&0xFF)<<40 | ((int64u(0x##PART1)>>24)&0xFF)<<32 | ((int64u(0x##PART2))&0xFF)<<24 | ((int64u(0x##PART2)>>8)&0xFF)<<16 | ((int64u(0x##PART3))&0xFF)<<8 | ((int64u(0x##PART3)>>8)&0xFF); \
82 const int64u NAME##2=0x##PART4##PART5##ULL; \
83
84 namespace Elements
85 {
86 UUID(Header, 75B22630, 668E, 11CF, A6D9, 00AA0062CE6C)
87 UUID(Header_FileProperties, 8CABDCA1, A947, 11CF, 8EE4, 00C00C205365)
88 UUID(Header_StreamProperties, B7DC0791, A9B7, 11CF, 8EE6, 00C00C205365)
89 UUID(Header_StreamProperties_Audio, F8699E40, 5B4D, 11CF, A8FD, 00805F5C442B)
90 UUID(Header_StreamProperties_Video, BC19EFC0, 5B4D, 11CF, A8FD, 00805F5C442B)
91 UUID(Header_StreamProperties_Command, 59DACFC0, 59E6, 11D0, A3AC, 00A0C90348F6)
92 UUID(Header_StreamProperties_JFIF, B61BE100, 5B4E, 11CF, A8FD, 00805F5C442B)
93 UUID(Header_StreamProperties_DegradableJPEG, 35907DE0, E415, 11CF, A917, 00805F5C442B)
94 UUID(Header_StreamProperties_FileTransfer, 91BD222C, F21C, 497A, 8B6D, 5AA86BFC0185)
95 UUID(Header_StreamProperties_Binary, 3AFB65E2, 47EF, 40F2, AC2C, 70A90D71D343)
96 UUID(Header_StreamProperties_Binary_WebStreamMediaSubType, 776257D4, C627, 41CB, 8F81, 7AC7FF1C40CC)
97 UUID(Header_StreamProperties_Binary_WebStreamFormat, DA1E6B13, 8359, 4050, B398, 388E965BF00C)
98 UUID(Header_HeaderExtension, 5FBF03B5, A92E, 11CF, 8EE3, 00C00C205365)
99 UUID(Header_HeaderExtension_ExtendedStreamProperties, 14E6A5CB, C672, 4332, 8399, A96952065B5A)
100 UUID(Header_HeaderExtension_AdvancedMutualExclusion, A08649CF, 4775, 4670, 8A16, 6E35357566CD)
101 UUID(Header_HeaderExtension_GroupMutualExclusion, D1465A40, 5A79, 4338, B71B, E36B8FD6C249)
102 UUID(Header_HeaderExtension_StreamPrioritization, D4FED15B, 88D3, 454F, 81F0, ED5C45999E24)
103 UUID(Header_HeaderExtension_BandwidthSharing, A69609E6, 517B, 11D2, B6AF, 00C04FD908E9)
104 UUID(Header_HeaderExtension_LanguageList, 7C4346A9, EFE0, 4BFC, B229, 393EDE415C85)
105 UUID(Header_HeaderExtension_Metadata, C5F8CBEA, 5BAF, 4877, 8467, AA8C44FA4CCA)
106 UUID(Header_HeaderExtension_MetadataLibrary, 44231C94, 9498, 49D1, A141, 1D134E457054)
107 UUID(Header_HeaderExtension_IndexParameters, D6E229DF, 35DA, 11D1, 9034, 00A0C90349BE)
108 UUID(Header_HeaderExtension_MediaIndexParameters, 6B203BAD, 3F11, 48E4, ACA8, D7613DE2CFA7)
109 UUID(Header_HeaderExtension_TimecodeIndexParameters, F55E496D, 9797, 4B5D, 8C8B, 604DFE9BFB24)
110 UUID(Header_HeaderExtension_Compatibility, 26F18B5D, 4584, 47EC, 9F5F, 0E651F0452C9)
111 UUID(Header_HeaderExtension_AdvancedContentEncryption, 43058533, 6981, 49E6, 9B74, AD12CB86D58C)
112 UUID(Header_HeaderExtension_IndexPlaceholder, D9AADE20, 7C17, 4F9C, BC28, 8555DD98E2A2)
113 UUID(Header_CodecList, 86D15240, 311D, 11D0, A3A4, 00ACC90348F6)
114 UUID(Header_ScriptCommand, 1EFB1A30, 0B62, 11D0, A39B, 00A0C90348F6)
115 UUID(Header_Marker, F487CD01, A951, 11CF, 8EE6, 00C00C205365)
116 UUID(Header_BitRateMutualExclusion, D6E229DC, 35DA, 11D1, 9034, 00A0C90349BE)
117 UUID(Header_ErrorCorrection, 75B22635, 668E, 11CF, A6D9, 00AA0062CE6C)
118 UUID(Header_ContentDescription, 75B22633, 668E, 11CF, A6D9, 00AA0062CE6C)
119 UUID(Header_ExtendedContentDescription, D2D0A440, E307, 11D2, 97F0, 00A0C95EA850)
120 UUID(Header_StreamBitRate, 7BF875CE, 468D, 11D1, 8D82, 006097C9A2B2)
121 UUID(Header_ContentBranding, 2211B3FA, BD23, 11D2, B4B7, 00A0C955FC6E)
122 UUID(Header_ContentEncryption, 2211B3FB, BD23, 11D2, B4B7, 00A0C955FC6E)
123 UUID(Header_ExtendedContentEncryption, 298AE614, 2622, 4C17, B935, DAE07EE9289C)
124 UUID(Header_DigitalSignature, 2211B3FC, BD23, 11D2, B4B7, 00A0C955FC6E)
125 UUID(Header_Padding, 1806D474, CADF, 4509, A4BA, 9AABCB96AAE8)
126 UUID(Data, 75B22636, 668E, 11CF, A6D9, 00AA0062CE6C)
127 UUID(SimpleIndex, 33000890, E5B1, 11CF, 89F4, 00A0C90349CB)
128 UUID(Index, D6E229D3, 35DA, 11D1, 9034, 00A0C90349BE)
129 UUID(MediaIndex, FEB103F8, 12AD, 4C64, 840F, 2A1D2F7AD48C)
130 UUID(TimecodeIndex, 3CB73FD0, 0C4A, 4803, 953D, EDF7B6228F0C)
131
132 UUID(Payload_Extension_System_TimeStamp, 1135BEB7, 3A39, 478A, 98D9, 15C76B00EB69);
133 UUID(Mutex_Language, D6E22A00, 35DA, 11D1, 9034, 00A0C90349BE);
134 UUID(Mutex_Bitrate, D6E22A01, 35DA, 11D1, 9034, 00A0C90349BE);
135 }
136
Wm_StreamType(const int128u & Kind)137 static const char* Wm_StreamType(const int128u& Kind)
138 {
139 switch (Kind.hi)
140 {
141 case Elements::Header_StreamProperties_Audio : return "Audio";
142 case Elements::Header_StreamProperties_Video : return "Video";
143 case Elements::Header_StreamProperties_Command : return "Command";
144 case Elements::Header_StreamProperties_JFIF : return "JFIF";
145 case Elements::Header_StreamProperties_DegradableJPEG : return "Degradable JPEG";
146 case Elements::Header_StreamProperties_FileTransfer : return "File Transfer";
147 case Elements::Header_StreamProperties_Binary : return "Binary";
148 default : return "";
149 }
150 }
151
Wm_ExclusionType(const int128u & ExclusionType)152 static const char* Wm_ExclusionType(const int128u& ExclusionType)
153 {
154 switch (ExclusionType.hi)
155 {
156 case Elements::Header_StreamProperties_Audio : return "Language";
157 case Elements::Header_StreamProperties_Video : return "Bitrate";
158 default : return "";
159 }
160 }
161
162 //***************************************************************************
163 // Format
164 //***************************************************************************
165
166 //---------------------------------------------------------------------------
167 // Element parse
168 //
Data_Parse()169 void File_Wm::Data_Parse()
170 {
171 //Parsing
172 DATA_BEGIN
173 LIST(Header)
174 ATOM_BEGIN
175 ATOM(Header_FileProperties)
176 ATOM(Header_StreamProperties)
177 LIST(Header_HeaderExtension)
178 ATOM_BEGIN
179 ATOM(Header_HeaderExtension_ExtendedStreamProperties)
180 ATOM(Header_HeaderExtension_AdvancedMutualExclusion)
181 ATOM(Header_HeaderExtension_GroupMutualExclusion)
182 ATOM(Header_HeaderExtension_StreamPrioritization)
183 ATOM(Header_HeaderExtension_BandwidthSharing)
184 ATOM(Header_HeaderExtension_LanguageList)
185 ATOM(Header_HeaderExtension_Metadata)
186 ATOM(Header_HeaderExtension_MetadataLibrary)
187 ATOM(Header_HeaderExtension_IndexParameters)
188 ATOM(Header_HeaderExtension_MediaIndexParameters)
189 ATOM(Header_HeaderExtension_TimecodeIndexParameters)
190 ATOM(Header_HeaderExtension_Compatibility)
191 ATOM(Header_HeaderExtension_AdvancedContentEncryption)
192 ATOM(Header_HeaderExtension_IndexPlaceholder)
193 ATOM(Header_Padding)
194 ATOM_END
195 ATOM(Header_CodecList)
196 ATOM(Header_ScriptCommand)
197 ATOM(Header_Marker)
198 ATOM(Header_BitRateMutualExclusion)
199 ATOM(Header_ErrorCorrection)
200 ATOM(Header_ContentDescription)
201 ATOM(Header_ExtendedContentDescription)
202 ATOM(Header_StreamBitRate)
203 ATOM(Header_ContentBranding)
204 ATOM(Header_ContentEncryption)
205 ATOM(Header_ExtendedContentEncryption)
206 ATOM(Header_DigitalSignature)
207 ATOM(Header_Padding)
208 ATOM_END
209 LIST(Data)
210 ATOM_DEFAULT_ALONE(Data_Packet)
211 LIST_SKIP(SimpleIndex)
212 LIST_SKIP(Index)
213 ATOM(MediaIndex)
214 ATOM(TimecodeIndex)
215 DATA_END
216 }
217
218 //***************************************************************************
219 // Elements
220 //***************************************************************************
221
222 //---------------------------------------------------------------------------
Header()223 void File_Wm::Header()
224 {
225 Data_Accept("Windows Media");
226 Element_Name("Header");
227
228 //Parsing
229 Skip_L4( "Number of Header Objects");
230 Skip_L1( "Alignment");
231 Skip_L1( "Architecture");
232
233 FILLING_BEGIN();
234 Fill(Stream_General, 0, General_Format, "Windows Media");
235 Header_StreamProperties_StreamOrder=0;
236 FILLING_END();
237 }
238
239 //---------------------------------------------------------------------------
Header_FileProperties()240 void File_Wm::Header_FileProperties()
241 {
242 Element_Name("File Properties");
243
244 //Parsing
245 int64u CreationDate, PlayDuration, SendDuration, Preroll;
246 int32u Flags, MaximumBitRate;
247 Skip_GUID( "File ID");
248 Skip_L8( "File Size");
249 Get_L8 (CreationDate, "Creation Date"); Param_Info1(Ztring().Date_From_Milliseconds_1601(CreationDate/10000));
250 Skip_L8( "Data Packets Count");
251 Get_L8 (PlayDuration, "Play Duration"); Param_Info_From_Milliseconds(PlayDuration/10000);
252 Get_L8 (SendDuration, "Send Duration"); Param_Info_From_Milliseconds(SendDuration/10000);
253 Get_L8 (Preroll, "Preroll"); Param_Info_From_Milliseconds(Preroll);
254 Get_L4 (Flags, "Flags");
255 Skip_Flags(Flags, 0, "Broadcast");
256 Skip_Flags(Flags, 1, "Seekable");
257 Skip_Flags(Flags, 2, "Use Packet Template");
258 Skip_Flags(Flags, 3, "Live");
259 Skip_Flags(Flags, 4, "Recordable");
260 Skip_Flags(Flags, 5, "Unknown Data Size");
261 Skip_L4( "Minimum Data Packet Size");
262 Get_L4 (MaximumDataPacketSize, "Maximum Data Packet Size");
263 Get_L4 (MaximumBitRate, "Maximum Bitrate");
264
265 //Filling
266 if (MaximumBitRate)
267 Fill(Stream_General, 0, General_OverallBitRate_Maximum, MaximumBitRate);
268 Ztring Encoded_Date_New=Ztring().Date_From_Seconds_1601(CreationDate/10000000);
269 const Ztring& Encoded_Date_Old=Retrieve_Const(Stream_General, 0, General_Encoded_Date);
270 if (Encoded_Date_Old.empty() || Encoded_Date_New!=Encoded_Date_Old)
271 Fill(Stream_General, 0, General_Encoded_Date, Encoded_Date_New);
272 if (PlayDuration/1000>Preroll)
273 Fill(Stream_General, 0, General_Duration, PlayDuration/10000-Preroll);
274 FileProperties_Preroll=(int32u)(Preroll);
275 }
276
277 //---------------------------------------------------------------------------
Header_StreamProperties()278 void File_Wm::Header_StreamProperties ()
279 {
280 Element_Name("Stream Properties");
281
282 //Parsing
283 int128u StreamType;
284 int32u StreamTypeLength, ErrorCorrectionTypeLength;
285 Get_GUID(StreamType, "StreamType"); Param_Info1(Wm_StreamType(StreamType)); Element_Info1(Wm_StreamType(StreamType));
286 Skip_GUID( "Error Correction Type");
287 Skip_L8( "Time Offset");
288 Get_L4 (StreamTypeLength, "Type-Specific Data Length");
289 Get_L4 (ErrorCorrectionTypeLength, "Error Correction Data Length");
290 Get_L2 (Stream_Number, "Stream Number");
291 if (Stream_Number&0x8000)
292 {
293 Param_Info1("Encrypted Content");
294 Stream[Stream_Number&0x007F].Info["Encryption"]=__T("Encrypted");
295 }
296 Stream_Number&=0x007F; //Only 7bits
297 Element_Info1(Stream_Number);
298 Skip_L4( "Reserved");
299 switch (StreamType.hi)
300 {
301 case Elements::Header_StreamProperties_Audio : Element_Begin0(); //size is StreamTypeLength
302 Header_StreamProperties_Audio();
303 Element_End0(); break;
304 case Elements::Header_StreamProperties_Video : Element_Begin0(); //size is StreamTypeLength
305 Header_StreamProperties_Video();
306 Element_End0(); break;
307 case Elements::Header_StreamProperties_JFIF : Element_Begin0(); //size is StreamTypeLength
308 Header_StreamProperties_JFIF();
309 Element_End0(); break;
310 case Elements::Header_StreamProperties_DegradableJPEG : Element_Begin0(); //size is StreamTypeLength
311 Header_StreamProperties_DegradableJPEG();
312 Element_End0(); break;
313 case Elements::Header_StreamProperties_FileTransfer :
314 case Elements::Header_StreamProperties_Binary : Element_Begin0(); //size is StreamTypeLength
315 Header_StreamProperties_Binary();
316 StreamKind_Last=Stream_Max; StreamPos_Last=(size_t)-1;
317 Element_End0(); break;
318 default : if (StreamTypeLength>0)
319 Skip_XX(StreamTypeLength, "Type-Specific Data");
320 StreamKind_Last=Stream_Max; StreamPos_Last=(size_t)-1;
321 }
322 if (ErrorCorrectionTypeLength)
323 Skip_XX(ErrorCorrectionTypeLength, "Error Correction Data");
324
325 //Filling
326 stream& StreamItem = Stream[Stream_Number];
327 StreamItem.StreamKind=StreamKind_Last;
328 StreamItem.StreamPos=StreamPos_Last;
329 StreamItem.Info["ID"].From_Number(Stream_Number);
330 StreamItem.Info["StreamOrder"].From_Number(Header_StreamProperties_StreamOrder);
331 Header_StreamProperties_StreamOrder++;
332 }
333
334 //---------------------------------------------------------------------------
Header_StreamProperties_Audio()335 void File_Wm::Header_StreamProperties_Audio ()
336 {
337 Element_Name("Audio");
338
339 //Parsing
340 int32u SamplingRate, BytesPerSec;
341 int16u CodecID, Channels, Data_Size, Resolution;
342 Get_L2 (CodecID, "Codec ID");
343 Get_L2 (Channels, "Number of Channels");
344 Get_L4 (SamplingRate, "Samples Per Second");
345 Get_L4 (BytesPerSec, "Average Number of Bytes Per Second");
346 Skip_L2( "Block Alignment");
347 Get_L2 (Resolution, "Bits / Sample");
348 Get_L2 (Data_Size, "Codec Specific Data Size");
349
350 //Filling
351 Stream_Prepare(Stream_Audio);
352 Stream[Stream_Number].IsCreated=true;
353 Ztring Codec; Codec.From_Number(CodecID, 16);
354 Codec.MakeUpperCase();
355 CodecID_Fill(Codec, Stream_Audio, StreamPos_Last, InfoCodecID_Format_Riff);
356 Fill(Stream_Audio, StreamPos_Last, Audio_Codec, Codec); //May be replaced by codec parser
357 Fill(Stream_Audio, StreamPos_Last, Audio_Codec_CC, Codec);
358 if (Channels)
359 Fill(Stream_Audio, StreamPos_Last, Audio_Channel_s_, Channels);
360 if (SamplingRate)
361 Fill(Stream_Audio, StreamPos_Last, Audio_SamplingRate, SamplingRate);
362 if (BytesPerSec)
363 Fill(Stream_Audio, StreamPos_Last, Audio_BitRate, BytesPerSec*8);
364 if (Resolution)
365 Fill(Stream_Audio, StreamPos_Last, Audio_BitDepth, Resolution);
366
367 FILLING_BEGIN();
368 //Creating the parser
369 if (0);
370 #if defined(MEDIAINFO_MPEGA_YES)
371 else if (MediaInfoLib::Config.CodecID_Get(Stream_Audio, InfoCodecID_Format_Riff, Ztring::ToZtring(CodecID, 16))==__T("MPEG Audio"))
372 {
373 stream& StreamItem = Stream[Stream_Number];
374 File_Mpega* Parser = new File_Mpega;
375 StreamItem.Parser= Parser;
376 Parser->Frame_Count_Valid=8;
377 StreamItem.Parser->ShouldContinueParsing=true;
378 }
379 #endif
380 Open_Buffer_Init(Stream[Stream_Number].Parser);
381 FILLING_END();
382
383 //Parsing
384 if (Data_Size>0)
385 {
386 Element_Begin1("Codec Specific Data");
387 switch (CodecID)
388 {
389 case 0x0161 :
390 case 0x0162 :
391 case 0x0163 : Header_StreamProperties_Audio_WMA(); break;
392 case 0x7A21 :
393 case 0x7A22 : Header_StreamProperties_Audio_AMR(); break;
394 default : Skip_XX(Data_Size, "Unknown");
395 }
396 Element_End0();
397 }
398 }
399
400 //---------------------------------------------------------------------------
Header_StreamProperties_Audio_WMA()401 void File_Wm::Header_StreamProperties_Audio_WMA ()
402 {
403 Element_Info1("WMA");
404
405 //Demux
406 #if MEDIAINFO_DEMUX
407 switch (Config->Demux_InitData_Get())
408 {
409 case 0 : //In demux event
410 Demux_Level=2; //Container
411 Demux(Buffer+Buffer_Offset, (size_t)Element_Size, ContentType_Header);
412 break;
413 case 1 : //In field
414 {
415 std::string Data_Raw((const char*)(Buffer+Buffer_Offset+Element_Offset), (size_t)10);//Element_Size-(Element_Offset));
416 std::string Data_Base64(Base64::encode(Data_Raw));
417 Fill(Stream_Audio, StreamPos_Last, "Demux_InitBytes", Data_Base64);
418 Fill_SetOptions(Stream_Audio, StreamPos_Last, "Demux_InitBytes", "N NT");
419 }
420 break;
421 default : ;
422 }
423 #endif //MEDIAINFO_DEMUX
424
425 //Parsing
426 Skip_L4( "SamplesPerBlock");
427 Skip_L2( "EncodeOptions");
428 Skip_L4( "SuperBlockAlign");
429 }
430
431 //---------------------------------------------------------------------------
Header_StreamProperties_Audio_AMR()432 void File_Wm::Header_StreamProperties_Audio_AMR ()
433 {
434 Element_Info1("AMR");
435
436 //Parsing
437 int32u Flags;
438 bool VBR;
439 Get_L4 (Flags, "Flags");
440 Skip_Flags(Flags, 0, "SID is used");
441 Get_Flags (Flags, 1, VBR, "Varying bitrate");
442
443 //Filling
444 Fill(Stream_Audio, StreamPos_Last, Audio_BitRate_Mode, VBR?"VBR":"CBR");
445 }
446
447 //---------------------------------------------------------------------------
Header_StreamProperties_Video()448 void File_Wm::Header_StreamProperties_Video ()
449 {
450 Element_Name("Video");
451
452 //Parsing
453 int32u Width, Height, Compression;
454 int16u Data_Size, Resolution;
455 Get_L4 (Width, "Width");
456 Get_L4 (Height, "Height");
457 Skip_L1( "Flags");
458 Get_L2 (Data_Size, "Format Data Size");
459 Skip_L4( "Size");
460 Get_L4 (Width, "Width");
461 Get_L4 (Height, "Height");
462 Skip_L2( "Planes");
463 Get_L2 (Resolution, "BitCount");
464 Get_C4 (Compression, "Compression");
465 Skip_L4( "SizeImage");
466 Skip_L4( "XPelsPerMeter");
467 Skip_L4( "YPelsPerMeter");
468 Skip_L4( "ClrUsed");
469 Skip_L4( "ClrImportant");
470
471 //Filling
472 Stream_Prepare(Stream_Video);
473 Stream[Stream_Number].IsCreated=true;
474 CodecID_Fill(Ztring().From_CC4(Compression), Stream_Video, StreamPos_Last, InfoCodecID_Format_Riff);
475 Fill(Stream_Video, StreamPos_Last, Video_Codec, Ztring().From_CC4(Compression)); //May be replaced by codec parser
476 Fill(Stream_Video, StreamPos_Last, Video_Codec_CC, Ztring().From_CC4(Compression));
477 Fill(Stream_Video, StreamPos_Last, Video_Width, Width);
478 Fill(Stream_Video, StreamPos_Last, Video_Height, Height);
479 if (Resolution>0)
480 Fill(Stream_Video, StreamPos_Last, Video_BitDepth, (Resolution%3)?Resolution:(Resolution/3)); //If not a multiple of 3, the total resolution is filled
481 if (Compression==CC4("DVR "))
482 IsDvrMs=true;
483
484 //From Content description (we imagine that data is for all video streams...)
485 if (Header_ExtendedContentDescription_AspectRatioX && Header_ExtendedContentDescription_AspectRatioY)
486 {
487 if (Header_ExtendedContentDescription_AspectRatioX==16 && Header_ExtendedContentDescription_AspectRatioY==9)
488 Fill(Stream_Video, StreamPos_Last, Video_DisplayAspectRatio, ((float32)16)/9, 3);
489 else if (Header_ExtendedContentDescription_AspectRatioX==4 && Header_ExtendedContentDescription_AspectRatioY==3)
490 Fill(Stream_Video, StreamPos_Last, Video_DisplayAspectRatio, ((float32)4)/3, 3);
491 else
492 Fill(Stream_Video, StreamPos_Last, Video_PixelAspectRatio, ((float32)Header_ExtendedContentDescription_AspectRatioX)/Header_ExtendedContentDescription_AspectRatioY, 3, true);
493 }
494
495 //Creating the parser
496 if (0);
497 #if defined(MEDIAINFO_VC1_YES)
498 else if (MediaInfoLib::Config.CodecID_Get(Stream_Video, InfoCodecID_Format_Riff, Ztring().From_CC4(Compression), InfoCodecID_Format)==__T("VC-1"))
499 {
500 stream& StreamItem = Stream[Stream_Number];
501 File_Vc1* Parser = new File_Vc1;
502 StreamItem.Parser= Parser;
503 if (Compression==CC4("WMV3"))
504 {
505 Parser->From_WMV3=true;
506 Parser->MustSynchronize=false;
507 }
508 Parser->FrameIsAlwaysComplete=true; //Warning: this is not always the case, see data parsing
509 Open_Buffer_Init(StreamItem.Parser);
510 if (Data_Size>40)
511 {
512
513 //Demux
514 #if MEDIAINFO_DEMUX
515 switch (Config->Demux_InitData_Get())
516 {
517 case 0 : //In demux event
518 Element_Code=Stream_Number;
519 Demux_Level=2; //Container
520 Demux(Buffer+(size_t)Element_Offset, (size_t)(Data_Size-40), ContentType_Header);
521 break;
522 case 1 : //In field
523 {
524 std::string Data_Raw((const char*)(Buffer+(size_t)Element_Offset), (size_t)(Data_Size-40));
525 std::string Data_Base64(Base64::encode(Data_Raw));
526 Fill(Stream_Video, StreamPos_Last, "Demux_InitBytes", Data_Base64);
527 Fill_SetOptions(Stream_Video, StreamPos_Last, "Demux_InitBytes", "N NT");
528 }
529 break;
530 default : ;
531 }
532 #endif //MEDIAINFO_DEMUX
533 stream& StreamItem = Stream[Stream_Number];
534 Open_Buffer_Continue(StreamItem.Parser, (size_t)(Data_Size-40));
535 if (StreamItem.Parser->Status[IsFinished])
536 {
537 Finish(StreamItem.Parser);
538 Merge(*StreamItem.Parser, Stream_Video, 0, StreamPos_Last);
539 delete StreamItem.Parser; StreamItem.Parser=NULL;
540 }
541 else
542 {
543 ((File_Vc1*)StreamItem.Parser)->Only_0D=true;
544 ((File_Vc1*)StreamItem.Parser)->MustSynchronize=false;
545 }
546 }
547 }
548 #endif
549 #if defined(MEDIAINFO_MPEGV_YES)
550 else if (MediaInfoLib::Config.Codec_Get(Ztring().From_CC4(Compression), InfoCodec_KindofCodec).find(__T("MPEG-2"))==0)
551 {
552 stream& StreamItem = Stream[Stream_Number];
553 File_Mpegv* Parser = new File_Mpegv;
554 StreamItem.Parser = Parser;
555 Parser->Frame_Count_Valid=30; //For searching Pulldown
556 Open_Buffer_Init(StreamItem.Parser);
557 }
558 #endif
559 else if (Data_Size>40) //TODO: see "The Mummy_e"
560 Skip_XX(Data_Size-40, "Codec Specific Data");
561 }
562
563 //---------------------------------------------------------------------------
Header_StreamProperties_JFIF()564 void File_Wm::Header_StreamProperties_JFIF ()
565 {
566 Element_Name("JFIF");
567
568 //Parsing
569 int32u Width, Height;
570 Get_L4 (Width, "Width");
571 Get_L4 (Height, "Height");
572 Skip_L4( "Reserved");
573
574 //Filling
575 Stream_Prepare(Stream_Image);
576 Fill(Stream_Video, StreamPos_Last, Video_Format, "JPEG");
577 Fill(Stream_Video, StreamPos_Last, Video_Codec, "JPEG");
578 Fill(Stream_Video, StreamPos_Last, Video_Width, Width);
579 Fill(Stream_Video, StreamPos_Last, Video_Height, Height);
580 }
581
582 //---------------------------------------------------------------------------
Header_StreamProperties_DegradableJPEG()583 void File_Wm::Header_StreamProperties_DegradableJPEG ()
584 {
585 Element_Name("Degradable JPEG");
586
587 int32u Width, Height;
588 int16u InterchangeDataLength;
589 Get_L4 (Width, "Width");
590 Get_L4 (Height, "Height");
591 Skip_L2( "Reserved");
592 Skip_L2( "Reserved");
593 Skip_L2( "Reserved");
594 Get_L2 (InterchangeDataLength, "Interchange data length");
595 if (InterchangeDataLength>0)
596 Skip_XX(InterchangeDataLength, "Interchange data");
597 else
598 Skip_L1( "Zero");
599
600 //Filling
601 Stream_Prepare(Stream_Image);
602 Fill(Stream_Video, StreamPos_Last, Video_Format, "JPEG");
603 Fill(Stream_Video, StreamPos_Last, Video_Codec, "JPEG");
604 Fill(Stream_Video, StreamPos_Last, Video_Width, Width);
605 Fill(Stream_Video, StreamPos_Last, Video_Height, Height);
606 }
607
608 //---------------------------------------------------------------------------
Header_StreamProperties_Binary()609 void File_Wm::Header_StreamProperties_Binary ()
610 {
611 Element_Name("Binary");
612
613 //Parsing
614 int32u FormatDataLength;
615 Skip_GUID( "Major media type");
616 Skip_GUID( "Media subtype");
617 Skip_L4( "Fixed-size samples");
618 Skip_L4( "Temporal compression");
619 Skip_L4( "Sample size");
620 Skip_GUID( "Format type");
621 Get_L4 (FormatDataLength, "Format data size");
622 if (FormatDataLength>0)
623 Skip_XX(FormatDataLength, "Format data");
624 }
625
626 //---------------------------------------------------------------------------
Header_HeaderExtension()627 void File_Wm::Header_HeaderExtension()
628 {
629 Element_Name("Header Extension");
630
631 //Parsing
632 int32u Size;
633 Skip_GUID( "ClockType");
634 Skip_L2( "ClockSize");
635 Get_L4 (Size, "Extension Data Size");
636 }
637
638 //---------------------------------------------------------------------------
Header_HeaderExtension_ExtendedStreamProperties()639 void File_Wm::Header_HeaderExtension_ExtendedStreamProperties()
640 {
641 Element_Name("Extended Stream Properties");
642
643 //Parsing
644 int64u AverageTimePerFrame;
645 int32u DataBitrate, Flags;
646 int16u StreamNumber, LanguageID, StreamNameCount, PayloadExtensionSystemCount;
647 Info_L8(StartTime, "Start Time"); Param_Info_From_Milliseconds(StartTime);
648 Info_L8(EndTime, "End Time"); Param_Info_From_Milliseconds(EndTime);
649 Get_L4 (DataBitrate, "Data Bitrate");
650 Skip_L4( "Buffer Size");
651 Skip_L4( "Initial Buffer Fullness");
652 Skip_L4( "Alternate Data Bitrate");
653 Skip_L4( "Alternate Buffer Size");
654 Skip_L4( "Alternate Initial Buffer Fullness");
655 Skip_L4( "Maximum Object Size");
656 Get_L4 (Flags, "Flags");
657 Skip_Flags(Flags, 0, "Reliable");
658 Skip_Flags(Flags, 1, "Seekable");
659 Skip_Flags(Flags, 2, "No Cleanpoints");
660 Skip_Flags(Flags, 3, "Resend Live Cleanpoints");
661 Get_L2 (StreamNumber, "Stream Number"); Element_Info1(StreamNumber);
662 Get_L2 (LanguageID, "Stream Language ID Index");
663 Get_L8 (AverageTimePerFrame, "Average Time Per Frame");
664 Get_L2 (StreamNameCount, "Stream Name Count");
665 Get_L2 (PayloadExtensionSystemCount, "Payload Extension System Count");
666 for (int16u Pos=0; Pos<StreamNameCount; Pos++)
667 {
668 Element_Begin1("Stream Name");
669 int16u StreamNameLength;
670 Skip_L2( "Language ID Index");
671 Get_L2 (StreamNameLength, "Stream Name Length");
672 Skip_UTF16L(StreamNameLength, "Stream Name");
673 Element_End0();
674 }
675 for (int16u Pos=0; Pos<PayloadExtensionSystemCount; Pos++)
676 {
677 Element_Begin1("Payload Extension System");
678 stream::payload_extension_system Payload_Extension_System;
679 int32u ExtensionSystemInfoLength;
680 Get_GUID(Payload_Extension_System.ID, "Extension System ID");
681 Get_L2 (Payload_Extension_System.Size, "Extension Data Size");
682 Get_L4 (ExtensionSystemInfoLength, "Extension System Info Length");
683 if (ExtensionSystemInfoLength>0)
684 Skip_XX(ExtensionSystemInfoLength, "Extension System Info");
685 Element_End0();
686
687 //Filling
688 Stream[StreamNumber].Payload_Extension_Systems.push_back(Payload_Extension_System);
689 }
690
691 //Header_StreamProperties
692 if (Element_Offset<Element_Size)
693 {
694 //This could be everything, but in theory this is only Header_StreamProperties
695 int128u Name;
696 int64u Size;
697 Element_Begin1("Stream Properties Object");
698 Element_Begin1("Header");
699 Get_GUID(Name, "Name");
700 Get_L8 (Size, "Size");
701 Element_End0();
702 if (Size>=24 && Element_Offset+Size-24==Element_Size)
703 {
704 switch (Name.hi)
705 {
706 case Elements::Header_StreamProperties : Header_StreamProperties(); break;
707 default : Skip_XX(Size-24, "Unknown");
708 }
709 }
710 else
711 Skip_XX(Element_Size-Element_Offset, "Problem");
712 Element_End0();
713 }
714
715 //Filling
716 stream& StreamItem = Stream[StreamNumber];
717 StreamItem.LanguageID=LanguageID;
718 StreamItem.AverageBitRate=DataBitrate;
719 StreamItem.AverageTimePerFrame=AverageTimePerFrame;
720 }
721
722 //---------------------------------------------------------------------------
Header_HeaderExtension_AdvancedMutualExclusion()723 void File_Wm::Header_HeaderExtension_AdvancedMutualExclusion()
724 {
725 Element_Name("Advanced Mutual Exclusion");
726
727 //Parsing
728 int16u Count;
729 Info_GUID(ExclusionType, "Exclusion Type"); Param_Info1(Wm_ExclusionType(ExclusionType));
730 Get_L2 (Count, "Stream Numbers Count");
731 for (int16u Pos=0; Pos<Count; Pos++)
732 {
733 Info_L2(StreamNumber, "Stream Number"); Element_Info1(StreamNumber);
734 }
735 }
736
737 //---------------------------------------------------------------------------
Header_HeaderExtension_GroupMutualExclusion()738 void File_Wm::Header_HeaderExtension_GroupMutualExclusion()
739 {
740 Element_Name("Group Mutual Exclusion");
741
742 //Parsing
743 Skip_XX(Element_Size, "Unknown");
744 }
745
746 //---------------------------------------------------------------------------
Header_HeaderExtension_StreamPrioritization()747 void File_Wm::Header_HeaderExtension_StreamPrioritization()
748 {
749 Element_Name("Stream Prioritization");
750
751 //Parsing
752 int16u Count;
753 Get_L2 (Count, "Stream Numbers Count");
754 for (int16u Pos=0; Pos<Count; Pos++)
755 {
756 int16u Flags;
757 Element_Begin1("Stream");
758 Info_L2(StreamNumber, "Stream Number"); Element_Info1(StreamNumber);
759 Get_L2 (Flags, "Flags");
760 Skip_Flags(Flags, 0, "Mandatory");
761 Element_End0();
762 }
763 }
764
765 //---------------------------------------------------------------------------
Header_HeaderExtension_BandwidthSharing()766 void File_Wm::Header_HeaderExtension_BandwidthSharing()
767 {
768 Element_Name("Bandwidth Sharing");
769
770 //Parsing
771 Skip_XX(Element_Size, "Unknown");
772 }
773
774 //---------------------------------------------------------------------------
Header_HeaderExtension_LanguageList()775 void File_Wm::Header_HeaderExtension_LanguageList()
776 {
777 Element_Name("Language List");
778
779 //Parsing
780 Ztring LanguageID;
781 int16u Count;
782 int8u LanguageID_Length;
783 Get_L2 (Count, "Count");
784 for (int16u Pos=0; Pos<Count; Pos++)
785 {
786 Element_Begin1("Language ID");
787 Get_L1 (LanguageID_Length, "Language ID Length");
788 if (LanguageID_Length>0)
789 {
790 Get_UTF16L(LanguageID_Length, LanguageID, "Language ID");
791 Element_Info1(LanguageID);
792 }
793 Element_End0();
794
795 //Filling
796 Languages.push_back(LanguageID);
797 }
798 }
799
800 //---------------------------------------------------------------------------
Header_HeaderExtension_MetadataLibrary()801 void File_Wm::Header_HeaderExtension_MetadataLibrary()
802 {
803 Element_Name("Metadata Library");
804 }
805
806 //---------------------------------------------------------------------------
Header_HeaderExtension_Metadata()807 void File_Wm::Header_HeaderExtension_Metadata()
808 {
809 Element_Name("Metadata");
810
811 //Parsing
812 float32 AspectRatioX=0, AspectRatioY=0;
813 int16u Count;
814 Get_L2 (Count, "Description Records Count");
815 for (int16u Pos=0; Pos<Count; Pos++)
816 {
817 Element_Begin1("Description Record");
818 Ztring Name, Data;
819 int64u Data_Int64=0;
820 int32u Data_Length;
821 int16u StreamNumber, Name_Length, Data_Type;
822 Skip_L2( "Reserved");
823 Get_L2 (StreamNumber, "Stream Number");
824 Get_L2 (Name_Length, "Name Length");
825 Get_L2 (Data_Type, "Data Type");
826 Get_L4 (Data_Length, "Data Length");
827 Get_UTF16L(Name_Length, Name, "Name Length");
828 switch (Data_Type)
829 {
830 case 0x00 : Get_UTF16L(Data_Length, Data, "Data"); break;
831 case 0x01 : Skip_XX(Data_Length, "Data"); Data=__T("(Binary)"); break;
832 case 0x02 : {int16u Data_Int; Get_L2 (Data_Int, "Data"); Data=(Data_Int==0)?__T("No"):__T("Yes"); Data_Int64=Data_Int;} break;
833 case 0x03 : {int32u Data_Int; Get_L4 (Data_Int, "Data"); Data.From_Number(Data_Int); Data_Int64=Data_Int;} break;
834 case 0x04 : {int64u Data_Int; Get_L8 (Data_Int, "Data"); Data.From_Number(Data_Int); Data_Int64=Data_Int;} break;
835 case 0x05 : {int16u Data_Int; Get_L2 (Data_Int, "Data"); Data.From_Number(Data_Int); Data_Int64=Data_Int;} break;
836 default : Skip_XX(Data_Length, "Data"); Data=__T("(Unknown)"); break;
837 }
838 Element_Info1(Name);
839 Element_Info1(Data);
840 Element_End0();
841
842 if (Name==__T("IsVBR"))
843 Stream[StreamNumber].Info["BitRate_Mode"]=(Data_Int64==0)?"CBR":"VBR";
844 else if (Name==__T("AspectRatioX"))
845 {
846 AspectRatioX=Data.To_float32();
847 if (AspectRatioX && AspectRatioY)
848 Stream[StreamNumber].Info["PixelAspectRatio"].From_Number(AspectRatioX/AspectRatioY, 3);
849 }
850 else if (Name==__T("AspectRatioY"))
851 {
852 AspectRatioY=Data.To_float32();
853 if (AspectRatioX && AspectRatioY)
854 Stream[StreamNumber].Info["PixelAspectRatio"].From_Number(AspectRatioX/AspectRatioY, 3);
855 }
856 else if (Name==__T("DeviceConformanceTemplate"))
857 {
858 if (Data!=__T("@") && Data.find(__T('@'))!=std::string::npos)
859 Stream[StreamNumber].Info["Format_Profile"]=Data;
860 }
861 else if (Name==__T("WM/WMADRCPeakReference")) {}
862 else if (Name==__T("WM/WMADRCAverageReference")) {}
863 else if (Name==__T("WM/WMADRCAverageTarget")) {}
864 else if (Name==__T("WM/WMADRCPeakTarget")) {}
865 else
866 Stream[StreamNumber].Info[Name.To_Local()]=Data;
867 }
868 }
869
870 //---------------------------------------------------------------------------
Header_HeaderExtension_IndexParameters()871 void File_Wm::Header_HeaderExtension_IndexParameters()
872 {
873 Element_Name("Index Parameters");
874
875 //Parsing
876 int16u Count;
877 Skip_L4( "Index Entry Time Interval");
878 Get_L2 (Count, "Index Specifiers Count");
879 for (int16u Pos=0; Pos<Count; Pos++)
880 {
881 Element_Begin1("Index Specifier");
882 int16u IndexType;
883 Skip_L2( "Stream Number");
884 Get_L2 (IndexType, "Index Type");
885 Element_Info1(IndexType);
886 Element_End0();
887 }
888 }
889
890 //---------------------------------------------------------------------------
Header_HeaderExtension_MediaIndexParameters()891 void File_Wm::Header_HeaderExtension_MediaIndexParameters()
892 {
893 Header_HeaderExtension_IndexParameters();
894
895 Element_Name("MediaIndex Parameters");
896 }
897
898 //---------------------------------------------------------------------------
Header_HeaderExtension_TimecodeIndexParameters()899 void File_Wm::Header_HeaderExtension_TimecodeIndexParameters()
900 {
901 Header_HeaderExtension_IndexParameters();
902
903 Element_Name("Timecode Index Parameters");
904 }
905
906 //---------------------------------------------------------------------------
Header_HeaderExtension_Compatibility()907 void File_Wm::Header_HeaderExtension_Compatibility()
908 {
909 Element_Name("Compatibility");
910
911 //Parsing
912 Skip_L1( "Profile");
913 Skip_L1( "Mode");
914 }
915
916 //---------------------------------------------------------------------------
Header_HeaderExtension_AdvancedContentEncryption()917 void File_Wm::Header_HeaderExtension_AdvancedContentEncryption()
918 {
919 Element_Name("Advanced Content Encryption");
920 }
921
922 //---------------------------------------------------------------------------
Header_HeaderExtension_IndexPlaceholder()923 void File_Wm::Header_HeaderExtension_IndexPlaceholder()
924 {
925 Element_Name("Index Placeholder");
926 }
927
928 //---------------------------------------------------------------------------
Header_CodecList()929 void File_Wm::Header_CodecList()
930 {
931 Element_Name("Codec List");
932
933 //Parsing
934 Ztring CodecName, CodecDescription;
935 int32u Count32;
936 int16u Count, Type, CodecNameLength, CodecDescriptionLength, CodecInformationLength;
937 Skip_GUID( "Reserved");
938 Get_L4 (Count32, "Codec Entries Count");
939 Count=(int16u)Count32;
940 CodecInfos.resize(Count);
941 for (int16u Pos=0; Pos<Count; Pos++)
942 {
943 Element_Begin1("Codec Entry");
944 Get_L2 (Type, "Type"); Param_Info1(Wm_CodecList_Kind(Type));
945 Get_L2 (CodecNameLength, "Codec Name Length");
946 Get_UTF16L(CodecNameLength*2, CodecName, "Codec Name");
947 Get_L2 (CodecDescriptionLength, "Codec Description Length");
948 Get_UTF16L(CodecDescriptionLength*2, CodecDescription, "Codec Description");
949 Get_L2 (CodecInformationLength, "Codec Information Length");
950 if (Type==2 && CodecInformationLength==2) //Audio and 2CC
951 Skip_L2( "2CC"); //Not used, we have it elsewhere
952 else if (Type==1 && CodecInformationLength==4) //Video and 4CC
953 Skip_C4( "4CC"); //Not used, we have it elsewhere
954 else
955 Skip_XX(CodecInformationLength, "Codec Information");
956 Element_End0();
957
958 FILLING_BEGIN();
959 CodecInfos[Pos].Type=Type;
960 CodecInfos[Pos].Info=CodecName;
961 if (!CodecDescription.empty())
962 {
963 CodecInfos[Pos].Info+=__T(" - ");
964 CodecInfos[Pos].Info+=CodecDescription;
965 }
966
967 Codec_Description_Count++;
968 FILLING_END();
969 }
970 }
971
972 //---------------------------------------------------------------------------
Header_ScriptCommand()973 void File_Wm::Header_ScriptCommand()
974 {
975 Element_Name("Script Command");
976
977 //Parsing
978 Skip_GUID( "Reserved");
979 int16u Commands_Count, CommandTypes_Count;
980 Get_L2 (Commands_Count, "Commands Count");
981 Get_L2 (CommandTypes_Count, "Command Types Count");
982 for (int16u Pos=0; Pos<CommandTypes_Count; Pos++)
983 {
984 Element_Begin1("Command Type");
985 int16u Length;
986 Get_L2 (Length, "Command Type Length");
987 if (Length>0)
988 Skip_UTF16L(Length*2, "Command Type");
989 Element_End0();
990 }
991 for (int16u Pos=0; Pos<Commands_Count; Pos++)
992 {
993 Element_Begin1("Command");
994 int16u Length;
995 Skip_L2( "Type Index");
996 Get_L2 (Length, "Command Length");
997 if (Length>0)
998 Skip_UTF16L(Length*2, "Command");
999 Element_End0();
1000 }
1001 }
1002
1003 //---------------------------------------------------------------------------
Header_Marker()1004 void File_Wm::Header_Marker()
1005 {
1006 Element_Name("Markers");
1007
1008 //Parsing
1009 Skip_GUID( "Reserved");
1010 int32u Markers_Count;
1011 int16u Name_Length;
1012 Get_L4 (Markers_Count, "Markers Count");
1013 Skip_L2( "Reserved");
1014 Get_L2 (Name_Length, "Name Length");
1015 if (Name_Length>0)
1016 Skip_UTF16L(Name_Length, "Name");
1017
1018 //Filling
1019 if (Markers_Count>0)
1020 Stream_Prepare(Stream_Menu);
1021
1022 //Parsing
1023 for (int32u Pos=0; Pos<Markers_Count; Pos++)
1024 {
1025 Element_Begin1("Marker");
1026 Ztring Marker;
1027 int32u Marker_Length;
1028 Skip_L8( "Offset");
1029 Info_L8(PresentationTime, "Presentation Time"); Param_Info_From_Milliseconds(PresentationTime/10000);
1030 Skip_L2( "Entry Length");
1031 Info_L4(SendTime, "Send Time"); Param_Info_From_Milliseconds(SendTime);
1032 Skip_L4( "Flags");
1033 Get_L4 (Marker_Length, "Marker Description Length");
1034 if (Marker_Length>0)
1035 Get_UTF16L(Marker_Length*2, Marker, "Marker Description");
1036 Element_End0();
1037 }
1038 }
1039
1040 //---------------------------------------------------------------------------
Header_BitRateMutualExclusion()1041 void File_Wm::Header_BitRateMutualExclusion()
1042 {
1043 Element_Name("BitRate Mutual Exclusion");
1044
1045 //Parsing
1046 int16u Count;
1047 Skip_GUID( "Exclusion Type");
1048 Get_L2 (Count, "Stream Numbers Count");
1049 for (int16u Pos=0; Pos<Count; Pos++)
1050 Skip_L2( "Stream Number");
1051 }
1052
1053 //---------------------------------------------------------------------------
Header_ErrorCorrection()1054 void File_Wm::Header_ErrorCorrection()
1055 {
1056 Element_Name("Error Correction");
1057 }
1058
1059 //---------------------------------------------------------------------------
Header_ContentDescription()1060 void File_Wm::Header_ContentDescription()
1061 {
1062 Element_Name("Content Description");
1063
1064 //Parsing
1065 Ztring Title, Author, Copyright, Description, Rating;
1066 int16u TitleLength, AuthorLength, CopyrightLength, DescriptionLength, RatingLength;
1067 Get_L2 (TitleLength, "TitleLength");
1068 Get_L2 (AuthorLength, "AuthorLength");
1069 Get_L2 (CopyrightLength, "CopyrightLength");
1070 Get_L2 (DescriptionLength, "DescriptionLength");
1071 Get_L2 (RatingLength, "RatingLength");
1072 if (TitleLength>0)
1073 Get_UTF16L(TitleLength, Title, "Title");
1074 if (AuthorLength>0)
1075 Get_UTF16L(AuthorLength, Author, "Author");
1076 if (CopyrightLength>0)
1077 Get_UTF16L(CopyrightLength, Copyright, "Copyright");
1078 if (DescriptionLength>0)
1079 Get_UTF16L(DescriptionLength, Description, "Description");
1080 if (RatingLength>0)
1081 Get_UTF16L(RatingLength, Rating, "Rating");
1082
1083 //Filling
1084 Fill(Stream_General, 0, General_Title, Title);
1085 Fill(Stream_General, 0, General_Performer, Author);
1086 Fill(Stream_General, 0, General_Copyright, Copyright);
1087 Fill(Stream_General, 0, General_Comment, Description);
1088 Fill(Stream_General, 0, General_Rating, Rating);
1089 }
1090
1091 //---------------------------------------------------------------------------
Header_ExtendedContentDescription()1092 void File_Wm::Header_ExtendedContentDescription()
1093 {
1094 Element_Name("Extended Content Description");
1095
1096 //Parsing
1097 int16u Count;
1098 Get_L2 (Count, "Content Descriptors Count");
1099 for (int16u Pos=0; Pos<Count; Pos++)
1100 {
1101 Element_Begin1("Content Descriptor");
1102 Ztring Name, Value;
1103 int64u Value_Int64=0;
1104 int16u Name_Length, Value_Type, Value_Length;
1105 Get_L2 (Name_Length, "Name Length");
1106 Get_UTF16L(Name_Length, Name, "Name");
1107 Get_L2 (Value_Type, "Value Data Type");
1108 Get_L2 (Value_Length, "Value Length");
1109 switch (Value_Type)
1110 {
1111 case 0x00 : Get_UTF16L(Value_Length, Value, "Value"); break;
1112 case 0x01 :
1113 if (Name==__T("ASFLeakyBucketPairs")) Header_ExtendedContentDescription_ASFLeakyBucketPairs(Value_Length);
1114 else {Skip_XX(Value_Length, "Value"); Value=__T("(Binary)");} break;
1115 case 0x02 : {int32u Value_Int; Get_L4 (Value_Int, "Value"); Value=(Value_Int==0)?__T("No"):__T("Yes"); Value_Int64=Value_Int;} break;
1116 case 0x03 : {int32u Value_Int; Get_L4 (Value_Int, "Value"); Value.From_Number(Value_Int); Value_Int64=Value_Int;} break;
1117 case 0x04 : {int64u Value_Int; Get_L8 (Value_Int, "Value"); Value.From_Number(Value_Int); Value_Int64=Value_Int;} break;
1118 case 0x05 : {int16u Value_Int; Get_L2 (Value_Int, "Value"); Value.From_Number(Value_Int); Value_Int64=Value_Int;} break;
1119 default : Skip_XX(Value_Length, "Value"); Value=__T("(Unknown)"); break;
1120 }
1121 Element_Info1(Name);
1122 Element_Info1(Value);
1123 Element_End0();
1124
1125 //Filling
1126 if (!Value.empty())
1127 {
1128 if (Name==__T("Agility FPS")) {}
1129 else if (Name==__T("ASFLeakyBucketPairs")) {} //Already done elsewhere
1130 else if (Name==__T("AspectRatioX")) Header_ExtendedContentDescription_AspectRatioX=Value_Int64;
1131 else if (Name==__T("AspectRatioY")) Header_ExtendedContentDescription_AspectRatioY=Value_Int64;
1132 else if (Name==__T("Buffer Average")) {}
1133 else if (Name==__T("DVR Index Granularity")) {}
1134 else if (Name==__T("DVR File Version")) {}
1135 else if (Name==__T("IsVBR"))
1136 Fill(Stream_General, 0, General_OverallBitRate_Mode, Value_Int64==0?"CBR":"VBR");
1137 else if (Name==__T("VBR Peak")) {} //Already in "Stream Bitrate" chunk
1138 else if (Name==__T("WMFSDKVersion")) {}
1139 else if (Name==__T("WMFSDKNeeded")) {}
1140 else if (Name==__T("WM/AlbumTitle"))
1141 Fill(Stream_General, 0, General_Album, Value);
1142 else if (Name==__T("WM/AlbumArtist"))
1143 {
1144 const Ztring& Previous=Retrieve(Stream_General, 0, General_Performer);
1145 if (!Previous.empty() && Previous != Value)
1146 Fill(Stream_General, 0, General_Accompaniment, Previous); // Microsoft "Contributing artists"
1147 Fill(Stream_General, 0, General_Performer, Value, true);
1148 }
1149 else if (Name==__T("WM/ArtistSortOrder"))
1150 Fill(Stream_General, 0, General_Performer_Sort, Value);
1151 else if (Name==__T("WM/AuthorURL"))
1152 Fill(Stream_General, 0, "Author/Url", Value);
1153 else if (Name==__T("WM/BeatsPerMinute"))
1154 Fill(Stream_General, 0, General_BPM, Value);
1155 else if (Name==__T("WM/Binary"))
1156 Fill(Stream_General, 0, General_Cover, "Y");
1157 else if (Name==__T("WM/Comments"))
1158 Fill(Stream_General, 0, General_Comment, Value, true); //Clear last value
1159 else if (Name==__T("WM/Composer"))
1160 Fill(Stream_General, 0, General_Composer, Value);
1161 else if (Name==__T("WM/Conductor"))
1162 Fill(Stream_General, 0, General_Conductor, Value);
1163 else if (Name==__T("WM/EncodedBy"))
1164 Fill(Stream_General, 0, General_EncodedBy, Value);
1165 else if (Name==__T("WM/EncoderSettings"))
1166 Fill(Stream_General, 0, General_Encoded_Library_Settings, Value);
1167 else if (Name==__T("WM/EncodingTime"))
1168 {
1169 Ztring Encoded_Date_New=Ztring().Date_From_Seconds_1601(Value_Int64/10000000);
1170 const Ztring& Encoded_Date_Old=Retrieve_Const(Stream_General, 0, General_Encoded_Date);
1171 if (Encoded_Date_Old.empty() || Encoded_Date_New!=Encoded_Date_Old)
1172 Fill(Stream_General, 0, General_Encoded_Date, Encoded_Date_New);
1173 }
1174 else if (Name==__T("WM/Genre"))
1175 Fill(Stream_General, 0, General_Genre, Value, true); //Clear last value
1176 else if (Name==__T("WM/GenreID"))
1177 {
1178 if (Retrieve(Stream_General, 0, General_Genre).empty())
1179 Fill(Stream_General, 0, General_Genre, Value);
1180 }
1181 else if (Name==__T("WM/Language"))
1182 Language_ForAll=Value;
1183 else if (Name==__T("WM/MediaCredits"))
1184 Fill(Stream_General, 0, General_ThanksTo, Value);
1185 else if (Name==__T("WM/MediaPrimaryClassID")) {}
1186 else if (Name==__T("WM/MCDI")) {}
1187 else if (Name==__T("WM/ModifiedBy"))
1188 Fill(Stream_General, 0, General_RemixedBy, Value);
1189 else if (Name==__T("WM/OriginalAlbumTitle"))
1190 Fill(Stream_General, 0, "Original/Album", Value);
1191 else if (Name==__T("WM/OriginalReleaseTime"))
1192 Fill(Stream_General, 0, "Original/Released_Date", Value);
1193 else if (Name==__T("WM/ParentalRating"))
1194 Fill(Stream_General, 0, General_LawRating, Value);
1195 else if (Name==__T("WM/ParentalRatingReason"))
1196 Fill(Stream_General, 0, General_LawRating_Reason, Value);
1197 else if (Name==__T("WM/Picture"))
1198 Fill(Stream_General, 0, General_Cover, "Y");
1199 else if (Name==__T("WM/Provider"))
1200 Fill(Stream_General, 0, "Provider", Value);
1201 else if (Name==__T("WM/Publisher"))
1202 Fill(Stream_General, 0, General_Publisher, Value);
1203 else if (Name==__T("WM/RadioStationName"))
1204 Fill(Stream_General, 0, General_ServiceName, Value);
1205 else if (Name==__T("WM/RadioStationOwner"))
1206 Fill(Stream_General, 0, General_ServiceProvider, Value);
1207 else if (Name==__T("WM/SubTitle"))
1208 Fill(Stream_General, 0, General_Title_More, Value);
1209 else if (Name==__T("WM/SubTitleDescription"))
1210 Fill(Stream_General, 0, General_Title_More, Value);
1211 else if (Name==__T("WM/ToolName"))
1212 Fill(Stream_General, 0, General_Encoded_Application, Value);
1213 else if (Name==__T("WM/ToolVersion"))
1214 Fill(Stream_General, 0, General_Encoded_Application, Retrieve(Stream_General, 0, General_Encoded_Application)+__T(" ")+Value, true);
1215 else if (Name==__T("WM/TrackNumber"))
1216 Fill(Stream_General, 0, General_Track_Position, Value, true); //Clear last value, like WM/Track
1217 else if (Name==__T("WM/Track"))
1218 {
1219 if (Retrieve(Stream_General, 0, General_Track_Position).empty())
1220 Fill(Stream_General, 0, General_Track_Position, Value.To_int32u()+1);
1221 }
1222 else if (Name==__T("WM/UniqueFileIdentifier"))
1223 {
1224 if (Value.empty() || Value[0]!=__T(';')) //Test if there is only the separator
1225 {
1226 Value.FindAndReplace(__T(";"), MediaInfoLib::Config.TagSeparator_Get());
1227 Fill(Stream_General, 0, General_UniqueID, Value);
1228 }
1229 }
1230 else if (Name==__T("WM/Writer"))
1231 Fill(Stream_General, 0, General_WrittenBy, Value);
1232 else if (Name==__T("WM/Year"))
1233 Fill(Stream_General, 0, General_Recorded_Date, Value);
1234 else
1235 Fill(Stream_General, 0, Name.To_Local().c_str(), Value);
1236 }
1237 }
1238 }
1239
1240 //---------------------------------------------------------------------------
Header_ExtendedContentDescription_ASFLeakyBucketPairs(int16u Value_Length)1241 void File_Wm::Header_ExtendedContentDescription_ASFLeakyBucketPairs(int16u Value_Length)
1242 {
1243 Element_Begin1("ASFLeakyBucketPairs");
1244 Skip_L2( "Reserved");
1245 for (int16u Pos=2; Pos<Value_Length; Pos+=8)
1246 {
1247 Element_Begin1("Bucket");
1248 Skip_L4( "BitRate");
1249 Skip_L4( "msBufferWindow");
1250 Element_End0();
1251 }
1252 Element_End0();
1253 }
1254
1255 //---------------------------------------------------------------------------
Header_StreamBitRate()1256 void File_Wm::Header_StreamBitRate()
1257 {
1258 Element_Name("Stream Bitrate");
1259
1260 //Parsing
1261 int16u Count;
1262 Get_L2 (Count, "Count");
1263 for (int16u Pos=0; Pos<Count; Pos++)
1264 {
1265 Element_Begin1("Stream");
1266 int32u AverageBitRate;
1267 int16u StreamNumber;
1268 Get_L2 (StreamNumber, "Stream Number"); Element_Info1(StreamNumber);
1269 Get_L4 (AverageBitRate, "Average Bitrate"); Element_Info1(AverageBitRate);
1270 Element_End0();
1271
1272 //Filling
1273 stream& StreamItem = Stream[StreamNumber];
1274 if (StreamItem.AverageBitRate==0) //Prefere Average bitrate of Extended Stream Properties if present
1275 StreamItem.AverageBitRate=AverageBitRate;
1276 }
1277 }
1278
1279 //---------------------------------------------------------------------------
Header_ContentBranding()1280 void File_Wm::Header_ContentBranding()
1281 {
1282 Element_Name("Content Branding");
1283
1284 //Parsing
1285 Ztring CopyrightURL, BannerImageURL;
1286 int32u BannerImageData_Type, BannerImageData_Length, BannerImageURL_Length, CopyrightURL_Length;
1287 Get_L4 (BannerImageData_Type, "Banner Image Data Type"); Param_Info1(Wm_BannerImageData_Type(BannerImageData_Type));
1288 Get_L4 (BannerImageData_Length, "Banner Image Data Length");
1289 if (BannerImageData_Length>0)
1290 Skip_XX(BannerImageData_Length, "Banner Image Data");
1291 Get_L4 (BannerImageURL_Length, "Banner Image URL Length");
1292 if (BannerImageURL_Length>0)
1293 Get_Local(BannerImageURL_Length, BannerImageURL, "Banner Image URL");
1294 Get_L4 (CopyrightURL_Length, "Copyright URL Length");
1295 if (CopyrightURL_Length>0)
1296 Get_Local(CopyrightURL_Length, CopyrightURL, "Copyright URL");
1297 }
1298
1299 //---------------------------------------------------------------------------
Header_ContentEncryption()1300 void File_Wm::Header_ContentEncryption()
1301 {
1302 Element_Name("Content Encryption");
1303
1304 //Parsing
1305 Ztring LicenseURL;
1306 int32u SecretDataLength, ProtectionTypeLength, KeyIDLength, LicenseURLLength;
1307 Get_L4 (SecretDataLength, "Secret Data Length");
1308 Skip_XX(SecretDataLength, "Secret Data");
1309 Get_L4 (ProtectionTypeLength, "Protection Type Length");
1310 Skip_Local(ProtectionTypeLength, "Protection Type");
1311 Get_L4 (KeyIDLength, "Key ID Length");
1312 Skip_Local(KeyIDLength, "Key ID Type");
1313 Get_L4 (LicenseURLLength, "License URL Length");
1314 Get_Local(LicenseURLLength, LicenseURL, "License URL");
1315
1316 //Filling
1317 Fill(Stream_General, 0, "Encryption", LicenseURL);
1318 }
1319
1320 //---------------------------------------------------------------------------
Header_ExtendedContentEncryption()1321 void File_Wm::Header_ExtendedContentEncryption()
1322 {
1323 Element_Name("Extended Content Encryption");
1324
1325 //Parsing
1326 int32u DataLength;
1327 Get_L4 (DataLength, "Data Length");
1328 Skip_XX(DataLength, "Data");
1329 }
1330
1331 //---------------------------------------------------------------------------
Header_DigitalSignature()1332 void File_Wm::Header_DigitalSignature()
1333 {
1334 Element_Name("Digital Signature");
1335
1336 //Parsing
1337 int32u DataLength;
1338 Skip_L4( "Signature Type");
1339 Get_L4 (DataLength, "Signature Data Length");
1340 Skip_XX(DataLength, "Signature Data");
1341 }
1342
1343 //---------------------------------------------------------------------------
Header_Padding()1344 void File_Wm::Header_Padding()
1345 {
1346 Element_Name("Padding");
1347
1348 //Parsing
1349 Skip_XX(Element_Size, "Padding");
1350 }
1351
1352 //---------------------------------------------------------------------------
Data()1353 void File_Wm::Data()
1354 {
1355 Element_Name("Data");
1356
1357 //Parsing
1358 Skip_GUID( "File ID");
1359 Skip_L8( "Total Data Packets");
1360 Skip_L1( "Alignment");
1361 Skip_L1( "Packet Alignment");
1362
1363 //Filling
1364 Fill(Stream_General, 0, General_HeaderSize, File_Offset+Buffer_Offset-24);
1365 Fill(Stream_General, 0, General_DataSize, Element_TotalSize_Get()+24);
1366
1367 //For each stream
1368 Streams_Count=0;
1369 std::map<int16u, stream>::iterator Temp=Stream.begin();
1370 while (Temp!=Stream.end())
1371 {
1372 #if defined(MEDIAINFO_MPEGA_YES)
1373 if (IsDvrMs && !Temp->second.Parser && Temp->second.AverageBitRate>=32768)
1374 {
1375 Temp->second.Parser=new File_Mpega; //No stream properties, trying to detect it in datas...
1376 ((File_Mpega*)Temp->second.Parser)->Frame_Count_Valid=8;
1377 Open_Buffer_Init(Temp->second.Parser);
1378 }
1379 #endif
1380 if (Temp->second.Parser || Temp->second.StreamKind==Stream_Video) //We need Stream_Video for Frame_Rate computing
1381 {
1382 Temp->second.SearchingPayload=true;
1383 Streams_Count++;
1384 }
1385 ++Temp;
1386 }
1387
1388 //Enabling the alternative parser
1389 MustUseAlternativeParser=true;
1390 Data_AfterTheDataChunk=File_Offset+Buffer_Offset+Element_TotalSize_Get();
1391 }
1392
1393 //---------------------------------------------------------------------------
Data_Packet()1394 void File_Wm::Data_Packet()
1395 {
1396 //Counting
1397 Packet_Count++;
1398 Element_Info1(Packet_Count);
1399 size_t Element_Show_Count=0;
1400
1401 //Parsing
1402 int32u PacketLength=0, SizeOfMediaObject=0;
1403 int8u Flags, ErrorCorrectionData_Length, ErrorCorrectionLengthType, SequenceType, PaddingLengthType, PacketLengthType;
1404 bool ErrorCorrectionPresent;
1405 Element_Begin1("Error Correction");
1406 Get_L1 (Flags, "Flags");
1407 Get_FlagsM(Flags&0x0F, ErrorCorrectionData_Length, "Error Correction Data Length"); //4 lowest bits
1408 Skip_Flags(Flags, 4, "Opaque Data Present");
1409 Get_FlagsM((Flags>>5)&0x03, ErrorCorrectionLengthType, "Error Correction Length Type"); //bits 6 and 7
1410 Get_Flags (Flags, 7, ErrorCorrectionPresent, "Error Correction Present");
1411 if (ErrorCorrectionPresent && ErrorCorrectionLengthType==0 && ErrorCorrectionData_Length==2)
1412 {
1413 int8u TypeNumber;
1414 Get_L1 (TypeNumber, "Type/Number");
1415 Skip_FlagsM((TypeNumber>>4)&0x0F, "Type");
1416 Skip_FlagsM( TypeNumber &0x0F, "Number");
1417 Skip_L1( "Cycle");
1418 }
1419 Element_End0();
1420
1421 Element_Begin1("Payload Parsing Information");
1422 Get_L1 (Flags, "Length Type Flags");
1423 Get_Flags (Flags, 0, MultiplePayloadsPresent, "Multiple Payloads Present");
1424 Get_FlagsM((Flags>>1)&0x3, SequenceType, "Sequence Type");
1425 Get_FlagsM((Flags>>3)&0x3, PaddingLengthType, "Padding Length Type");
1426 Get_FlagsM((Flags>>5)&0x3, PacketLengthType, "Packet Length Type");
1427 Skip_Flags(Flags, 7, "Error Correction Present");
1428 Get_L1 (Flags, "Property Flags");
1429 Get_FlagsM( Flags &0x3, ReplicatedDataLengthType, "Replicated Data Length Type");
1430 Get_FlagsM((Flags>>2)&0x3, OffsetIntoMediaObjectLengthType, "Offset Into Media Object Length Type");
1431 Get_FlagsM((Flags>>4)&0x3, MediaObjectNumberLengthType, "Media Object Number Length Type");
1432 Get_FlagsM((Flags>>6)&0x3, StreamNumberLengthType, "Stream Number Length Type");
1433 switch (PacketLengthType)
1434 {
1435 case 1 : {int8u Data; Get_L1(Data, "Packet Length"); PacketLength=Data;} break;
1436 case 2 : {int16u Data; Get_L2(Data, "Packet Length"); PacketLength=Data;} break;
1437 case 3 : Get_L4(PacketLength, "Packet Length"); break;
1438 default: ;
1439 }
1440 switch (SequenceType)
1441 {
1442 case 1 : Skip_L1( "Sequence"); break;
1443 case 2 : Skip_L2( "Sequence"); break;
1444 case 3 : Skip_L4( "Sequence"); break;
1445 default: ;
1446 }
1447 switch (PaddingLengthType)
1448 {
1449 case 1 : {int8u Data; Get_L1(Data, "Padding Length"); Data_Parse_Padding=Data;} break;
1450 case 2 : {int16u Data; Get_L2(Data, "Padding Length"); Data_Parse_Padding=Data;} break;
1451 case 3 : Get_L4(Data_Parse_Padding, "Padding Length"); break;
1452 default: Data_Parse_Padding=0;
1453 }
1454 Skip_L4( "Send Time");
1455 Skip_L2( "Duration");
1456 Element_End0();
1457
1458 if (MultiplePayloadsPresent)
1459 {
1460 //Parsing
1461 Element_Begin1("Multiple Payloads additional flags");
1462 int8u AdditionalFlags;
1463 Get_L1 (AdditionalFlags, "Flags");
1464 Get_FlagsM( AdditionalFlags &0x3F, NumberPayloads, "Number of Payloads"); //6 bits
1465 Get_FlagsM((AdditionalFlags>>6)&0x03, PayloadLengthType, "Payload Length Type"); //bits 6 and 7
1466 Element_End0();
1467 }
1468 else
1469 {
1470 SizeOfMediaObject=(int32u)(Element_Size-Element_Offset-Data_Parse_Padding);
1471 NumberPayloads=1;
1472 }
1473
1474 for (NumberPayloads_Pos=0; NumberPayloads_Pos<NumberPayloads; NumberPayloads_Pos++)
1475 {
1476 Element_Begin1("Payload");
1477 int32u ReplicatedDataLength=0, PayloadLength=0;
1478 int8u StreamNumber;
1479 Get_L1 (StreamNumber, "Stream Number");
1480 Stream_Number=StreamNumber&0x7F; //For KeyFrame
1481 Element_Info1(Stream_Number);
1482 switch (MediaObjectNumberLengthType)
1483 {
1484 case 1 : Skip_L1( "Media Object Number"); break;
1485 case 2 : Skip_L2( "Media Object Number"); break;
1486 case 3 : Skip_L4( "Media Object Number"); break;
1487 default: Trusted_IsNot("Media Object Number"); return; //Problem
1488 }
1489 switch (OffsetIntoMediaObjectLengthType)
1490 {
1491 case 1 : Skip_L1( "Offset Into Media Object"); break;
1492 case 2 : Skip_L2( "Offset Into Media Object"); break;
1493 case 3 : Skip_L4( "Offset Into Media Object"); break;
1494 default: Trusted_IsNot("Offset Into Media Object"); return; //Problem
1495 }
1496 switch (ReplicatedDataLengthType)
1497 {
1498 case 1 : {int8u Data; Get_L1(Data, "Replicated Data Length"); ReplicatedDataLength=Data;} break;
1499 case 2 : {int16u Data; Get_L2(Data, "Replicated Data Length"); ReplicatedDataLength=Data;} break;
1500 case 3 : Get_L4(ReplicatedDataLength, "Replicated Data Length"); break;
1501 default: Trusted_IsNot("Replicated Data Length"); return; //Problem
1502 }
1503 if (ReplicatedDataLengthType!=0 && ReplicatedDataLength>0)
1504 {
1505 if (ReplicatedDataLength>=8)
1506 {
1507 int32u PresentationTime;
1508 Get_L4 (SizeOfMediaObject, "Size Of Media Object");
1509 Get_L4 (PresentationTime, "Presentation Time");
1510 if (ReplicatedDataLength>8)
1511 Data_Packet_ReplicatedData(ReplicatedDataLength-8);
1512
1513 //Presentation time delta
1514 std::map<int16u, stream>::iterator Strea=Stream.find(Stream_Number);
1515 if (Strea!=Stream.end() && Strea->second.StreamKind==Stream_Video)
1516 {
1517 Strea->second.PresentationTimes.insert(PresentationTime);
1518 }
1519 }
1520 else if (ReplicatedDataLength==1)
1521 {
1522 Skip_L1( "Presentation Time Delta");
1523 //TODO
1524 }
1525 else
1526 {
1527 Skip_XX(ReplicatedDataLength, "Replicated Data");
1528 }
1529 }
1530
1531 if (MultiplePayloadsPresent)
1532 {
1533 switch (PayloadLengthType)
1534 {
1535 case 1 : {int8u Data; Get_L1(Data, "Payload Length"); PayloadLength=Data;} break;
1536 case 2 : {int16u Data; Get_L2(Data, "Payload Length"); PayloadLength=Data;} break;
1537 case 3 : Get_L4(PayloadLength, "Payload Length"); break;
1538 default: Trusted_IsNot("Payload Length"); return; //Problem
1539 }
1540 }
1541 else if (Element_Size-Element_Offset>Data_Parse_Padding)
1542 PayloadLength=(int32u)(Element_Size-(Element_Offset+Data_Parse_Padding));
1543 else
1544 {
1545 Trusted_IsNot("Padding size problem");
1546 }
1547 if (Element_Offset+PayloadLength+Data_Parse_Padding>Element_Size)
1548 {
1549 Trusted_IsNot("Payload Length problem");
1550 }
1551 else
1552 {
1553 //Demux
1554 Element_Code=Stream_Number;
1555 Demux(Buffer+(size_t)Element_Offset, (size_t)PayloadLength, ContentType_MainStream);
1556
1557 //Analyzing
1558 stream& StreamItem = Stream[Stream_Number];
1559 if (StreamItem.Parser && StreamItem.SearchingPayload)
1560 {
1561 //Handling of spanned on multiple chunks
1562 #if defined(MEDIAINFO_VC1_YES)
1563 bool FrameIsAlwaysComplete=true;
1564 #endif
1565 if (PayloadLength!=SizeOfMediaObject)
1566 {
1567 if (SizeOfMediaObject_BytesAlreadyParsed==0)
1568 SizeOfMediaObject_BytesAlreadyParsed=SizeOfMediaObject-PayloadLength;
1569 else
1570 SizeOfMediaObject_BytesAlreadyParsed-=PayloadLength;
1571 if (SizeOfMediaObject_BytesAlreadyParsed==0)
1572 Element_Show_Count++;
1573 #if defined(MEDIAINFO_VC1_YES)
1574 else
1575 FrameIsAlwaysComplete=false;
1576 #endif
1577 }
1578 else
1579 Element_Show_Count++;
1580
1581 //Codec specific
1582 #if defined(MEDIAINFO_VC1_YES)
1583 if (Retrieve(StreamItem.StreamKind, StreamItem.StreamPos, Fill_Parameter(StreamItem.StreamKind, Generic_Format))==__T("VC-1"))
1584 ((File_Vc1*)StreamItem.Parser)->FrameIsAlwaysComplete=FrameIsAlwaysComplete;
1585 #endif
1586
1587 Open_Buffer_Continue(StreamItem.Parser, (size_t)PayloadLength);
1588 if (StreamItem.Parser->Status[IsFinished]
1589 || (StreamItem.PresentationTimes.size()>=300 && Config->ParseSpeed<1.0))
1590 {
1591 StreamItem.Parser->Open_Buffer_Unsynch();
1592 StreamItem.SearchingPayload=false;
1593 Streams_Count--;
1594 }
1595
1596 Element_Show();
1597 }
1598 else
1599 {
1600 Skip_XX(PayloadLength, "Data");
1601 if (StreamItem.SearchingPayload
1602 && (StreamItem.StreamKind==Stream_Video && StreamItem.PresentationTimes.size()>=300))
1603 {
1604 StreamItem.SearchingPayload=false;
1605 Streams_Count--;
1606 }
1607 }
1608 }
1609 Element_End0();
1610 }
1611
1612 if (Data_Parse_Padding)
1613 Skip_XX(Data_Parse_Padding, "Padding");
1614
1615 //Jumping if needed
1616 if (Streams_Count==0 || (Packet_Count>=1000 && Config->ParseSpeed<1.0))
1617 {
1618 Info("Data, Jumping to end of chunk");
1619 GoTo(Data_AfterTheDataChunk, "Windows Media");
1620 }
1621
1622 if (Element_Show_Count>0)
1623 Element_Show();
1624 }
1625
1626 //---------------------------------------------------------------------------
Data_Packet_ReplicatedData(int32u Size)1627 void File_Wm::Data_Packet_ReplicatedData(int32u Size)
1628 {
1629 Element_Begin1("Replicated Data");
1630 int64u Element_Offset_Final=Element_Offset+Size;
1631 stream& StreamItem = Stream[Stream_Number];
1632 for (size_t Pos=0; Pos<StreamItem.Payload_Extension_Systems.size(); Pos++)
1633 {
1634 Element_Begin0();
1635 switch (StreamItem.Payload_Extension_Systems[Pos].ID.hi)
1636 {
1637 case Elements::Payload_Extension_System_TimeStamp : Data_Packet_ReplicatedData_TimeStamp(); break;
1638 default : //Not enough info to validate this algorithm
1639 //if (StreamItem.Payload_Extension_Systems[Pos].Size!=(int16u)-1)
1640 //{
1641 // Element_Name("Unknown");
1642 // Skip_XX(StreamItem.Payload_Extension_Systems[Pos].Size, "Unknown");
1643 //}
1644 //else
1645 Pos=StreamItem.Payload_Extension_Systems.size(); //Disabling the rest, all is unknown
1646 }
1647 Element_End0();
1648 }
1649
1650 if (Element_Offset<Element_Offset_Final)
1651 {
1652 Element_Begin1("Other chunks");
1653 Skip_XX(Element_Offset_Final-Element_Offset, "Unknown");
1654 Element_End0();
1655 }
1656 Element_End0();
1657 }
1658
1659 //---------------------------------------------------------------------------
Data_Packet_ReplicatedData_TimeStamp()1660 void File_Wm::Data_Packet_ReplicatedData_TimeStamp()
1661 {
1662 Element_Name("TimeStamp");
1663
1664 //Parsing
1665 int64u TS0;
1666 Skip_L2( "Unknown");
1667 Skip_L4( "Unknown");
1668 Skip_L4( "Unknown");
1669 Get_L8 (TS0, "TS0");
1670 #if MEDIAINFO_TRACE
1671 if (TS0!=(int64u)-1) Param_Info1(TS0/10000);
1672 #endif //MEDIAINFO_TRACE
1673 Info_L8(TS1, "TS1");
1674 #if MEDIAINFO_TRACE
1675 if (TS1!=(int64u)-1) Param_Info1(TS1/10000);
1676 #endif //MEDIAINFO_TRACE
1677 Skip_L4( "Unknown");
1678 Skip_L4( "Unknown");
1679 Skip_L4( "Unknown");
1680 Skip_L4( "Unknown");
1681 stream& StreamItem = Stream[Stream_Number];
1682 if (StreamItem.TimeCode_First==(int64u)-1 && TS0!=(int64u)-1)
1683 StreamItem.TimeCode_First=TS0/10000;
1684 }
1685
1686 //---------------------------------------------------------------------------
SimpleIndex()1687 void File_Wm::SimpleIndex()
1688 {
1689 Element_Name("Simple Index");
1690
1691 //Parsing
1692 /*
1693 int32u Count;
1694 Skip_GUID( "File ID");
1695 Skip_L8( "Index Entry Time Interval");
1696 Skip_L4( "Maximum Packet Count");
1697 Get_L4 (Count, "Index Entries Count");
1698 for (int32u Pos=0; Pos<Count; Pos++)
1699 {
1700 Element_Begin1("Index Entry", 6);
1701 int32u PacketNumber;
1702 int16u PacketCount;
1703 Get_L4 (PacketNumber, "Packet Number");
1704 Get_L2 (PacketCount, "Packet Count");
1705 Element_End0();
1706 }
1707 */
1708 Skip_XX(Element_TotalSize_Get()-Element_Offset, "Indexes");
1709 }
1710
1711 //---------------------------------------------------------------------------
Index()1712 void File_Wm::Index()
1713 {
1714 Element_Name("Index");
1715
1716 //Parsing
1717 /*
1718 int32u Blocks_Count;
1719 int16u Specifiers_Count;
1720 Skip_L4( "Index Entry Time Interval");
1721 Get_L2 (Specifiers_Count, "Index Specifiers Count");
1722 Get_L4 (Blocks_Count, "Index Blocks Count");
1723 for (int16u Pos=0; Pos<Specifiers_Count; Pos++)
1724 {
1725 Element_Begin1("Specifier");
1726 Skip_L2( "Stream Number");
1727 Skip_L2( "Index Type");
1728 Element_End0();
1729 }
1730 for (int32u Pos=0; Pos<Blocks_Count; Pos++)
1731 {
1732 Element_Begin1("Block");
1733 int32u Entry_Count;
1734 Get_L4 (Entry_Count, "Index Entry Count");
1735 Element_Begin1("Block Positions");
1736 for (int16u Pos=0; Pos<Specifiers_Count; Pos++)
1737 Skip_L4( "Position");
1738 Element_End0();
1739 for (int32u Pos=0; Pos<Entry_Count; Pos++)
1740 {
1741 Element_Begin1("Entry");
1742 for (int16u Pos=0; Pos<Specifiers_Count; Pos++)
1743 Skip_L4( "Offset");
1744 Element_End0();
1745 }
1746 Element_End0();
1747 }
1748 */
1749 Skip_XX(Element_TotalSize_Get()-Element_Offset, "Indexes");
1750 }
1751
1752 //---------------------------------------------------------------------------
MediaIndex()1753 void File_Wm::MediaIndex()
1754 {
1755 Element_Name("MediaIndex");
1756 }
1757
1758 //---------------------------------------------------------------------------
TimecodeIndex()1759 void File_Wm::TimecodeIndex()
1760 {
1761 Element_Name("Timecode Index");
1762
1763 //Parsing
1764 int32u TimeCode_First=(int32u)-1;
1765 int32u IndexBlocksCount;
1766 int16u IndexSpecifiersCount;
1767 Skip_L4( "Reserved");
1768 Get_L2 (IndexSpecifiersCount, "Index Specifiers Count");
1769 Get_L4 (IndexBlocksCount, "Index Blocks Count");
1770 Element_Begin1("Index Specifiers");
1771 for (int16u Pos=0; Pos<IndexSpecifiersCount; ++Pos)
1772 {
1773 Element_Begin1("Index Specifier");
1774 Skip_L2( "Stream Number");
1775 Info_L2(IndexType, "Index Type");
1776 Element_Info1(IndexType);
1777 Element_End0();
1778 }
1779 Element_End0();
1780 Element_Begin1("Index Blocks");
1781 for (int16u Pos=0; Pos<IndexBlocksCount; ++Pos)
1782 {
1783 Element_Begin1("Index Block");
1784 int32u IndexEntryCount;
1785 Get_L4 (IndexEntryCount, "Index Entry Count");
1786 Skip_L2( "Timecode Range");
1787 Element_Begin1("Block Positions");
1788 for (int16u Pos=0; Pos<IndexSpecifiersCount; ++Pos)
1789 Skip_L8( "Block Position");
1790 Element_End0();
1791 Element_Begin1("Index Entries");
1792 for (int32u Pos=0; Pos<IndexEntryCount; ++Pos)
1793 {
1794 Element_Begin1("Index Entry");
1795 if (TimeCode_First==(int32u)-1)
1796 Get_L4 (TimeCode_First, "Timecode");
1797 else
1798 Skip_L4( "Timecode");
1799 for (int16u Pos=0; Pos<IndexSpecifiersCount; ++Pos)
1800 Skip_L4( "Offsets");
1801 Element_End0();
1802 }
1803 Element_End0();
1804 Element_End0();
1805 }
1806 Element_End0();
1807
1808 FILLING_BEGIN();
1809 Stream_Prepare(Stream_Other);
1810 Fill(Stream_Other, StreamPos_Last, Other_Type, "Time code");
1811 Fill(Stream_Other, StreamPos_Last, Other_Format, "WM TC");
1812 if (TimeCode_First!=(int32u)-1)
1813 {
1814 int8u H1= TimeCode_First>>28;
1815 int8u H2=(TimeCode_First>>24)&0xF;
1816 int8u M1=(TimeCode_First>>20)&0xF;
1817 int8u M2=(TimeCode_First>>16)&0xF;
1818 int8u S1=(TimeCode_First>>12)&0xF;
1819 int8u S2=(TimeCode_First>> 8)&0xF;
1820 int8u F1=(TimeCode_First>> 4)&0xF;
1821 int8u F2= TimeCode_First &0xF;
1822 if (H1<10 && H2<10 && M1<10 && M2<10 && S1<10 && S2<10 && F1<10 && F2<10)
1823 {
1824 string TC;
1825 TC+='0'+H1;
1826 TC+='0'+H2;
1827 TC+=':';
1828 TC+='0'+M1;
1829 TC+='0'+M2;
1830 TC+=':';
1831 TC+='0'+S1;
1832 TC+='0'+S2;
1833 TC+=':';
1834 TC+='0'+F1;
1835 TC+='0'+F2;
1836 Fill(Stream_Other, StreamPos_Last, Other_TimeCode_FirstFrame, TC.c_str());
1837 }
1838 }
1839 FILLING_END();
1840 }
1841
1842 //***************************************************************************
1843 // C++
1844 //***************************************************************************
1845
1846 } //NameSpace
1847
1848 #endif //MEDIAINFO_WM_YES
1849