bool File_Zip::Zip64_end_of_central_directory_record()
{
if (Element_Offset+12>Element_Size) //Zip64_end_of_central_directory_record
return false; //Not enough data
//Retrieving complete Zip64_end_of_central_directory_record size
int64u size_of_Zip64_end_of_central_directory_record=LittleEndian2int64u(Buffer+(size_t)Element_Offset+4);
if (Element_Offset+12+size_of_Zip64_end_of_central_directory_record>Element_Size) //end_of_central_directory all included
return false; //Not enough data
//Parsing
//~ int32u offset;
int16u version_made_by;
Element_Begin1("Zip64 End of central directory record");
Skip_C4( "Zip64 end of central dir signature");
Skip_L8( "size of zip64 end of central directory record");
Get_L2 (version_made_by, "version made by");
Param_Info1((version_made_by>>8)>20?"unused":Zip_made_by[version_made_by>>8]);
Skip_L2( "version needed to extract");
Skip_L4( "number of this disk");
Skip_L4( "number of the disk");// with the start of the central directory
Skip_L8( "total number of entries on this disk");// in the central directory
Skip_L8( "total number of entries");// in the central directory
Skip_L8( "size of the central directory");
Skip_L8( "offset of start of central directory"); // with respect to the starting disk number
Skip_XX(size_of_Zip64_end_of_central_directory_record-44, "zip64 extensible data sector");
Element_End0();
return true;
}
//---------------------------------------------------------------------------
void File_Cdxa::FileHeader_Parse()
{
//Parsing
Skip_C4( "RIFF header");
Skip_L4( "RIFF data size");
Skip_C4( "CDXA");
Skip_C4( "fmt header");
Skip_L4( "fmt size");
Skip_L2( "user_id");
Skip_L2( "group_id");
Skip_L2( "attributes");
Skip_C2( "xa_signature");
Skip_L4( "xa_track_number");
Skip_L4( "reserved");
Skip_C4( "data header");
Skip_L4( "data size");
FILLING_BEGIN();
Accept("CDXA");
MI=new MediaInfo_Internal;
MI->Option(_T("FormatDetection_MaximumOffset"), _T("1048576"));
//MI->Option(_T("File_IsSub"), _T("1"));
MI->Open_Buffer_Init(File_Size, File_Offset+Buffer_Offset);
FILLING_END();
}
//---------------------------------------------------------------------------
// file header
void File_Rar::Header_Parse_Content_74()
{
int16u name_size;
int8u HOST_OS, METHOD, UNP_VER;
Get_L4 (PACK_SIZE, "PACK_SIZE"); //Compressed file size
Skip_L4( "UNP_SIZE"); //Uncompressed file size
Get_L1 (HOST_OS, "HOST_OS"); Param_Info1((HOST_OS<6?Rar_host_os[HOST_OS]:"Unknown"));
Skip_L4( "FILE_CRC");
Skip_L4( "FTIME"); //Date and time in standard MS DOS format
Get_L1 (UNP_VER, "UNP_VER"); Param_Info1(Rar_version_number(UNP_VER)); //RAR version needed to extract file
Get_L1 (METHOD, "METHOD"); Param_Info1(((METHOD>=0x30)&&(METHOD<0x36)?Rar_packing_method[METHOD-0x30]:"Unknown"));
Get_L2 (name_size, "NAME_SIZE"); //File name size
Skip_L4( "ATTR"); //File attributes
if(high_fields)
{
Get_L4 (HIGH_PACK_SIZE, "HIGH_PACK_SIZE"); //High 4 bytes of 64 bit value of compressed file size.
Skip_L4( "HIGH_UNP_SIZE"); //High 4 bytes of 64 bit value of uncompressed file size.
}
else
HIGH_PACK_SIZE=0;
if (usual_or_utf8)
{
//Must test the content before reading, looking fore zero byte
if (Element_Offset+name_size>Element_Size)
{
Skip_XX(Element_Size-Element_Offset, "Error");
return;
}
int64u ZeroPos=0;
while (ZeroPos<name_size)
{
if (Buffer[Buffer_Offset+(size_t)(Element_Offset+ZeroPos)]==0)
break; //Found
ZeroPos++;
}
if (ZeroPos==name_size)
Skip_UTF8(name_size, "FILE_NAME");
else
{
Skip_Local(ZeroPos, "FILE_NAME"); //Up to ZeroPos
Skip_L1( "Zero");
Skip_UTF16L(name_size-(ZeroPos+1), "FILE_NAME"); //Spec is not precise, "Unicode" without encoding format (character size, endianess), because RAR is from Windows, we hope this is the format from Windows (UTF-16 Little Endian)
}
}
else
Skip_Local(name_size, "FILE_NAME");
if (salt)
Skip_L8( "SALT");
//if(exttime)
//Skip_XX("EXT_TIME"); //Which size?
}
//---------------------------------------------------------------------------
void File_Tga::Tga_File_Footer()
{
if (Version==1)
return; //No footer
Element_Begin1("Image/color Map Data");
Skip_L4( "Extension Area Offset");
Skip_L4( "Developer Directory Offset");
Skip_Local(16, "Signature");
Skip_Local( 1, "Reserved Character");
Skip_L1( "Binary Zero String Terminator");
Element_End0();
}
bool File_Zip::Zip64_end_of_central_directory_locator()
{
if (Element_Offset+20>Element_Size) //Zip64_end_of_central_directory_locator
return false; //Not enough data
//Parsing
Element_Begin1("Zip64 end of central directory locator");
Skip_C4("zip64 end of central dir locator signature");
Skip_L4("number of the disk");// with the start of the zip64 end of central directory
Skip_L8("relative offset of the zip64 end of central directory record");
Skip_L4("total number of disks");
Element_End0();
return true;
}
bool File_Zip::data_descriptor()
{
if(data_descriptor_set)
{
if (Element_Offset+12>Element_Size)
return false; //Not enough data
Element_Begin1("data_descriptor");
Skip_L4("crc-32");
Skip_L4("compressed size");
Skip_L4("uncompressed size");
Element_End0();
}
return true;
}
bool File_Zip::end_of_central_directory()
{
if (Element_Offset+22>Element_Size) //end_of_central_directory up to relative offset of .ZIP file comment length included
return false; //Not enough data
//Retrieving complete local_file_header size
int16u zip_comment_length=LittleEndian2int16u(Buffer+(size_t)Element_Offset+20);
if (Element_Offset+22+zip_comment_length>Element_Size) //end_of_central_directory all included
return false; //Not enough data
//Parsing
int32u offset;
Element_Begin1("End of central directory");
Skip_C4( "end of central dir signature");
Skip_L2( "number of this disk");
Skip_L2( "number of the disk");// with the start of the central directory
Skip_L2( "total number of entries on this disk");// in the central directory
Skip_L2( "total number of entries");// in the central directory
Skip_L4( "size of the central directory");
Get_L4 (offset, "offset of start of central directory");// with respect to the starting disk number
Skip_L2( "zip file comment length");
Skip_XX(zip_comment_length, "zip file comment");
Element_End0();
//Going to first central directory (once)
if (!end_of_central_directory_IsParsed)
{
end_of_central_directory_IsParsed=true;
GoTo(offset);
}
return true;
}
//---------------------------------------------------------------------------
void File_Exr::FileHeader_Parse()
{
//Parsing
int32u Flags;
int8u Version;
bool Deep, Multipart;
Skip_L4( "Magic number");
Get_L1 (Version, "Version field");
Get_L3 (Flags, "Flags");
Skip_Flags(Flags, 0, "Single tile");
Get_Flags (Flags, 1, LongName, "Long name");
Get_Flags (Flags, 2, Deep, "Non-image");
Get_Flags (Flags, 3, Multipart, "Multipart");
//Filling
if (Frame_Count==0)
{
Fill(Stream_General, 0, General_Format_Version, __T("Version ")+Ztring::ToZtring(Version));
Fill(StreamKind_Last, 0, "Format", "EXR");
Fill(StreamKind_Last, 0, "Format_Version", __T("Version ")+Ztring::ToZtring(Version));
Fill(StreamKind_Last, 0, "Format_Profile", (Flags&0x02)?"Tile":"Line");
if (Deep)
Fill(Stream_General, 0, "Deep", "Yes");
if (Multipart)
Fill(Stream_General, 0, "Multipart", "Yes");
}
Frame_Count++;
if (Frame_Count_NotParsedIncluded!=(int64u)-1)
Frame_Count_NotParsedIncluded++;
ImageData_End=Config->File_Current_Size;
}
//---------------------------------------------------------------------------
void File_Kate::Identification()
{
Element_Name("Identification");
//Parsing
Ztring Language, Category;
int16u Width, Height;
int8u VersionMajor, VersionMinor, NumHeaders, TextEncoding;
Skip_B1 ( "Signature");
Skip_Local(7, "Signature");
Skip_L1( "Reserved");
Get_L1 (VersionMajor, "version major");
Get_L1 (VersionMinor, "version minor");
Get_L1 (NumHeaders, "num headers");
Get_L1 (TextEncoding, "text encoding");
Skip_L1( "directionality");
Skip_L1( "Reserved");
Skip_L1( "granule shift");
Skip_L4( "Reserved");
Get_L2 (Width, "cw sh + canvas width");
Get_L2 (Height, "ch sh + canvas height");
/*
BS_Begin();
Skip_BS( 4, "cw sh");
Get_BS (12, Width, "canvas width");
Skip_BS( 4, "ch sh");
Get_BS (12, Height, "canvas height");
BS_End();
*/
Skip_L4( "granule rate numerator");
Skip_L4( "granule rate denominator");
Get_UTF8(16, Language, "Language");
Get_UTF8(16, Category, "Category");
FILLING_BEGIN();
Accept("Kate");
Stream_Prepare(Stream_Text);
Fill(Stream_Text, 0, Text_Format, "Kate");
Fill(Stream_Text, 0, Text_Codec, "Kate");
Fill(Stream_Text, 0, Text_Language, Language);
Fill(Stream_Text, 0, Text_Language_More, Kate_Category(Category));
Finish("Kate");
FILLING_END();
}
//---------------------------------------------------------------------------
void File_ApeTag::HeaderFooter()
{
//Parsing
int32u Flags;
Skip_C8( "Preamble");
Skip_L4( "Version");
Skip_L4( "Size");
Skip_L4( "Count");
Get_L4 (Flags, "Flags");
Skip_Flags(Flags, 0, "Read Only");
Skip_Flags(Flags, 1, "Binary");
Skip_Flags(Flags, 2, "Locator of external stored information");
Skip_Flags(Flags, 29, "Is the header");
Skip_Flags(Flags, 30, "Contains a footer");
Skip_Flags(Flags, 31, "Contains a header");
Skip_L8( "Reserved");
}
//---------------------------------------------------------------------------
void File_Pmp::FileHeader_Parse()
{
//Parsing
int32u version, video_format=0, nb_frames=0, video_width=0, video_height=0, time_base_num=0, time_base_den=0, audio_format=0, sample_rate=0, channels=0;
Skip_C4( "Signature");
Get_L4 (version, "Version");
if (version==1)
{
Get_L4 (video_format, "video_format");
Get_L4 (nb_frames, "number of frames");
Get_L4 (video_width, "video_width");
Get_L4 (video_height, "video_height");
Get_L4 (time_base_num, "time_base_num");
Get_L4 (time_base_den, "time_base_den");
Skip_L4( "number of audio streams");
Get_L4 (audio_format, "audio_format");
Get_L4 (channels, "channels");
Skip_L4( "unknown");
Get_L4 (sample_rate, "sample_rate");
}
FILLING_BEGIN();
Accept("PMP");
Fill(Stream_General, 0, General_Format, "PMP");
if (version==1)
{
Stream_Prepare(Stream_Video);
Fill(Stream_Video, 0, Video_Format, Pmp_video_format(video_format));
Fill(Stream_Video, 0, Video_FrameCount, nb_frames);
Fill(Stream_Video, 0, Video_Width, video_width);
Fill(Stream_Video, 0, Video_Height, video_height);
Fill(Stream_Video, 0, Video_FrameRate, (float)time_base_den / 100);
Stream_Prepare(Stream_Audio);
Fill(Stream_Audio, 0, Audio_Format, Pmp_audio_format(audio_format));
Fill(Stream_Audio, 0, Audio_Channel_s_, channels);
Fill(Stream_Audio, 0, Audio_SamplingRate, sample_rate);
}
//No more need data
Finish("PMP");
FILLING_END();
}
//---------------------------------------------------------------------------
void File_Fraps::Version2()
{
//Parsing
if (Element_Size>8) //Else this is a repeat frame
{
Skip_C4( "FPSx");
Skip_L4( "offset to the Y plane (minus 8)");
Skip_L4( "offset to the U plane (minus 8)");
Skip_L4( "offset to the V plane (minus 8)");
Skip_XX(Element_Size-Element_Offset, "data");
}
FILLING_BEGIN();
Accept();
Fill();
Fill(Stream_Video, 0, Video_ColorSpace, "YUV");
Fill(Stream_Video, 0, Video_BitDepth, 8);
FILLING_END();
}
//---------------------------------------------------------------------------
void File_Ps2Audio::SShd()
{
Element_Begin1("SShd (Header)");
//Parsing
int32u Size, Format, SamplingRate, Channels;
Skip_C4( "ID");
Get_L4 (Size, "Size");
if (Size!=0x18)
{
Trusted_IsNot("Bad size");
return;
}
Get_L4 (Format, "Format");
Get_L4 (SamplingRate, "Sampling rate");
Get_L4 (Channels, "Channels");
Skip_L4( "Bytes per channel");
Skip_L4( "Reserved");
Skip_L4( "Reserved");
Element_End0();
FILLING_BEGIN();
Accept("PS2 Audio");
BitRate=SamplingRate*Channels*16; //Always 16 bits
Stream_Prepare(Stream_Audio);
Ztring FormatS;
switch(Format)
{
case 0x00000001 : FormatS=__T("PCM"); break;
case 0x00000010 : FormatS=__T("ADPCM"); break;
default : ;
}
Fill(Stream_Audio, 0, Audio_Format, FormatS);
Fill(Stream_Audio, 0, Audio_Codec, FormatS);
Fill(Stream_Audio, 0, Audio_MuxingMode, "PS2");
Fill(Stream_Audio, 0, Audio_SamplingRate, SamplingRate);
Fill(Stream_Audio, 0, Audio_Channel_s_, Channels);
Fill(Stream_Audio, 0, Audio_BitRate, BitRate);
FILLING_END();
}
//---------------------------------------------------------------------------
void File_Jpeg::APP1_EXIF()
{
//Parsing
Element_Begin1("Exif");
int32u Alignment;
Get_C4(Alignment, "Alignment");
if (Alignment==0x49492A00)
Skip_B4( "First_IFD");
if (Alignment==0x4D4D2A00)
Skip_L4( "First_IFD");
Element_End0();
}
//---------------------------------------------------------------------------
void File_Bmp::BitmapInfoHeader()
{
//Parsing
Element_Begin("Bitmap Info header", 40);
int32u Width, Height, CompressionMethod;
int16u BitsPerPixel;
Skip_L4( "Size");
Get_L4 (Width, "Width");
Get_L4 (Height, "Height");
Skip_L2( "Color planes");
Get_L2 (BitsPerPixel, "Bits per pixel");
Get_L4 (CompressionMethod, "Compression method"); Param_Info(Bmp_CompressionMethod(CompressionMethod));
Skip_L4( "Image size");
Skip_L4( "Horizontal resolution");
Skip_L4( "Vertical resolution");
Skip_L4( "Number of colors in the color palette");
Skip_L4( "Number of important colors used");
Element_End();
FILLING_BEGIN();
Fill(Stream_Image, 0, Image_Width, Width);
Fill(Stream_Image, 0, Image_Height, Height);
Fill(Stream_Image, 0, Image_BitDepth, BitsPerPixel);
Fill(Stream_Image, 0, Image_Format, Bmp_CompressionMethod(CompressionMethod));
Fill(Stream_Image, 0, Image_Codec, Bmp_CompressionMethod(CompressionMethod));
FILLING_END();
}
//---------------------------------------------------------------------------
// RIFF Header, 44 bytes
// RIFF header 4 bytes, Pos=0
// RIFF data size 4 bytes, Pos=4
// Format (CDXA) 4 bytes, Pos=8
// Format Header 4 bytes, Pos=12
// Format Size 4 bytes, Pos=16
// Format user_id 2 bytes, Pos=20
// Format group_id 2 bytes, Pos=22
// Format attributes 2 bytes, Pos=24
// Format xa_signature 2 bytes, Pos=26 ("XA")
// Format xa_track_number 4 bytes, Pos=28
// Format Reserved 4 bytes, Pos=32
// Data Header 4 bytes, Pos=36
// Data Size 4 bytes, Pos=40
//
// Attributes (big endian):
// 15 Directory
// 14 CDDA
// 13 Interleaved
// 12 Mode2Form2 --> 2324 bytes/block
// 11 Mode2Form1 --> 2048 bytes/block
// 10 Exec_Other
// 09 Reserved
// 08 Read_Other
// 07 Reserved
// 06 Exec_Group
// 05 Reserved
// 04 Read_Group
// 03 Reserved
// 02 Exec_User
// 01 Reserved
// 00 Read_User
//
void File_Cdxa::FileHeader_Parse()
{
//Parsing
if ( CC4(Buffer+Buffer_Offset+0x00)!=CC4("RIFF")
|| LittleEndian2int32u(Buffer+Buffer_Offset+0x04)!=LittleEndian2int32u(Buffer+Buffer_Offset+0x28)+0x24 //Sizes of chunks
|| CC4(Buffer+Buffer_Offset+0x08)!=CC4("CDXA")
|| CC4(Buffer+Buffer_Offset+0x0C)!=CC4("fmt ")
|| LittleEndian2int32u(Buffer+Buffer_Offset+0x10)!=0x10
|| CC4(Buffer+Buffer_Offset+0x24)!=CC4("data")
)
{
Finnished();
return;
}
//Parsing
Element_Begin("CDXA header");
Skip_C4( "RIFF header");
Skip_L4( "RIFF data size");
Skip_C4( "CDXA");
Skip_C4( "fmt header");
Skip_L4( "fmt size");
Skip_L2( "user_id");
Skip_L2( "group_id");
Skip_L2( "attributes");
Skip_C2( "xa_signature");
Skip_L4( "xa_track_number");
Skip_L4( "reserved");
Skip_C4( "data header");
Skip_L4( "data size");
Element_End();
FILLING_BEGIN();
if (MI==NULL)
MI=new MediaInfo;
Stream_Prepare(Stream_General);
FILLING_END();
}
//---------------------------------------------------------------------------
void File_La::FileHeader_Parse()
{
//Parsing
Ztring Major, Minor;
int32u SampleRate, Samples, BytesPerSecond, UnCompSize, WAVEChunk, FmtSize, FmtChunk, CRC32;
int16u RawFormat, Channels, BytesPerSample, BitsPerSample;
Skip_Local(2, "signature");
Get_Local (1, Major, "major_version");
Get_Local (1, Minor, "minor_version");
Get_L4 (UnCompSize, "uncompressed_size");
Get_L4 (WAVEChunk, "chunk");
Skip_L4( "fmt_size");
Get_L4 (FmtChunk, "fmt_chunk");
Get_L4 (FmtSize, "fmt_size");
Get_L2 (RawFormat, "raw_format");
Get_L2 (Channels, "channels"); Param_Info2(Channels, " channel(s)");
Get_L4 (SampleRate, "sample_rate");
Get_L4 (BytesPerSecond, "bytes_per_second");
Get_L2 (BytesPerSample, "bytes_per_sample");
Get_L2 (BitsPerSample, "bits_per_sample");
Get_L4 (Samples, "samples");
Skip_L1( "flags");
Get_L4 (CRC32, "crc");
FILLING_BEGIN()
if (SampleRate==0)
return;
Duration=((int64u)Samples/Channels)*1000/SampleRate; // Seems that it's samples per channels otherwise Duration is doubled ??!!
if (Duration==0)
return;
UncompressedSize=(Samples)*Channels*(BitsPerSample/8);
if (UncompressedSize==0)
return;
File__Tags_Helper::Accept("LA");
Fill(Stream_General, 0, General_Format_Version, Major+__T('.')+Minor);
File__Tags_Helper::Stream_Prepare(Stream_Audio);
Fill(Stream_Audio, 0, Audio_Format, "LA");
Fill(Stream_Audio, 0, Audio_Codec, "LA");
Fill(Stream_Audio, 0, Audio_Format_Version, Major+__T('.')+Minor);
Fill(Stream_Audio, 0, Audio_BitDepth, BitsPerSample);
Fill(Stream_Audio, 0, Audio_Channel_s_, Channels);
Fill(Stream_Audio, 0, Audio_SamplingRate, SampleRate);
Fill(Stream_Audio, 0, Audio_Duration, Duration);
//No more need data
File__Tags_Helper::Finish("LA");
FILLING_END();
}
//---------------------------------------------------------------------------
void File_Celt::Identification()
{
Element_Name("Identification");
//Parsing
Ztring celt_version;
int32u Celt_version_id, sample_rate, nb_channels;
Skip_Local(8, "celt_codec_id");
Get_Local(20, celt_version, "celt_version");
Get_L4 (Celt_version_id, "celt_version_id");
Skip_L4( "header_size");
Get_L4 (sample_rate, "rate");
Get_L4 (nb_channels, "nb_channels");
Skip_L4( "frame_size");
Skip_L4( "overlap");
Skip_L4( "bytes_per_packet");
Skip_L4( "extra_headers");
//Filling
FILLING_BEGIN()
Accept("CELT");
Stream_Prepare(Stream_Audio);
Fill(Stream_Audio, 0, Audio_Format, "CELT");
Fill(Stream_Audio, 0, Audio_Codec, "CELT");
if (!celt_version.empty())
{
//Fill(Stream_Audio, 0, Audio_Encoded_Library, celt_version); //Need more info about hte different possibilities, in the meanwhile trusting more the comment part
Fill(Stream_Audio, 0, Audio_SamplingRate, sample_rate);
Fill(Stream_Audio, 0, Audio_Channel_s_, nb_channels);
}
FILLING_END();
//Filling
Identification_Done=true;
}
//---------------------------------------------------------------------------
void File_Cdxa::FileHeader_Parse()
{
//Parsing
Skip_C4( "RIFF header");
Skip_L4( "RIFF data size");
Skip_C4( "CDXA");
Skip_C4( "fmt header");
Skip_L4( "fmt size");
Skip_L2( "user_id");
Skip_L2( "group_id");
Skip_L2( "attributes");
Skip_C2( "xa_signature");
Skip_L4( "xa_track_number");
Skip_L4( "reserved");
Skip_C4( "data header");
Skip_L4( "data size");
FILLING_BEGIN();
MI=new MediaInfo_Internal;
MI->Option(_T("FormatDetection_MaximumOffset"), _T("1048576"));
Stream_Prepare(Stream_General);
Accept("CDXA");
FILLING_END();
}
//---------------------------------------------------------------------------
void File_Speex::Identification()
{
Element_Name("Identification");
//Parsing
Ztring speex_version;
int32u Speex_version_id, header_size, rate, nb_channels, bitrate, vbr;
Skip_Local(8, "speex_string");
Get_Local(20, speex_version, "speex_version");
Get_L4 (Speex_version_id, "Speex_version_id");
if (Speex_version_id==1)
{
Get_L4 (header_size, "header_size");
Get_L4 (rate, "rate");
Skip_L4( "mode");
Skip_L4( "mode_bitstream_version");
Get_L4 (nb_channels, "nb_channels");
Get_L4 (bitrate, "bitrate");
Skip_L4( "frame_size");
Get_L4 (vbr, "vbr");
Skip_L4( "frames_per_packet");
Skip_L4( "extra_headers");
Skip_L4( "reserved1");
Skip_L4( "reserved2");
if (header_size<Element_Size)
Skip_XX(Element_Size-header_size, "Unknown");
//Filling
FILLING_BEGIN()
Accept("Speex");
Stream_Prepare(Stream_Audio);
Fill(Stream_Audio, 0, Audio_Format, "Speex");
Fill(Stream_Audio, 0, Audio_Codec, "Speex");
if (Speex_version_id==1)
{
if (!speex_version.empty())
Fill(Stream_Audio, 0, Audio_Encoded_Library, speex_version);
Fill(Stream_Audio, 0, Audio_SamplingRate, rate);
Fill(Stream_Audio, 0, Audio_Channel_s_, nb_channels);
if (bitrate!=(int32u)-1)
Fill(Stream_Audio, 0, Audio_BitRate, bitrate);
Fill(Stream_Audio, 0, Audio_BitRate_Mode, vbr?"VBR":"CBR");
}
FILLING_END();
}
//Filling
Identification_Done=true;
}
//---------------------------------------------------------------------------
void File_Dpg::FileHeader_Parse()
{
//Parsing
int32u FrameCount, FrameRate, SamplingRate;
Skip_C4( "Signature");
Get_L4 (FrameCount, "Frame count");
Get_L4 (FrameRate, "Frame rate"); Param_Info2(FrameRate/0x100, " fps");
Get_L4 (SamplingRate, "Sampling rate");
Skip_L4( "0x00000000");
Get_L4 (Audio_Offset, "Audio Offset");
Get_L4 (Audio_Size, "Audio Size");
Get_L4 (Video_Offset, "Video Offset");
Get_L4 (Video_Size, "Video Size");
FILLING_BEGIN();
Accept("DPG");
Fill(Stream_General, 0, General_Format, "DPG");
Stream_Prepare(Stream_Video);
Fill(Stream_Video, 0, Video_FrameRate, (float)(FrameRate/0x100), 3);
Fill(Stream_Video, 0, Video_FrameCount, FrameCount);
Fill(Stream_Video, 0, Video_StreamSize, Video_Size);
Stream_Prepare(Stream_Audio);
Fill(Stream_Audio, 0, Audio_SamplingRate, SamplingRate);
Fill(Stream_Audio, 0, Audio_StreamSize, Audio_Size);
//Positionning
#if defined(MEDIAINFO_MPEGA_YES)
Parser=new File_Mpega();
Open_Buffer_Init(Parser);
GoTo(Audio_Offset, "DPG");
#elif defined(MEDIAINFO_MPEGV_YES)
Audio_Size=0;
Parser=new File_Mpegv();
Open_Buffer_Init(Parser);
GoTo(Video_Offset, "DPG");
#else
Finish("DPG");
#endif
FILLING_END();
}
//---------------------------------------------------------------------------
void File_Ogg::Header_Parse()
{
//Parsing
int64u absolute_granule_position;
int32u stream_serial_number, page_sequence_no;
int16u total_page_size;
int8u stream_structure_version, flags, page_segments, packet_lacing_value;
Skip_C4( "capture_pattern");
Get_L1 (stream_structure_version, "stream_structure_version");
Get_L1 (flags, "header_type_flag");
Get_Flags (flags, 0, continued, "continued packet");
Skip_Flags(flags, 1, "first page of logical bitstream (bos)");
Skip_Flags(flags, 2, "last page of logical bitstream (eos)");
Get_L8 (absolute_granule_position, "absolute granule position");
Get_L4 (stream_serial_number, "stream serial number");
Get_L4 (page_sequence_no, "page sequence no");
Skip_L4( "page checksum");
Get_L1 (page_segments, "page_segments");
total_page_size=0;
Chunk_Sizes.clear();
Chunk_Sizes.push_back(0);
for (int8u Pos=0; Pos<page_segments; Pos++)
{
Get_L1 (packet_lacing_value, "packet lacing value");
total_page_size+=packet_lacing_value;
Chunk_Sizes[Chunk_Sizes.size()-1]+=packet_lacing_value;
if (packet_lacing_value!=0xFF)
{
Chunk_Sizes.push_back(0);
Chunk_Sizes_Finnished=true;
}
else
Chunk_Sizes_Finnished=false;
}
if (Chunk_Sizes_Finnished)
Chunk_Sizes.resize(Chunk_Sizes.size()-1); //Keep out the last value
//Filling
Header_Fill_Size(27+page_segments+total_page_size);
Header_Fill_Code(stream_serial_number, Ztring::ToZtring(stream_serial_number, 16));
Stream[stream_serial_number].absolute_granule_position=absolute_granule_position;
}
//---------------------------------------------------------------------------
void File_Exr::Header()
{
//Parsing
int32u Flags;
int8u Version;
Skip_L4( "Magic number");
Get_L1 (Version, "Version field");
Get_L3 (Flags, "Flags");
//Filling
if (Frame_Count==0)
{
Fill(Stream_General, 0, General_Format_Version, _T("Version ")+Ztring::ToZtring(Version));
Fill(StreamKind_Last, 0, "Format", "EXR");
Fill(StreamKind_Last, 0, "Format_Version", _T("Version ")+Ztring::ToZtring(Version));
Fill(StreamKind_Last, 0, "Format_Profile", (Flags&0x02)?"Tile":"Line");
}
Frame_Count++;
if (Frame_Count_NotParsedIncluded!=(int64u)-1)
Frame_Count_NotParsedIncluded++;
ImageData_End=File_Offset+Buffer_Offset+Config->File_Sizes[Config->File_Names_Pos-1];
}
//---------------------------------------------------------------------------
void File_Fraps::Read_Buffer_Continue()
{
//Parsing
int8u version, flags;
Get_L1 (version, "version");
Skip_L2( "unknown");
Get_L1 (flags, "flags");
if (flags&0x40)
Skip_L4( "unknown");
switch (version)
{
case 0x00 :
Version0(); break;
case 0x01 :
Version1(); break;
case 0x02 :
case 0x04 :
Version2(); break;
default : Skip_XX(Element_Size-Element_Offset, "data");
}
Finish();
}
//---------------------------------------------------------------------------
void File_Wvpk::Data_Parse()
{
//Specific
if (FromMKV && !FromMKV_CodecPrivateParsed)
{
//Parsing
Get_L2 (version, "version");
FILLING_BEGIN();
FromMKV_CodecPrivateParsed=true;
FILLING_END();
return;
}
//Counting
Frame_Count++;
//Parsing
Element_Begin("Block Header");
if (!FromMKV)
Get_L2 (version, "version");
if (version/0x100==0x4)
{
while (Element_Offset<Element_Size)
{
int32u total_samples=(int32u)-1, block_index=(int32u)-1, block_samples=0, flags, blocksize=(int32u)-1;
bool initial_block=true, final_block=true;
if (!FromMKV)
{
Skip_L1( "track_no");
Skip_L1( "index_no");
Get_L4 (total_samples, "total_samples");
Get_L4 (block_index, "block_index");
}
if (!FromMKV || (FromMKV && Element_Offset==0))
Get_L4 (block_samples, "block_samples");
if (block_samples!=0) //empty frames have other values empty
{
if (!FromMKV)
{
if (block_index==0) //Only the frame with block_index==0
total_samples_FirstFrame=total_samples; //Note: total_samples is not trustable for a cutted file
if (Frame_Count==1)
block_index_FirstFrame=block_index; //Save the block_index of the first block
block_index_LastFrame=block_index;
block_samples_LastFrame=block_samples;
}
Get_L4 (flags, "flags");
Get_Flags (flags, 0, resolution0, "resolution0");
Get_Flags (flags, 1, resolution1, "resolution1");
Get_Flags (flags, 2, mono, "mono");
Get_Flags (flags, 3, hybrid, "hybrid");
Get_Flags (flags, 4, joint_stereo, "joint stereo");
Get_Flags (flags, 5, cross_channel_decorrelation, "cross-channel decorrelation");
Skip_Flags(flags, 6, "hybrid noise shaping");
Skip_Flags(flags, 7, "floating point data");
Skip_Flags(flags, 8, "extended size integers");
Skip_Flags(flags, 9, "hybrid mode parameters control bitrate");
Skip_Flags(flags, 10, "hybrid noise balanced between channels");
Get_Flags (flags, 11, initial_block, "initial block in sequence");
Get_Flags (flags, 12, final_block, "final block in sequence");
Skip_Flags(flags, 13, "amount of data left-shift after decode");
Skip_Flags(flags, 14, "amount of data left-shift after decode");
Skip_Flags(flags, 15, "amount of data left-shift after decode");
Skip_Flags(flags, 16, "amount of data left-shift after decode");
Skip_Flags(flags, 17, "amount of data left-shift after decode");
Skip_Flags(flags, 18, "maximum magnitude of decoded data");
Skip_Flags(flags, 19, "maximum magnitude of decoded data");
Skip_Flags(flags, 20, "maximum magnitude of decoded data");
Skip_Flags(flags, 21, "maximum magnitude of decoded data");
Skip_Flags(flags, 22, "maximum magnitude of decoded data");
Skip_Flags(flags, 23, "sampling rate");
Skip_Flags(flags, 24, "sampling rate");
Skip_Flags(flags, 25, "sampling rate");
Skip_Flags(flags, 26, "sampling rate"); SamplingRate=(int8u)(((flags>>23)&0xF)); Param_Info(Wvpk_SamplingRate[SamplingRate]);
Skip_Flags(flags, 27, "reserved");
Skip_Flags(flags, 28, "reserved");
Skip_Flags(flags, 29, "use IIR for negative hybrid noise shaping");
Skip_Flags(flags, 30, "false stereo");
Skip_Flags(flags, 31, "reserved");
}
else
{
Skip_L4( "flags (empty)");
//Counting
Frame_Count--; //This is not a real frame
}
Skip_L4( "crc");
Element_End();
int64u End=Element_Size;
if (FromMKV && !(initial_block && final_block))
{
Get_L4 (blocksize, "blocksize");
End=Element_Offset+blocksize;
if (End>=Element_Size)
End=Element_Size;
}
//Sub-block
int8u id;
while (Element_Offset<End)
{
Element_Begin();
int32u word_size;
bool large, odd_size;
BS_Begin();
Get_SB (large, "large");
Get_SB (odd_size, "odd_size");
Get_S1 (6, id, "id"); Element_Info(Wvpk_id(id));
BS_End();
if (large)
{
Get_L3 (word_size, "word_size");
}
else
{
int8u word_size1;
Get_L1 (word_size1, "word_size");
word_size=word_size1;
}
if (word_size==0 && odd_size)
Size=0; //Problem!
else
Size=word_size*2-(odd_size?1:0);
Element_Name(Ztring().From_CC1(id));
switch (id)
{
case 0x07 : id_07(); break;
case 0x0D : id_0D(); break;
case 0x25 : id_25(); break;
default : if (word_size)
Skip_XX(Size, "data");
}
if (odd_size)
Skip_XX(1, "padding");
Element_End();
}
}
}
//---------------------------------------------------------------------------
void File_Mz::FileHeader_Parse()
{
//Parsing
int32u lfanew;
int16u magic;
Element_Begin("MZ");
Get_C2 (magic, "magic");
if (magic!=0x4D5A) //"MZ"
{
Finished();
return;
}
Skip_L2( "cblp");
Skip_L2( "cp");
Skip_L2( "crlc");
Skip_L2( "cparhdr");
Skip_L2( "minalloc");
Skip_L2( "maxalloc");
Skip_L2( "ss");
Skip_L2( "sp");
Skip_L2( "csum");
Skip_L2( "ip");
Skip_L2( "cs");
Skip_L2( "lsarlc");
Skip_L2( "ovno");
Skip_L2( "res");
Skip_L2( "res");
Skip_L2( "res");
Skip_L2( "res");
Skip_L2( "oemid");
Skip_L2( "oeminfo");
Skip_L2( "res2");
Skip_L2( "res2");
Skip_L2( "res2");
Skip_L2( "res2");
Skip_L2( "res2");
Skip_L2( "res2");
Skip_L2( "res2");
Skip_L2( "res2");
Skip_L2( "res2");
Skip_L2( "res2");
Get_L4 (lfanew, "lfanew");
//Computing
if (lfanew>Element_Offset)
{
Skip_XX(lfanew-Element_Offset, "MZ data");
Element_End();
}
if (Element_Offset>lfanew)
{
Element_End();
Element_Offset=lfanew; //Multi usage off the first bytes
}
//Parsing
int32u Signature, TimeDateStamp=0;
int16u Machine=0, Characteristics=0;
Peek_B4(Signature);
if (Signature==0x50450000) //"PE"
{
Element_Begin("PE");
Skip_C4( "Header");
Get_L2 (Machine, "Machine"); Param_Info(Mz_Machine(Machine));
Skip_L2( "NumberOfSections");
Get_L4 (TimeDateStamp, "TimeDateStamp"); Param_Info(Ztring().Date_From_Seconds_1970(TimeDateStamp));
Skip_L4( "PointerToSymbolTable");
Skip_L4( "NumberOfSymbols");
Skip_L2( "SizeOfOptionalHeader");
Get_L2 (Characteristics, "Characteristics");
Element_End("PE");
}
//Filling
Stream_Prepare(Stream_General);
Fill(Stream_General, 0, General_Format, "MZ");
if (Characteristics&0x2000)
Fill(Stream_General, 0, General_Format_Profile, "DLL");
else if (Characteristics&0x0002)
Fill(Stream_General, 0, General_Format_Profile, "Executable");
Fill(Stream_General, 0, General_Format_Profile, Mz_Machine(Machine));
if (TimeDateStamp)
Fill(Stream_General, 0, General_Encoded_Date, Ztring().Date_From_Seconds_1970(TimeDateStamp));
//No need of more
Finished();
}
//---------------------------------------------------------------------------
// archive header
void File_Rar::Header_Parse_Content_73()
{
Skip_L2( "RESERVED_1");
Skip_L4( "RESERVED_2");
}
//---------------------------------------------------------------------------
void File_Umf::Read_Buffer_Continue()
{
//Parsing
int32u Tracks, Segments;
Element_Begin1("Payload description");
Skip_L4( "Total length of the UMF data");
Skip_L4( "Version of this file");
Get_L4 (Tracks, "Number of tracks in the material");
Skip_L4( "Offset to track description section");
Skip_L4( "Size of the track description section");
Get_L4 (Segments, "Number of segments");
Skip_L4( "Offset to media description section");
Skip_L4( "Size of the media description section");
Skip_L4( "Offset to the user data section");
Skip_L4( "Size of the user data section");
Skip_L4( "Reserved");
Skip_L4( "Reserved");
Element_End0();
Element_Begin1("Material description");
Skip_L4( "Attributes");
Skip_L4( "Maximum length of the material in fields");
Skip_L4( "Minimum length of the material in fields");
Skip_L4( "Material mark in value in fields");
Skip_L4( "Material mark out value in fields");
Skip_L4( "Time code at mark in value");
Skip_L4( "Time code at mark out value");
Skip_L4( "last modified time (Most)");
Skip_L4( "last modified time (Least)");
Skip_L4( "creation time (Most)");
Skip_L4( "creation time (Least)");
Skip_L2( "Reserved");
Skip_L2( "Reserved");
Skip_L2( "Number of audio tracks");
Skip_L2( "Number of time code tracks");
Skip_L2( "Reserved");
Skip_L2( "Number of MPEG-1, MPEG-2, and MPEG-2 HD video tracks");
Element_End0();
for (int32u Pos=0; Pos<Tracks; Pos++)
{
Element_Begin1("Track description");
Skip_C1( "Track information - Track type");
Skip_C1( "Track information - Track logical number");
Skip_L2( "Number of segments on this track");
Element_End0();
if (Element_Offset>=Element_Size)
break;
}
for (int32u Pos=0; Pos<Segments; Pos++)
{
Element_Begin1("Media description");
int32u Type;
int16u Length;
Get_L2 (Length, "Length of this media description");
int64u End=Element_Offset+Length-2;
Skip_C1( "Track information - Track type");
Skip_C1( "Track information - Track logical number");
Skip_L2( "Media Sequence number");
Skip_L2( "Reserved");
Skip_L4( "Number of fields in segment");
Skip_L4( "Reserved");
Skip_L4( "Mark in value for the media file in fields");
Skip_L4( "Mark out value for the media file in fields");
Skip_Local(88, "Source device media file name");
Get_L4 (Type, "Type of media track");
Skip_L4( "Sampling rates for this track");
Skip_L4( "Size of sample for audio and time codes");
Skip_L4( "Reserved");
switch (Type)
{
case 0x00000004 :
case 0x00000007 :
case 0x00000009 : //MPEG-Video
{
#if MEDIAINFO_SEEK || MEDIAINFO_DEMUX
int32u P, B;
#endif //MEDIAINFO_SEEK || MEDIAINFO_DEMUX
Skip_L4( "Color difference format");
Skip_L4( "GoP structure");
Skip_L4( "Frame/field structure");
Skip_L4( "Target I-pictures per GoP");
#if MEDIAINFO_SEEK || MEDIAINFO_DEMUX
Get_L4 (P, "Target P-pictures per I-picture");
Get_L4 (B, "Target B-pictures per P-picture or I-picture");
#else //MEDIAINFO_SEEK || MEDIAINFO_DEMUX
Skip_L4( "Target P-pictures per I-picture");
Skip_L4( "Target B-pictures per P-picture or I-picture");
#endif //MEDIAINFO_SEEK || MEDIAINFO_DEMUX
Skip_L4( "MPEG video attributes");
Skip_L4( "Reserved");
#if MEDIAINFO_SEEK || MEDIAINFO_DEMUX
GopSize=(1+P)*(1+B);
#endif //MEDIAINFO_SEEK || MEDIAINFO_DEMUX
}
break;
case 0x00000003 : //TimeCode
Skip_L4( "Time code attributes");
Skip_L4( "Reserved");
Skip_L4( "Reserved");
Skip_L4( "Reserved");
Skip_L4( "Reserved");
Skip_L4( "Reserved");
Skip_L4( "Reserved");
Skip_L4( "Reserved");
break;
case 0x00000002 : //Audio
//Skip_LF8( "Level at which to play this segment");
//Skip_LF8( "Level at which to terminate this segment");
Skip_L8( "Level at which to play this segment");
Skip_L8( "Level at which to terminate this segment");
Skip_L4( "Number of fields over which to ramp up");
Skip_L4( "Number of fields over which to ramp down");
Skip_L4( "Reserved");
Skip_L4( "Reserved");
break;
case 0x00000005 : //DV25
case 0x00000006 : //DV50
Skip_L4( "Attributes"); //With Aspect ratio
Skip_L4( "Reserved");
Skip_L4( "Reserved");
Skip_L4( "Reserved");
Skip_L4( "Reserved");
Skip_L4( "Reserved");
Skip_L4( "Reserved");
Skip_L4( "Reserved");
#if MEDIAINFO_SEEK || MEDIAINFO_DEMUX
GopSize=1;
#endif //MEDIAINFO_SEEK || MEDIAINFO_DEMUX
break;
default :
Skip_L4( "Reserved");
Skip_L4( "Reserved");
Skip_L4( "Reserved");
Skip_L4( "Reserved");
Skip_L4( "Reserved");
Skip_L4( "Reserved");
Skip_L4( "Reserved");
Skip_L4( "Reserved");
}
if (Element_Offset<End)
Skip_XX(End-Element_Offset, "Unknown");
Element_End0();
if (Element_Offset>=Element_Size)
break;
}
while (Element_Offset<Element_Size)
{
Element_Begin1("User data");
int32u Length;
Get_L4 (Length, "The length of this user data record");
Skip_L4( "Position on the material time line");
Skip_L2( "Track associated with the user data record");
Skip_L2( "Media Sequence Numbe");
Skip_L4( "User-defined key");
if (Length>18)
Skip_XX(Length-18, "User data");
else
Skip_XX(Element_Size-Element_Offset-2, "User data");
Skip_L1( "NULL byte");
Skip_L1( "Reserved byte");
Element_End0();
}
}
//---------------------------------------------------------------------------
void File_Mz::Read_Buffer_Continue()
{
//Parsing
int32u lfanew;
Element_Begin1("MZ");
Skip_C2( "magic");
Skip_L2( "cblp");
Skip_L2( "cp");
Skip_L2( "crlc");
Skip_L2( "cparhdr");
Skip_L2( "minalloc");
Skip_L2( "maxalloc");
Skip_L2( "ss");
Skip_L2( "sp");
Skip_L2( "csum");
Skip_L2( "ip");
Skip_L2( "cs");
Skip_L2( "lsarlc");
Skip_L2( "ovno");
Skip_L2( "res");
Skip_L2( "res");
Skip_L2( "res");
Skip_L2( "res");
Skip_L2( "oemid");
Skip_L2( "oeminfo");
Skip_L2( "res2");
Skip_L2( "res2");
Skip_L2( "res2");
Skip_L2( "res2");
Skip_L2( "res2");
Skip_L2( "res2");
Skip_L2( "res2");
Skip_L2( "res2");
Skip_L2( "res2");
Skip_L2( "res2");
Get_L4 (lfanew, "lfanew");
//Computing
if (lfanew>Element_Offset)
{
Skip_XX(lfanew-Element_Offset, "MZ data");
Element_End0();
}
if (Element_Offset>lfanew)
{
Element_End0();
Element_Offset=lfanew; //Multi usage off the first bytes
}
//Parsing
int32u Signature, TimeDateStamp=0;
int16u Machine=0, Characteristics=0;
Peek_B4(Signature);
if (Signature==0x50450000) //"PE"
{
Element_Begin1("PE");
Skip_C4( "Header");
Get_L2 (Machine, "Machine"); Param_Info1(Mz_Machine(Machine));
Skip_L2( "NumberOfSections");
Get_L4 (TimeDateStamp, "TimeDateStamp"); Param_Info1(Ztring().Date_From_Seconds_1970(TimeDateStamp));
Skip_L4( "PointerToSymbolTable");
Skip_L4( "NumberOfSymbols");
Skip_L2( "SizeOfOptionalHeader");
Get_L2 (Characteristics, "Characteristics");
Element_End0();
}
FILLING_BEGIN();
Accept("MZ");
Fill(Stream_General, 0, General_Format, "MZ");
if (Characteristics&0x2000)
Fill(Stream_General, 0, General_Format_Profile, "DLL");
else if (Characteristics&0x0002)
Fill(Stream_General, 0, General_Format_Profile, "Executable");
Fill(Stream_General, 0, General_Format_Profile, Mz_Machine(Machine));
if (TimeDateStamp)
Fill(Stream_General, 0, General_Encoded_Date, Ztring().Date_From_Seconds_1970(TimeDateStamp));
//No more need data
Finish("MZ");
FILLING_END();
}
//---------------------------------------------------------------------------
void File_Ogg::Header_Parse()
{
//Specific case
if (SizedBlocks)
{
int16u Size;
Get_B2 (Size, "Size");
Chunk_Sizes.clear();
Chunk_Sizes.push_back(Size);
Header_Fill_Size(2+Size);
Header_Fill_Code(0, Ztring::ToZtring(0, 16));
return;
}
if (XiphLacing)
{
if (Chunk_Sizes.empty())
{
int8u CountMinus1;
Get_B1 (CountMinus1, "Number of frames minus one");
int64u UsedSize=0;
for (size_t Pos=0; Pos<CountMinus1; Pos++)
{
int32u Size=0;
int8u Size8;
do
{
Get_B1 (Size8, "Size");
Size+=Size8;
}
while (Size8==0xFF);
Param_Info1(Size);
Chunk_Sizes.push_back(Size);
UsedSize+=Size;
}
Chunk_Sizes.push_back((size_t)(Element_Size-UsedSize-1));
}
Header_Fill_Size(Element_Size);
Header_Fill_Code(0, Ztring::ToZtring(0, 16));
return;
}
//Parsing
int64u absolute_granule_position;
int32u stream_serial_number, page_sequence_no;
int16u total_page_size;
int8u stream_structure_version, flags, page_segments, packet_lacing_value;
Skip_C4( "capture_pattern");
Get_L1 (stream_structure_version, "stream_structure_version");
Get_L1 (flags, "header_type_flag");
Get_Flags (flags, 0, continued, "continued packet");
Skip_Flags(flags, 1, "first page of logical bitstream (bos)");
Get_Flags (flags, 2, eos, "last page of logical bitstream (eos)");
Get_L8 (absolute_granule_position, "absolute granule position");
Get_L4 (stream_serial_number, "stream serial number");
Get_L4 (page_sequence_no, "page sequence no");
Skip_L4( "page checksum");
Get_L1 (page_segments, "page_segments");
total_page_size=0;
Chunk_Sizes.clear();
Chunk_Sizes.push_back(0);
for (int8u Pos=0; Pos<page_segments; Pos++)
{
Get_L1 (packet_lacing_value, "packet lacing value");
total_page_size+=packet_lacing_value;
Chunk_Sizes[Chunk_Sizes.size()-1]+=packet_lacing_value;
if (packet_lacing_value!=0xFF)
{
Chunk_Sizes.push_back(0);
Chunk_Sizes_Finished=true;
}
else
Chunk_Sizes_Finished=false;
}
if (Chunk_Sizes_Finished)
Chunk_Sizes.resize(Chunk_Sizes.size()-1); //Keep out the last value
//Filling
Header_Fill_Size(27+page_segments+total_page_size);
Header_Fill_Code(stream_serial_number, Ztring::ToZtring(stream_serial_number, 16));
Stream[stream_serial_number].absolute_granule_position=absolute_granule_position;
}
