void File_Ibi::Stream_FrameNumber()
{
Element_Name("Frame Number");
//Parsing
size_t Pos=0;
int64u Offset=0;
while (Element_Offset<Element_Size)
{
int64u Item;
Get_EB (Item, "Item");
Offset+=Item;
Param_Info1(Pos);
Param_Info1(Ztring::ToZtring(Offset)+__T(" (0x")+Ztring::ToZtring(Offset, 16)+__T(')'));
FILLING_BEGIN();
if (Ibi)
{
//Filling information for ID after data
if (Ibi->Streams[ID_Current]==NULL)
Ibi->Streams[ID_Current]=new ibi::stream();
if (Pos>=Ibi->Streams[ID_Current]->Infos.size())
{
Ibi->Streams[ID_Current]->Infos.push_back(ibi::stream::info());
Ibi->Streams[ID_Current]->Infos[Pos].IsContinuous=true; //default
}
Ibi->Streams[ID_Current]->Infos[Pos].FrameNumber=Offset;
Pos++;
}
FILLING_END();
}
}
//---------------------------------------------------------------------------
void File_Tiff::Read_Directory()
{
/* Each directory consist of 4 fields */
/* Get information for this directory */
Element_Begin0();
ifditem IfdItem;
Get_X2 (IfdItem.Tag, "Tag"); Param_Info1(Tiff_Tag_Name(IfdItem.Tag));
Get_X2 (IfdItem.Type, "Type"); Param_Info1(Tiff_Type_Name(IfdItem.Type));
Get_X4 (IfdItem.Count, "Count");
Element_Name(Tiff_Tag_Name(IfdItem.Tag));
if (Tiff_Type_Size(IfdItem.Type)*IfdItem.Count<=4)
{
GetValueOffsetu(IfdItem);
/* Padding up, skip dummy bytes */
if (Tiff_Type_Size(IfdItem.Type)==0)
{
if (Element_Offset+4<Element_Size)
Skip_XX(Element_Size-(Element_Offset+4), "Unknown");
}
else if (Tiff_Type_Size(IfdItem.Type)*IfdItem.Count<4)
Skip_XX(Tiff_Type_Size(IfdItem.Type)*IfdItem.Count, "Padding");
}
else
{
int32u IFDOffset;
Get_X4 (IFDOffset, "IFDOffset");
IfdItems[IFDOffset]=IfdItem;
}
Element_End0();
}
void File_Ibi::Stream_Dts()
{
Element_Name("DTS");
//Parsing
int64u Item;
Get_EB (Item, "DtsFrequencyNumerator");
#if MEDIAINFO_IBIUSAGE
FILLING_BEGIN();
if (Ibi)
Ibi->Streams[ID_Current]->DtsFrequencyNumerator=Item;
FILLING_END();
#endif //MEDIAINFO_IBIUSAGE
Get_EB (Item, "DtsFrequencyDenominator");
#if MEDIAINFO_IBIUSAGE
FILLING_BEGIN();
if (Ibi)
{
Ibi->Streams[ID_Current]->DtsFrequencyDenominator=Item;
//Handling of previous inverted Numerator/Denominator
if (Ibi->Streams[ID_Current]->DtsFrequencyNumerator<Ibi->Streams[ID_Current]->DtsFrequencyDenominator)
std::swap(Ibi->Streams[ID_Current]->DtsFrequencyNumerator, Ibi->Streams[ID_Current]->DtsFrequencyDenominator);
}
FILLING_END();
#endif //MEDIAINFO_IBIUSAGE
#if MEDIAINFO_IBIUSAGE
size_t Pos=0;
#endif //MEDIAINFO_IBIUSAGE
int64u Offset=0;
while (Element_Offset<Element_Size)
{
int64u Item;
Get_EB (Item, "Item");
Offset+=Item;
#if MEDIAINFO_IBIUSAGE
Param_Info1(Pos);
#endif //MEDIAINFO_IBIUSAGE
Param_Info1(Ztring::ToZtring(Offset)+__T(" (0x")+Ztring::ToZtring(Offset, 16)+__T(')'));
#if MEDIAINFO_IBIUSAGE
FILLING_BEGIN();
if (Ibi)
{
//Filling information for ID after data
if (Ibi->Streams[ID_Current]==NULL)
Ibi->Streams[ID_Current]=new ibi::stream();
if (Pos>=Ibi->Streams[ID_Current]->Infos.size())
{
Ibi->Streams[ID_Current]->Infos.push_back(ibi::stream::info());
Ibi->Streams[ID_Current]->Infos[Pos].IsContinuous=true; //default
}
Ibi->Streams[ID_Current]->Infos[Pos].Dts=Offset;
Pos++;
}
FILLING_END();
#endif //MEDIAINFO_IBIUSAGE
}
}
//---------------------------------------------------------------------------
void File_Dpx::GenericSectionHeader_Dpx_ImageElement()
{
Element_Begin1("image element");
int8u Descriptor, TransferCharacteristic, ColorimetricSpecification, BitDephs;
Info_B4(DataSign, "Data sign");Param_Info1((DataSign==0?"unsigned":"signed"));
Skip_B4( "Reference low data code value");
Skip_BF4( "Reference low quantity represented");
Skip_B4( "Reference high data code value");
Skip_BF4( "Reference high quantity represented");
Get_B1 (Descriptor, "Descriptor");Param_Info1(DPX_Descriptors(Descriptor));
Get_B1 (TransferCharacteristic, "Transfer characteristic");Param_Info1(DPX_TransferCharacteristic(TransferCharacteristic));
Get_B1 (ColorimetricSpecification, "Colorimetric specification");Param_Info1(DPX_ColorimetricSpecification(ColorimetricSpecification));
Get_B1 (BitDephs, "Bit depth");Param_Info1(DPX_ValidBitDephs(BitDephs));
Info_B2(ComponentDataPackingMethod, "Packing");Param_Info1((ComponentDataPackingMethod<8?DPX_ComponentDataPackingMethod[ComponentDataPackingMethod]:"invalid"));
Info_B2(ComponentDataEncodingMethod, "Encoding");Param_Info1((ComponentDataEncodingMethod<8?DPX_ComponentDataEncodingMethod[ComponentDataEncodingMethod]:"invalid"));
Skip_B4( "Offset to data");
Skip_B4( "End-of-line padding");
Skip_B4( "End-of-image padding");
Skip_UTF8(32, "Description of image element");
Element_End0();
FILLING_BEGIN();
if (Frame_Count==0)
{
Fill(StreamKind_Last, StreamPos_Last, "ColorSpace", DPX_Descriptors_ColorSpace(Descriptor));
Fill(StreamKind_Last, StreamPos_Last, "ChromaSubsampling", DPX_Descriptors_ChromaSubsampling(Descriptor));
Fill(StreamKind_Last, StreamPos_Last, "BitDepth", BitDephs);
Fill(StreamKind_Last, StreamPos_Last, "colour_description_present", "Yes");
Fill(StreamKind_Last, StreamPos_Last, "colour_primaries", DPX_TransferCharacteristic(TransferCharacteristic));
Fill(StreamKind_Last, StreamPos_Last, "transfer_characteristics", DPX_ColorimetricSpecification(ColorimetricSpecification));
}
FILLING_END();
}
//---------------------------------------------------------------------------
// Packet "B0"
void File_AvsV::video_sequence_start()
{
Element_Name("video_sequence_start");
//Parsing
int32u bit_rate_upper, bit_rate_lower;
Get_B1 ( profile_id, "profile_id");
Get_B1 ( level_id, "level_id");
BS_Begin();
Get_SB ( progressive_sequence, "progressive_sequence");
Get_S2 (14, horizontal_size, "horizontal_size");
Get_S2 (14, vertical_size, "vertical_size");
Get_S1 ( 2, chroma_format, "chroma_format");
Skip_S1( 3, "sample_precision");
Get_S1 ( 4, aspect_ratio, "aspect_ratio"); Param_Info1(AvsV_aspect_ratio[aspect_ratio]);
Get_S1 ( 4, frame_rate_code, "frame_rate_code"); Param_Info1(AvsV_frame_rate[frame_rate_code]);
Get_S3 (18, bit_rate_lower, "bit_rate_lower");
Mark_1 ();
Get_S3 (12, bit_rate_upper, "bit_rate_upper");
bit_rate=(bit_rate_upper<<18)+bit_rate_lower; Param_Info2(bit_rate*8, " bps");
Get_SB ( low_delay, "low_delay");
Mark_1 ();
Skip_S3(18, "bbv_buffer_size");
Skip_SB( "reserved");
Skip_SB( "reserved");
Skip_SB( "reserved");
BS_End();
//Not sure, but the 3 first official files have this
if (Element_Size-Element_Offset)
{
BS_Begin();
Mark_1();
BS_End();
}
FILLING_BEGIN();
//NextCode
NextCode_Clear();
NextCode_Add(0xB2); //user_data_start
NextCode_Add(0xB3); //picture_start (I)
NextCode_Add(0xB5); //extension_start
//Autorisation of other streams
Streams[0xB1].Searching_Payload=true, //video_sequence_end
Streams[0xB2].Searching_Payload=true; //user_data_start
Streams[0xB3].Searching_Payload=true, //picture_start (I)
Streams[0xB4].Searching_Payload=true, //reserved
Streams[0xB5].Searching_Payload=true; //extension_start
Streams[0xB6].Searching_Payload=true, //picture_start (P or B)
Streams[0xB7].Searching_Payload=true; //video_edit
Streams[0xB8].Searching_Payload=true, //reserved
video_sequence_start_IsParsed=true;
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_MpcSv8::SH()
{
//Parsing
int64u SampleCount;
int8u Version, SampleFrequency, ChannelCount;
bool MidSideStereo;
Skip_B4( "CRC32");
Get_B1 (Version, "Version");
Get_VS (SampleCount, "Sample count");
Skip_VS( "Beginning silence");
BS_Begin();
Get_S1 (3, SampleFrequency, "Sample frequency"); Param_Info1(Mpc_SampleFreq[SampleFrequency]);
Skip_S1(5, "Max used bands");
Get_S1 (4, ChannelCount, "Channel count");
Get_SB ( MidSideStereo, "Mid side stereo used");
Skip_S1(3, "Audio block frames");
BS_End();
//Filling
FILLING_BEGIN();
Fill(Stream_Audio, 0, Audio_SamplingRate, Mpc_SampleFreq[SampleFrequency]);
if (SampleCount)
{
Fill(Stream_Audio, 0, Audio_SamplingCount, SampleCount);
Fill(Stream_Audio, 0, Audio_Duration, SampleCount*1000/Mpc_SampleFreq[SampleFrequency]);
Fill(Stream_Audio, 0, Audio_BitRate, File_Size*8*Mpc_SampleFreq[SampleFrequency]/SampleCount); //Should be more precise...
}
Fill(Stream_Audio, 0, Audio_BitDepth, 16); //MPC support only 16 bits
FILLING_END();
}
//---------------------------------------------------------------------------
void File_Vc3::ImageGeometry()
{
//Parsing
Element_Begin1("Image Geometry");
Get_B2 (ALPF, "Active lines-per-frame");
Get_B2 (SPL, "Samples-per-line");
Skip_B1( "Zero");
Skip_B2( "Number of active lines");
Skip_B2( "Zero");
BS_Begin();
Get_S1 (3, SBD, "Sample bit depth");
Mark_1();
Mark_1();
Mark_0();
Mark_0();
Mark_0();
Mark_1();
Mark_0();
Mark_0();
Mark_0();
Mark_1();
Get_SB ( SST, "Source scan type"); Param_Info1(Vc3_SST[SST]);
Mark_0();
Mark_0();
BS_End();
Element_End0();
}
//---------------------------------------------------------------------------
void File_Psd::Read_Buffer_Continue()
{
//Parsing
int32u Width, Height;
int16u BitsDepth, Version, channels, ColorMode;
Skip_C4( "Signature");
Get_B2 (Version, "Version"); // 1 = PSD, 2 = PSB
Skip_B6( "Reserved");
Get_B2 (channels, "channels"); // 1 to 56, including alpha channel
Get_B4 (Height, "Height");
Get_B4 (Width, "Width");
Get_B2 (BitsDepth, "Depth"); // 1,8,16 or 32
Get_B2 (ColorMode, "Color Mode"); Param_Info1(Psd_ColorMode(ColorMode));
FILLING_BEGIN();
Accept("PSD");
Stream_Prepare(Stream_Image);
Fill(Stream_Image, 0, Image_Format, Version==1?"PSD":"PSB");
Fill(Stream_Image, 0, Image_Format_Version, Version);
Fill(Stream_Image, 0, Image_ColorSpace, Psd_ColorMode(ColorMode));
Fill(Stream_Image, 0, Image_Width, Width);
Fill(Stream_Image, 0, Image_Height, Height);
Fill(Stream_Image, 0, Image_BitDepth, BitsDepth);
Finish("PSD");
FILLING_END();
}
//---------------------------------------------------------------------------
void File_Cdp::cdp_header()
{
Element_Begin1("cdp_header");
int16u cdp_identifier;
int8u cdp_frame_rate;
Get_B2 ( cdp_identifier, "cdp_identifier");
Skip_B1( "cdp_length");
BS_Begin();
Get_S1 (4, cdp_frame_rate, "cdp_frame_rate"); Param_Info1(Ztring::ToZtring(Cdp_cdp_frame_rate(cdp_frame_rate))+__T(" fps"));
Skip_S1(4, "Reserved");
Skip_SB( "time_code_present");
Skip_SB( "ccdata_present");
Skip_SB( "svcinfo_present");
Skip_SB( "svc_info_start");
Skip_SB( "svc_info_change");
Skip_SB( "svc_info_complete");
Skip_SB( "caption_service_active");
Skip_SB( "Reserved");
BS_End();
Skip_B2( "cdp_hdr_sequence_cntr");
Element_End0();
FILLING_BEGIN();
if (!Status[IsAccepted])
{
if (cdp_identifier!=0x9669)
{
Reject("CDP");
return;
}
Accept("CDP");
}
FILLING_END();
}
//---------------------------------------------------------------------------
void File_Pdf::Object_Root()
{
Element_Info1("Document Catalog");
//Parsing
string Key;
Ztring Value;
while (Element_Offset<Element_Size)
{
if (Get_Next(Key, Value))
{
for (;;)
{
Get_Next(Key, Value);
if (Key.empty())
break;
else if (Key=="Metadata")
{
int32u ObjectNumber=Value.To_int32u();
Objects[ObjectNumber].Type=Type_Metadata;
Objects[ObjectNumber].TopObject=Objects_Current->first;
Objects[Objects_Current->first].Bottoms.push_back(ObjectNumber);
Param_Info1(__T("Metadata is at offset 0x"+Ztring().From_Number(Objects[ObjectNumber].Offset)));
}
}
continue;
}
if (Key.empty())
break;
}
}
//---------------------------------------------------------------------------
void File_Pdf::xref()
{
//Parsing
Element_Begin1("Cross-Reference Table");
Element_Begin1("Cross-Reference Section");
string FirstLine;
Skip_String(SizeOfLine(), "Object name");
Element_Begin1("Cross-Reference SubSection");
Get_String(SizeOfLine(), FirstLine, "Header");
size_t FirstLine_Space=FirstLine.find(' ');
int32u Base=atoi((const char*)FirstLine.c_str());
int32u Count=0;
if (FirstLine_Space!=string::npos)
Count=atoi((const char*)FirstLine.c_str()+FirstLine_Space+1);
if (0x10000+20*Count>Buffer_Size && File_Offset+Buffer_Size<File_Size)
{
// We wait for more data
Buffer_Offset=0;
Element_Offset=0;
Element_DoNotShow();
Element_End0();
Element_End0();
Element_End0();
Element_WaitForMoreData();
return;
}
while (Element_Offset<Element_Size && (Buffer[Buffer_Offset+(size_t)Element_Offset]=='\r' || Buffer[Buffer_Offset+(size_t)Element_Offset]=='\n'))
Element_Offset++;
const int8u* Buffer_Temp=Buffer+Buffer_Offset+(size_t)Element_Offset+17;
for (int32u Pos=0; Pos<Count; ++Pos)
{
if (*Buffer_Temp=='n')
{
int32u Offset=(int32u)atoi((const char*)(Buffer_Temp-17));
Objects[Base+Pos].Offset=Offset;
//Offsets[Offset]=Base+Pos;
Offsets.push_back(Offset);
}
Buffer_Temp+=20;
if (Pos>100)
Element_Offset+=20;
else
{
Skip_String(18, "Entry"); Param_Info1(Base+Pos);
Element_Offset+=2; //Skipping spaces at end and line return
}
}
Element_End0();
Element_End0();
Element_End0();
if (File_Offset+Buffer_Offset>Offsets_Max)
Offsets_Max=(int32u)(File_Offset+Buffer_Offset);
}
//---------------------------------------------------------------------------
void File_Elf::Read_Buffer_Continue()
{
//Parsing
int32u version4=(int32u)-1;
int16u type=(int16u)-1, machine=(int16u)-1;
int8u classs, data, version1, osabi, abiversion;
Skip_C4( "magic");
Get_L1 (classs, "class");
Get_L1 (data, "data");
Get_L1 (version1, "version");
Get_L1 (osabi, "osabi"); Param_Info1(Elf_osabi(osabi));
Get_L1 (abiversion, "abiversion");
Skip_XX(7, "reserved");
if (data==1) //LE
{
Get_L2 (type, "type"); Param_Info1(Elf_type(type));
Get_L2 (machine, "machine"); Param_Info1(Elf_machine(machine));
Get_L4 (version4, "version");
}
if (data==2) //BE
{
Get_B2 (type, "type"); Param_Info1(Elf_type(type));
Get_B2 (machine, "machine"); Param_Info1(Elf_machine(machine));
Get_B4 (version4, "version");
}
Skip_XX(Element_Size-Element_Offset, "Data");
FILLING_BEGIN();
if (version4!=(int32u)-1 && version1!=version4)
{
Reject("ELF");
return;
}
Accept("ELF");
Fill(Stream_General, 0, General_Format, "ELF");
if (type!=(int16u)-1)
Fill(Stream_General, 0, General_Format_Profile, Elf_type(type));
if (machine!=(int16u)-1)
Fill(Stream_General, 0, General_Format_Profile, Elf_machine(machine));
//No need of more
Finish("ELF");
FILLING_END();
}
//---------------------------------------------------------------------------
void File_Tak::STREAMINFO()
{
//Parsing
int32u num_samples_hi, samplerate;
int8u num_samples_lo, framesizecode, samplesize;
bool channels;
Skip_L1 ( "unknown");
BS_Begin();
Get_S1 ( 2, num_samples_lo, "num_samples (lo)");
Get_S1 ( 3, framesizecode, "framesizecode");
Skip_S1( 2, "unknown");
BS_End();
Get_L4 (num_samples_hi, "num_samples (hi)"); Param_Info2((((int64u)num_samples_hi)<<2 | num_samples_lo), " samples");
Get_L3 (samplerate, "samplerate"); Param_Info2((samplerate/16)+6000, " Hz");
BS_Begin();
Skip_S1( 4, "unknown");
Get_SB ( channels, "channels"); Param_Info1(channels?"Stereo":"Mono");
Get_S1 ( 2, samplesize, "samplesize"); Param_Info1(Tak_samplesize[samplesize]);
Skip_SB( "unknown");
BS_End();
Skip_L3( "crc");
FILLING_BEGIN()
//Coherency
if (samplerate==0)
return;
//Computing
int64u Samples=((int64u)num_samples_hi)<<2 | num_samples_lo;
int32u SamplingRate=(samplerate/16)+6000;
//Filling
File__Tags_Helper::Accept("TAK");
File__Tags_Helper::Stream_Prepare(Stream_Audio);
Fill(Stream_Audio, 0, Audio_Format, "TAK");
Fill(Stream_Audio, 0, Audio_Codec, "TAK");
Fill(Stream_Audio, 0, Audio_SamplingRate, SamplingRate);
Fill(Stream_Audio, 0, Audio_Channel_s_, channels?2:1);
if (Tak_samplesize[samplesize])
Fill(Stream_Audio, 0, Audio_BitDepth, Tak_samplesize[samplesize]);
Fill(Stream_Audio, 0, Audio_Duration, Samples*1000/SamplingRate);
FILLING_END();
}
//---------------------------------------------------------------------------
void File_Bpg::Read_Buffer_Continue()
{
//Parsing
Ztring Version;
int64u Width, Height;
int8u pixelformat, BitsDepth, ColorSpace;
bool Alpha1_flag, Alpha2_flag, ReservedZeros, limited_range_flag, ExtensionPresentFlag;
Element_Begin1("File header");
Skip_C4( "Magic"); // File Magic
BS_Begin();
Get_S1 (3, pixelformat, "pixel_format"); Param_Info1(Bpg_Pixel_format(pixelformat));
Get_SB (Alpha1_flag, "Alpha1 Present Flag");
Get_S1 (4, BitsDepth, "bit_depth_minus_8");
Get_S1(4, ColorSpace, "color_space"); Param_Info1(Bpg_ColorSpace(ColorSpace)); Param_Info1(Bpg_colour_primaries(ColorSpace));
Get_SB (ExtensionPresentFlag, "Extension Present Flag");
Get_SB (Alpha2_flag, "Alpha2 Present Flag");
Get_SB (limited_range_flag, "limited_range_flag");
Get_SB (ReservedZeros, "Reserved");
BS_End();
Get_VS(Width, "Picture Width");
Get_VS(Height, "Picture Height");
Element_End0();
FILLING_BEGIN();
Accept("BPG");
Stream_Prepare(Stream_Image);
Fill(Stream_Image, 0, Image_Width, Width);
Fill(Stream_Image, 0, Image_Height, Height);
Fill(Stream_Image, 0, Image_Format, __T("BPG"));
Fill(Stream_Image, 0, Image_ChromaSubsampling, Bpg_Pixel_format(pixelformat));
Fill(Stream_Image, 0, Image_ColorSpace, Bpg_ColorSpace(ColorSpace));
Fill(Stream_Image, 0, Image_colour_primaries, Bpg_colour_primaries(ColorSpace));
Fill(Stream_Image, 0, Image_BitDepth, BitsDepth + 8);
Fill(Stream_Image, 0, Image_Codec, __T("BPG"));
FILLING_END();
Finish("BPG");
}
//---------------------------------------------------------------------------
void File_OpenMG::FileHeader_Parse()
{
//Parsing
int16u Size, FrameSize=0;
int8u Flags, CodecID, SamplingRate_Code=0, Channels_Code=0;
bool JointStereo=false;
Skip_C3( "Code");
Get_B1 (Flags, "Flags");
Get_B2 (Size, "Size");
Skip_XX(26, "Unknown");
Get_B1 (CodecID, "Coded ID"); Param_Info1(OpenMG_CodecID_Format(CodecID));
if (CodecID<=1) //Atrac3
{
BS_Begin();
Skip_S1(7, "Unknown");
Get_SB ( JointStereo, "Joint Stereo");
Get_S1 (3, SamplingRate_Code, "Sampling Rate"); Param_Info2(OpenMG_SamplingRate(SamplingRate_Code), " Hz");
Get_S1 (3, Channels_Code, "Channels"); Param_Info2(OpenMG_Channels(Channels_Code), " channel(s)");
Get_S2 (10, FrameSize, "Frame size");
BS_End();
}
Skip_XX(Size-Element_Offset, "Unknown");
FILLING_BEGIN();
if (!Status[IsAccepted])
{
File__Tags_Helper::Accept();
Fill(Stream_Audio, 0, Audio_Format, OpenMG_CodecID_Format(CodecID));
Fill(Stream_Audio, 0, Audio_Encryption, OpenMG_CodecID_Encryption(CodecID));
int64u StreamSize=(int64u)-1;
if (File_Size!=(int64u)-1)
{
StreamSize=File_Size-(Buffer_Offset+Element_Size);
Fill(Stream_Audio, 0, Audio_StreamSize, StreamSize);
}
if (CodecID<=1) // Atrac3
{
Fill(Stream_Audio, 0, Audio_Channel_s_, OpenMG_Channels(Channels_Code));
Fill(Stream_Audio, 0, Audio_ChannelPositions, OpenMG_ChannelPositions(Channels_Code));
if (Channels_Code==1 && JointStereo)
Fill(Stream_Audio, 0, Audio_Format_Settings_Mode, "Joint Stereo");
Fill(Stream_Audio, 0, Audio_SamplingRate, OpenMG_SamplingRate(SamplingRate_Code));
if (CodecID==1) //Protected
FrameSize++; //Not sure
FrameSize<<=3; //8-byte blocks
int64u BitRate=OpenMG_SamplingRate(SamplingRate_Code)*FrameSize/256;
Fill(Stream_Audio, 0, Audio_BitRate, BitRate);
if (StreamSize!=(int64u)-1 && BitRate)
Fill(Stream_Audio, 0, Audio_Duration, StreamSize*8*1000/BitRate);
}
}
FILLING_END();
}
//---------------------------------------------------------------------------
void File_Png::IHDR()
{
//Parsing
int32u Width, Height;
int8u Bit_depth, Colour_type, Compression_method, Interlace_method;
Get_B4 (Width, "Width");
Get_B4 (Height, "Height");
Get_B1 (Bit_depth, "Bit depth");
Get_B1 (Colour_type, "Colour type"); Param_Info1(Png_Colour_type(Colour_type));
Get_B1 (Compression_method, "Compression method");
Skip_B1( "Filter method");
Get_B1 (Interlace_method, "Interlace method");
FILLING_BEGIN_PRECISE();
if (!Status[IsFilled])
{
Fill(StreamKind_Last, 0, "Width", Width);
Fill(StreamKind_Last, 0, "Height", Height);
int8u Resolution;
switch (Colour_type)
{
case 0 : Resolution=Bit_depth; break;
case 2 : Resolution=Bit_depth*3; break;
case 3 : Resolution=Bit_depth; break;
case 4 : Resolution=Bit_depth*2; break;
case 6 : Resolution=Bit_depth*4; break;
default: Resolution=0;
}
if (Resolution)
Fill(StreamKind_Last, 0, "BitDepth", Resolution);
switch (Compression_method)
{
case 0 :
Fill(StreamKind_Last, 0, "Format_Compression", "LZ77");
break;
default: ;
}
switch (Interlace_method)
{
case 0 :
break;
case 1 :
break;
default: ;
}
Fill();
}
if (Config->ParseSpeed<1.0)
Finish("PNG"); //No need of more
FILLING_END();
}
void File_Ibi::Stream_ByteOffset()
{
Element_Name("Byte Offset");
//Parsing
#if MEDIAINFO_IBIUSAGE
size_t Pos=0;
#endif //MEDIAINFO_IBIUSAGE
int64u Offset=0;
while (Element_Offset<Element_Size)
{
int64u Item;
Get_EB (Item, "Item");
Offset+=Item;
#if MEDIAINFO_IBIUSAGE
Param_Info1(Pos);
#endif //MEDIAINFO_IBIUSAGE
Param_Info1(Ztring::ToZtring(Offset)+__T(" (0x")+Ztring::ToZtring(Offset, 16)+__T(')'));
#if MEDIAINFO_IBIUSAGE
FILLING_BEGIN();
if (Ibi)
{
//Filling information for ID after data
if (Ibi->Streams[ID_Current]==NULL)
Ibi->Streams[ID_Current]=new ibi::stream();
if (Pos>=Ibi->Streams[ID_Current]->Infos.size())
{
Ibi->Streams[ID_Current]->Infos.push_back(ibi::stream::info());
Ibi->Streams[ID_Current]->Infos[Pos].IsContinuous=true; //default
}
Ibi->Streams[ID_Current]->Infos[Pos].StreamOffset=Offset;
Pos++;
}
FILLING_END();
#endif //MEDIAINFO_IBIUSAGE
}
}
//---------------------------------------------------------------------------
void File_AfdBarData::afd_data()
{
//Parsing
Element_Begin1("Active Format Description");
BS_Begin();
if (Format==Format_S2016_3)
{
Mark_0_NoTrustError();
Get_S1 (4, active_format, "active_format"); Param_Info1(AfdBarData_active_format[active_format]);
Get_S1 (1, aspect_ratio, "aspect_ratio"); Param_Info1(AfdBarData_aspect_ratio[aspect_ratio]);
Mark_0_NoTrustError();
Mark_0_NoTrustError();
}
else
{
bool active_format_flag;
Mark_0();
Get_SB (active_format_flag, "active_format_flag");
Mark_0_NoTrustError();
Mark_0_NoTrustError();
Mark_0_NoTrustError();
Mark_0_NoTrustError();
Mark_0_NoTrustError();
Mark_1_NoTrustError();
if (active_format_flag)
{
Mark_1_NoTrustError();
Mark_1_NoTrustError();
Mark_1_NoTrustError();
Mark_1_NoTrustError();
Get_S1 (4, active_format, "active_format"); Param_Info1(AfdBarData_active_format[active_format]);
}
}
BS_End();
Element_End0();
}
//---------------------------------------------------------------------------
void File_Dpx::IndustrySpecificHeader_Dpx()
{
Element_Name("Industry specific header");
//Parsing
float32 FrameRate;
Element_Begin1("Motion-picture film information");
Skip_String(2, "Film mfg. ID code");
Skip_String(2, "Film type");
Skip_String(2, "Offset in perfs");
Skip_String(6, "Prefix");
Skip_String(4, "Count");
Skip_String(32, "Format - e.g. Academy");
Skip_B4( "Frame position in sequence");
Skip_B4( "Sequence length (frames)");
Skip_B4( "Held count (1 = default)");
Get_BF4 (FrameRate, "Frame rate of original (frames/s)");
Skip_BF4( "Shutter angle of camera in degrees");
Skip_UTF8(32, "Frame identification - e.g. keyframe");
Skip_UTF8(100, "Slate information");
Skip_XX(56, "Reserved for future use");
Element_End0();
Element_Begin1("Television information");
Skip_B4( "SMPTE time code");
Skip_B4( "SMPTE user bits");
Info_B1(Interlace, "Interlace");Param_Info1((Interlace==0?"noninterlaced":"2:1 interlace"));
Skip_B1( "Field number");
Info_B1(VideoSignalStandard, "Video signal standard");Param_Info1(DPX_VideoSignalStandard(VideoSignalStandard));
Skip_B1( "Zero");
Skip_BF4( "Horizontal sampling rate (Hz)");
Skip_BF4( "Vertical sampling rate (Hz)");
Skip_BF4( "Temporal sampling rate or frame rate (Hz)");
Skip_BF4( "Time offset from sync to first pixel (ms)");
Skip_BF4( "Gamma");
Skip_BF4( "Black level code value");
Skip_BF4( "Black gain");
Skip_BF4( "Breakpoint");
Skip_BF4( "Reference white level code value");
Skip_BF4( "Integration time (s)");
Skip_XX(76, "Reserved for future use");
Element_End0();
FILLING_BEGIN();
if (FrameRate)
Fill(StreamKind_Last, StreamPos_Last, "FrameRate", FrameRate);
FILLING_END();
}
//---------------------------------------------------------------------------
void File_Tga::Tga_File_Header()
{
//Parsing
Element_Begin1("Tga File Header");
Get_L1 (ID_Length, "ID Length");
Get_L1 (Color_Map_Type, "Color Map Type");
Get_L1 (Image_Type, "Image Type"); Param_Info1(Tga_Image_Type_Compression(Image_Type));
Element_End0();
Element_Begin1("Color Map Specification");
Get_L2 (First_Entry_Index, "First Entry Index");
Get_L2 (Color_map_Length, "Color map Length");
Get_L1 (Color_map_Entry_Size, "Color map Entry Size");
Element_End0();
Element_Begin1("Image Specification");
Skip_L2( "X-origin of Image");
Skip_L2( "Y-origin of Image");
Get_L2 (Image_Width_, "Image Width");
Get_L2 (Image_Height_, "Image Height");
Get_L1 (Pixel_Depth, "Pixel Depth");
Get_L1 (Image_Descriptor, "Image Descriptor");
Element_End0();
}
//---------------------------------------------------------------------------
void File_Pdf::trailer()
{
Element_Begin1("Trailer");
//Parsing
int32u Prev=(int32u)-1;
string Key;
Ztring Value;
Skip_String(SizeOfLine(), "Object name");
while (Element_Offset<Element_Size)
{
if (Get_Next(Key, Value))
{
for (;;)
{
Get_Next(Key, Value);
if (Key.empty())
break;
else if (Key=="Root")
{
int32u ObjectNumber=Value.To_int32u();
Objects[ObjectNumber].Type=Type_Root;
Objects[ObjectNumber].TopObject=(int32u)-1;
Objects[(int32u)-1].Bottoms.push_back(ObjectNumber);
Param_Info1(__T("Document Catalog is at offset 0x"+Ztring().From_Number(Objects[ObjectNumber].Offset, 16)));
}
else if (Key=="Info")
{
int32u ObjectNumber=Value.To_int32u();
Objects[ObjectNumber].Type=Type_Info;
Objects[ObjectNumber].TopObject=(int32u)-1;
Objects[(int32u)-1].Bottoms.push_back(ObjectNumber);
Param_Info1(__T("Info is at offset 0x"+Ztring().From_Number(Objects[ObjectNumber].Offset, 16)));
}
else if (Key=="Prev")
{
Prev=Value.To_int32u();
Param_Info1(__T("Previous Cross-Reference Table is at offset 0x"+Ztring().From_Number(Prev, 16)));
}
}
continue;
}
if (Key.empty())
break;
}
Element_End0();
//Previous Cross-Reference Table
if (Prev!=(int32u)-1)
{
GoTo(Prev);
return;
}
objects::iterator Object_Top=Objects.find((int32u)-1);
if (Offsets.empty() || Object_Top==Objects.end())
{
Finish();
return;
}
sort(Offsets.begin(), Offsets.end());
//Offsets_Current=Offsets.end(); //No more used for the moment
Objects[(int32u)-1].BottomPos=0;
Objects_Current=Objects.find(Object_Top->second.Bottoms[0]);
GoTo(Objects_Current->second.Offset);
State=State_Parsing_object;
}
//---------------------------------------------------------------------------
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_Begin1("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_Info1(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_End0();
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_Begin0();
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_Info1(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_End0();
}
}
}
//---------------------------------------------------------------------------
void File_Mpeg4_Descriptors::Descriptor_06()
{
delete SLConfig; SLConfig=new slconfig;
//Parsing
int8u predefined;
Get_B1 (predefined, "predefined"); Param_Info1(Mpeg4_Descriptors_Predefined(predefined));
switch (predefined)
{
case 0x00 :
{
BS_Begin();
Get_SB (SLConfig->useAccessUnitStartFlag, "useAccessUnitStartFlag");
Get_SB (SLConfig->useAccessUnitEndFlag, "useAccessUnitEndFlag");
Get_SB (SLConfig->useRandomAccessPointFlag, "useRandomAccessPointFlag");
Get_SB (SLConfig->hasRandomAccessUnitsOnlyFlag, "hasRandomAccessUnitsOnlyFlag");
Get_SB (SLConfig->usePaddingFlag, "usePaddingFlag");
Get_SB (SLConfig->useTimeStampsFlag, "useTimeStampsFlag");
Get_SB (SLConfig->useIdleFlag, "useIdleFlag");
Get_SB (SLConfig->durationFlag, "durationFlag");
BS_End();
Get_B4 (SLConfig->timeStampResolution, "timeStampResolution");
Get_B4( SLConfig->OCRResolution, "OCRResolution");
Get_B1 (SLConfig->timeStampLength, "timeStampLength");
Get_B1 (SLConfig->OCRLength, "OCRLength");
Get_B1 (SLConfig->AU_Length, "AU_Length");
Get_B1 (SLConfig->instantBitrateLength, "instantBitrateLength");
BS_Begin();
Get_S1 (4, SLConfig->degradationPriorityLength, "degradationPriorityLength");
Get_S1 (5, SLConfig->AU_seqNumLength, "AU_seqNumLength");
Get_S1 (5, SLConfig->packetSeqNumLength, "packetSeqNumLength");
Skip_S1(2, "reserved");
BS_End();
}
break;
case 0x01 :
SLConfig->useAccessUnitStartFlag =false;
SLConfig->useAccessUnitEndFlag =false;
SLConfig->useRandomAccessPointFlag =false;
SLConfig->hasRandomAccessUnitsOnlyFlag =false;
SLConfig->usePaddingFlag =false;
SLConfig->useTimeStampsFlag =false;
SLConfig->useIdleFlag =false;
SLConfig->durationFlag =false; //-
SLConfig->timeStampResolution =1000;
SLConfig->OCRResolution =0; //-
SLConfig->timeStampLength =32;
SLConfig->OCRLength =0; //-
SLConfig->AU_Length =0;
SLConfig->instantBitrateLength =0; //-
SLConfig->degradationPriorityLength =0;
SLConfig->AU_seqNumLength =0;
SLConfig->packetSeqNumLength =0;
break;
case 0x02 :
SLConfig->useAccessUnitStartFlag =false;
SLConfig->useAccessUnitEndFlag =false;
SLConfig->useRandomAccessPointFlag =false;
SLConfig->hasRandomAccessUnitsOnlyFlag =false;
SLConfig->usePaddingFlag =false;
SLConfig->useTimeStampsFlag =true;
SLConfig->useIdleFlag =false;
SLConfig->durationFlag =false;
SLConfig->timeStampResolution =0; //-
SLConfig->OCRResolution =0; //-
SLConfig->timeStampLength =0;
SLConfig->OCRLength =0;
SLConfig->AU_Length =0;
SLConfig->instantBitrateLength =0;
SLConfig->degradationPriorityLength =0;
SLConfig->AU_seqNumLength =0;
SLConfig->packetSeqNumLength =0;
break;
default :
SLConfig->useAccessUnitStartFlag =false;
SLConfig->useAccessUnitEndFlag =false;
SLConfig->useRandomAccessPointFlag =false;
SLConfig->hasRandomAccessUnitsOnlyFlag =false;
SLConfig->usePaddingFlag =false;
SLConfig->useTimeStampsFlag =false;
SLConfig->useIdleFlag =false;
SLConfig->durationFlag =false;
SLConfig->timeStampResolution =0;
SLConfig->OCRResolution =0;
SLConfig->timeStampLength =0;
SLConfig->AU_Length =0;
SLConfig->instantBitrateLength =0;
SLConfig->degradationPriorityLength =0;
SLConfig->AU_seqNumLength =0;
SLConfig->packetSeqNumLength =0;
}
if (SLConfig->durationFlag)
{
Get_B4 (SLConfig->timeScale, "timeScale");
Get_B2 (SLConfig->accessUnitDuration, "accessUnitDuration");
Get_B2 (SLConfig->compositionUnitDuration, "compositionUnitDuration");
}
else
{
SLConfig->timeScale =0; //-
SLConfig->accessUnitDuration =0; //-
SLConfig->compositionUnitDuration =0; //-
}
if (!SLConfig->useTimeStampsFlag)
{
BS_Begin();
Get_S8 (SLConfig->timeStampLength, SLConfig->startDecodingTimeStamp, "startDecodingTimeStamp");
Get_S8 (SLConfig->timeStampLength, SLConfig->startCompositionTimeStamp, "startCompositionTimeStamp");
BS_End();
}
else
{
SLConfig->startDecodingTimeStamp =0; //-
SLConfig->startCompositionTimeStamp =0; //-
}
}
//---------------------------------------------------------------------------
void File_Mpeg4_Descriptors::Descriptor_04()
{
//Parsing
int32u bufferSizeDB, MaxBitrate, AvgBitrate;
int8u streamType;
Get_B1 (ObjectTypeId, "objectTypeIndication"); Param_Info1(Mpeg4_Descriptors_ObjectTypeIndication(ObjectTypeId));
BS_Begin();
Get_S1 (6, streamType, "streamType"); Param_Info1(Mpeg4_Descriptors_StreamType(streamType));
Skip_SB( "upStream");
Skip_SB( "reserved");
BS_End();
Get_B3 (bufferSizeDB, "bufferSizeDB");
Get_B4 (MaxBitrate, "maxBitrate");
Get_B4 (AvgBitrate, "avgBitrate");
FILLING_BEGIN();
if (KindOfStream==Stream_Max)
switch (ObjectTypeId)
{
case 0x20 :
case 0x21 :
case 0x60 :
case 0x61 :
case 0x62 :
case 0x63 :
case 0x64 :
case 0x65 :
case 0x6A :
case 0x6C :
case 0x6D :
case 0x6E :
case 0xA3 :
case 0xA4 :
KindOfStream=Stream_Video; break;
case 0x40 :
case 0x66 :
case 0x67 :
case 0x68 :
case 0x69 :
case 0x6B :
case 0xA0 :
case 0xA1 :
case 0xA5 :
case 0xA6 :
case 0xA9 :
case 0xAA :
case 0xAB :
case 0xAC :
case 0xD1 :
case 0xD3 :
case 0xD4 :
case 0xE1 :
KindOfStream=Stream_Audio; break;
case 0x08 :
KindOfStream=Stream_Text; break;
default: ;
}
if (Count_Get(KindOfStream)==0)
Stream_Prepare(KindOfStream);
switch (ObjectTypeId)
{
case 0x01 : Fill(StreamKind_Last, StreamPos_Last, Fill_Parameter(StreamKind_Last, Generic_Format), "System", Error, false, true); break;
case 0x02 : Fill(StreamKind_Last, StreamPos_Last, Fill_Parameter(StreamKind_Last, Generic_Format), "System Core", Error, false, true); break;
//case 0x03 Interaction Stream
//case 0x05 AFX
//case 0x06 Font Data
//case 0x07 Synthesized Texture Stream
case 0x08 : Fill(Stream_Text , StreamPos_Last, Text_Format, "Streaming Text", Error, false, true); break;
case 0x20 : Fill(Stream_Video , StreamPos_Last, Video_Format, "MPEG-4 Visual", Error, false, true); break;
case 0x21 : Fill(Stream_Video , StreamPos_Last, Video_Format, "AVC", Error, false, true); break;
//case 0x22 Parameter Sets for AVC
case 0x40 : Fill(Stream_Audio , StreamPos_Last, Audio_Format, "AAC", Error, false, true); break; //MPEG-4 AAC
case 0x60 : Fill(Stream_Video , StreamPos_Last, Video_Format, "MPEG Video", Error, false, true); Fill(Stream_Video, StreamPos_Last, Video_Format_Profile, "Simple" , Error, false, true); Fill(Stream_Video, StreamPos_Last, Video_Format_Version, "Version 2", Error, false, true); break; //MPEG-2V Simple
case 0x61 : Fill(Stream_Video , StreamPos_Last, Video_Format, "MPEG Video", Error, false, true); Fill(Stream_Video, StreamPos_Last, Video_Format_Profile, "Main" , Error, false, true); Fill(Stream_Video, StreamPos_Last, Video_Format_Version, "Version 2", Error, false, true); break; //MPEG-2V Main
case 0x62 : Fill(Stream_Video , StreamPos_Last, Video_Format, "MPEG Video", Error, false, true); Fill(Stream_Video, StreamPos_Last, Video_Format_Profile, "SNR" , Error, false, true); Fill(Stream_Video, StreamPos_Last, Video_Format_Version, "Version 2", Error, false, true); break; //MPEG-2V SNR
case 0x63 : Fill(Stream_Video , StreamPos_Last, Video_Format, "MPEG Video", Error, false, true); Fill(Stream_Video, StreamPos_Last, Video_Format_Profile, "Spatial", Error, false, true); Fill(Stream_Video, StreamPos_Last, Video_Format_Version, "Version 2", Error, false, true); break; //MPEG-2V Spatial
case 0x64 : Fill(Stream_Video , StreamPos_Last, Video_Format, "MPEG Video", Error, false, true); Fill(Stream_Video, StreamPos_Last, Video_Format_Profile, "High" , Error, false, true); Fill(Stream_Video, StreamPos_Last, Video_Format_Version, "Version 2", Error, false, true); break; //MPEG-2V High
case 0x65 : Fill(Stream_Video , StreamPos_Last, Video_Format, "MPEG Video", Error, false, true); Fill(Stream_Video, StreamPos_Last, Video_Format_Profile, "4:2:2" , Error, false, true); Fill(Stream_Video, StreamPos_Last, Video_Format_Version, "Version 2", Error, false, true); break; //MPEG-2V 4:2:2
case 0x66 : Fill(Stream_Audio , StreamPos_Last, Audio_Format, "AAC", Error, false, true); Fill(Stream_Audio, StreamPos_Last, Audio_Format_Profile, "Main", Error, false, true); break; //MPEG-2 AAC Main
case 0x67 : Fill(Stream_Audio , StreamPos_Last, Audio_Format, "AAC", Error, false, true); Fill(Stream_Audio, StreamPos_Last, Audio_Format_Profile, "LC", Error, false, true); break; //MPEG-2 AAC LC
case 0x68 : Fill(Stream_Audio , StreamPos_Last, Audio_Format, "AAC", Error, false, true); Fill(Stream_Audio, StreamPos_Last, Audio_Format_Profile, "SSR", Error, false, true); break; //MPEG-2 AAC SSR
case 0x69 : Fill(Stream_Audio , StreamPos_Last, Audio_Format, "MPEG Audio", Error, false, true); Fill(Stream_Audio, StreamPos_Last, Audio_Format_Version, "Version 2", Error, false, true); Fill(Stream_Audio, StreamPos_Last, Audio_Format_Profile, "Layer 3", Error, false, true); break;
case 0x6A : Fill(Stream_Video , StreamPos_Last, Video_Format, "MPEG Video", Error, false, true); Fill(Stream_Video, StreamPos_Last, Video_Format_Version, "Version 1", Error, false, true); break;
case 0x6B : Fill(Stream_Audio , StreamPos_Last, Audio_Format, "MPEG Audio", Error, false, true); Fill(Stream_Audio, StreamPos_Last, Audio_Format_Version, "Version 1", Error, false, true); break;
case 0x6C : Fill(Stream_Video , StreamPos_Last, Video_Format, "JPEG", Error, false, true); break;
case 0x6D : Fill(Stream_Video , StreamPos_Last, Video_Format, "PNG", Error, false, true); break;
case 0x6E : Fill(Stream_Video , StreamPos_Last, Video_Format, "MPEG Video", Error, false, true); break;
case 0xA0 : Fill(Stream_Audio , StreamPos_Last, Audio_Format, "EVRC", Error, false, true); Fill(Stream_Audio, StreamPos_Last, Audio_SamplingRate, 8000, 10, true); Fill(Stream_Audio, StreamPos_Last, Audio_Channel_s_, 1, 10, true); break;
case 0xA1 : Fill(Stream_Audio , StreamPos_Last, Audio_Format, "SMV", Error, false, true); Fill(Stream_Audio, StreamPos_Last, Audio_SamplingRate, 8000, 10, true); Fill(Stream_Audio, StreamPos_Last, Audio_Channel_s_, 1, 10, true); break;
case 0xA2 : Fill(StreamKind_Last, StreamPos_Last, Fill_Parameter(StreamKind_Last, Generic_Format), "3GPP2", Error, false, true); break;
case 0xA3 : Fill(Stream_Video , StreamPos_Last, Video_Format, "VC-1", Error, false, true); break;
case 0xA4 : Fill(Stream_Video , StreamPos_Last, Video_Format, "Dirac", Error, false, true); break;
case 0xA5 : Fill(Stream_Audio , StreamPos_Last, Audio_Format, "AC-3", Error, false, true); break;
case 0xA6 : Fill(Stream_Audio , StreamPos_Last, Audio_Format, "E-AC-3", Error, false, true); break;
case 0xA9 : Fill(Stream_Audio , StreamPos_Last, Audio_Format, "DTS", Error, false, true); break;
case 0xAA : Fill(Stream_Audio , StreamPos_Last, Audio_Format, "DTS", Error, false, true); Fill(Stream_Audio, StreamPos_Last, Audio_Format_Profile, "HRA", Error, false, true); break; // DTS-HD High Resolution
case 0xAB : Fill(Stream_Audio , StreamPos_Last, Audio_Format, "DTS", Error, false, true); Fill(Stream_Audio, StreamPos_Last, Audio_Format_Profile, "MA", Error, false, true); break; // DTS-HD Master Audio
case 0xAC : Fill(Stream_Audio , StreamPos_Last, Audio_Format, "DTS", Error, false, true); Fill(Stream_Audio, StreamPos_Last, Audio_Format_Profile, "Express", Error, false, true); break; // DTS Express a.k.a. LBR
case 0xD1 : Fill(Stream_Audio , StreamPos_Last, Audio_Format, "EVRC", Error, false, true); Fill(Stream_Audio, StreamPos_Last, Audio_SamplingRate, 8000, 10, true); Fill(Stream_Audio, StreamPos_Last, Audio_Channel_s_, 1, 10, true); break;
case 0xD3 : Fill(Stream_Audio , StreamPos_Last, Audio_Format, "AC-3", Error, false, true); break;
case 0xD4 : Fill(Stream_Audio , StreamPos_Last, Audio_Format, "DTS", Error, false, true); break;
case 0xDD : Fill(StreamKind_Last, StreamPos_Last, Fill_Parameter(StreamKind_Last, Generic_Format), "Ogg", Error, false, true); break;
case 0xDE : Fill(StreamKind_Last, StreamPos_Last, Fill_Parameter(StreamKind_Last, Generic_Format), "Ogg", Error, false, true); break;
case 0xE1 : Fill(Stream_Audio , StreamPos_Last, Audio_Format, "QCELP", Error, false, true); Fill(Stream_Audio, StreamPos_Last, Audio_SamplingRate, 8000, 10, true); Fill(Stream_Audio, StreamPos_Last, Audio_Channel_s_, 1, 10, true); break;
default: ;
}
switch (ObjectTypeId)
{
case 0x01 : Fill(StreamKind_Last, StreamPos_Last, Fill_Parameter(StreamKind_Last, Generic_Codec), "System", Error, false, true); break;
case 0x02 : Fill(StreamKind_Last, StreamPos_Last, Fill_Parameter(StreamKind_Last, Generic_Codec), "System Core", Error, false, true); break;
case 0x20 : Fill(Stream_Video , StreamPos_Last, Video_Codec, "MPEG-4V", Error, false, true); break;
case 0x21 : Fill(Stream_Video , StreamPos_Last, Video_Codec, "H264", Error, false, true); break;
case 0x40 : Fill(Stream_Audio , StreamPos_Last, Audio_Codec, "AAC", Error, false, true); break; //MPEG-4 AAC
case 0x60 : Fill(Stream_Video , StreamPos_Last, Video_Codec, "MPEG-2V", Error, false, true); break; //MPEG-2V Simple
case 0x61 : Fill(Stream_Video , StreamPos_Last, Video_Codec, "MPEG-2V", Error, false, true); break; //MPEG-2V Main
case 0x62 : Fill(Stream_Video , StreamPos_Last, Video_Codec, "MPEG-2V", Error, false, true); break; //MPEG-2V SNR
case 0x63 : Fill(Stream_Video , StreamPos_Last, Video_Codec, "MPEG-2V", Error, false, true); break; //MPEG-2V Spatial
case 0x64 : Fill(Stream_Video , StreamPos_Last, Video_Codec, "MPEG-2V", Error, false, true); break; //MPEG-2V High
case 0x65 : Fill(Stream_Video , StreamPos_Last, Video_Codec, "MPEG-2V", Error, false, true); break; //MPEG-2V 4:2:2
case 0x66 : Fill(Stream_Audio , StreamPos_Last, Audio_Codec, "AAC", Error, false, true); break; //MPEG-2 AAC Main
case 0x67 : Fill(Stream_Audio , StreamPos_Last, Audio_Codec, "AAC", Error, false, true); break; //MPEG-2 AAC LC
case 0x68 : Fill(Stream_Audio , StreamPos_Last, Audio_Codec, "AAC", Error, false, true); break; //MPEG-2 AAC SSR
case 0x69 : Fill(Stream_Audio , StreamPos_Last, Audio_Codec, "MPEG-2A L3", Error, false, true); break;
case 0x6A : Fill(Stream_Video , StreamPos_Last, Video_Codec, "MPEG-1V", Error, false, true); break;
case 0x6B : Fill(Stream_Audio , StreamPos_Last, Audio_Codec, "MPEG-1A", Error, false, true); break;
case 0x6C : Fill(Stream_Video , StreamPos_Last, Video_Codec, "JPEG", Error, false, true); break;
case 0x6D : Fill(Stream_Video , StreamPos_Last, Video_Codec, "PNG", Error, false, true); break;
case 0x6E : Fill(Stream_Video , StreamPos_Last, Video_Codec, "MPEG-4V", Error, false, true); break;
case 0xA0 : Fill(Stream_Video , StreamPos_Last, Video_Codec, "EVRC", Error, false, true); break;
case 0xA1 : Fill(Stream_Video , StreamPos_Last, Video_Codec, "SMV", Error, false, true); break;
case 0xA2 : Fill(Stream_Video , StreamPos_Last, Video_Codec, "MPEG-4V", Error, false, true); break;
case 0xA3 : Fill(Stream_Audio , StreamPos_Last, Audio_Codec, "VC-1", Error, false, true); break;
case 0xA4 : Fill(Stream_Audio , StreamPos_Last, Audio_Codec, "Dirac", Error, false, true); break;
case 0xA5 : Fill(Stream_Audio , StreamPos_Last, Audio_Codec, "AC3", Error, false, true); break;
case 0xA6 : Fill(Stream_Audio , StreamPos_Last, Audio_Codec, "AC3+", Error, false, true); break;
case 0xA9 : Fill(Stream_Audio , StreamPos_Last, Audio_Codec, "DTS", Error, false, true); break;
case 0xAA :
case 0xAB : Fill(Stream_Audio , StreamPos_Last, Audio_Codec, "DTS-HD", Error, false, true); break;
case 0xAC : Fill(Stream_Audio , StreamPos_Last, Audio_Codec, "DTS Express", Error, false, true); break;
case 0xD1 : Fill(Stream_Audio , StreamPos_Last, Audio_Codec, "EVRC", Error, false, true); break;
case 0xD3 : Fill(Stream_Audio , StreamPos_Last, Audio_Codec, "AC3", Error, false, true); break;
case 0xD4 : Fill(Stream_Audio , StreamPos_Last, Audio_Codec, "DTS", Error, false, true); break;
case 0xDD : Fill(StreamKind_Last, StreamPos_Last, Fill_Parameter(StreamKind_Last, Generic_Codec), "Ogg", Error, false, true); break;
case 0xDE : Fill(StreamKind_Last, StreamPos_Last, Fill_Parameter(StreamKind_Last, Generic_Codec), "Ogg", Error, false, true); break;
case 0xE1 : Fill(Stream_Audio , StreamPos_Last, Audio_Codec, "QCELP", Error, false, true); break;
default: ;
}
Fill(StreamKind_Last, StreamPos_Last, Fill_Parameter(StreamKind_Last, Generic_CodecID), ObjectTypeId, 16, true);
Fill(StreamKind_Last, StreamPos_Last, Fill_Parameter(StreamKind_Last, Generic_Codec_CC), ObjectTypeId, 16, true);
//Bitrate mode
if (AvgBitrate>0
&& !(bufferSizeDB==AvgBitrate && bufferSizeDB==MaxBitrate && bufferSizeDB==0x1000)) //Some buggy data were found
{
Fill(StreamKind_Last, StreamPos_Last, Fill_Parameter(StreamKind_Last, Generic_BitRate_Nominal), AvgBitrate);
if (MaxBitrate<=AvgBitrate*1.005)
Fill(StreamKind_Last, StreamPos_Last, Fill_Parameter(StreamKind_Last, Generic_BitRate_Mode), "CBR");
else
{
Fill(StreamKind_Last, StreamPos_Last, Fill_Parameter(StreamKind_Last, Generic_BitRate_Mode), "VBR");
Fill(StreamKind_Last, StreamPos_Last, Fill_Parameter(StreamKind_Last, Generic_BitRate_Maximum), MaxBitrate);
}
}
//Creating parser
delete Parser; Parser=NULL;
switch (ObjectTypeId)
{
case 0x01 : switch (streamType)
{
case 0x01 : Parser=new File_Mpeg4_Descriptors; break;
default : ;
}
break;
case 0x20 : //MPEG-4 Visual
#if defined(MEDIAINFO_MPEG4V_YES)
Parser=new File_Mpeg4v;
((File_Mpeg4v*)Parser)->Frame_Count_Valid=1;
((File_Mpeg4v*)Parser)->FrameIsAlwaysComplete=true;
#endif
break;
case 0x21 : //AVC
#if defined(MEDIAINFO_AVC_YES)
Parser=new File_Avc;
((File_Avc*)Parser)->MustParse_SPS_PPS=true;
((File_Avc*)Parser)->MustSynchronize=false;
((File_Avc*)Parser)->SizedBlocks=true;
#endif
break;
case 0x40 : //MPEG-4 AAC
case 0x66 :
case 0x67 :
case 0x68 : //MPEG-2 AAC
#if defined(MEDIAINFO_AAC_YES)
Parser=new File_Aac;
((File_Aac*)Parser)->Mode=File_Aac::Mode_AudioSpecificConfig;
((File_Aac*)Parser)->FrameIsAlwaysComplete=true;
#endif
break;
case 0x60 :
case 0x61 :
case 0x62 :
case 0x63 :
case 0x64 :
case 0x65 :
case 0x6A : //MPEG Video
#if defined(MEDIAINFO_MPEGV_YES)
Parser=new File_Mpegv;
((File_Mpegv*)Parser)->FrameIsAlwaysComplete=true;
#endif
break;
case 0x69 :
case 0x6B : //MPEG Audio
#if defined(MEDIAINFO_MPEGA_YES)
Parser=new File_Mpega;
#endif
break;
case 0x6C : //JPEG
#if defined(MEDIAINFO_JPEG_YES)
Parser=new File_Jpeg;
((File_Jpeg*)Parser)->StreamKind=Stream_Video;
#endif
break;
case 0x6D : //PNG
#if defined(MEDIAINFO_PNG_YES)
Parser=new File_Png;
#endif
break;
case 0xA3 : //VC-1
#if defined(MEDIAINFO_VC1_YES)
Parser=new File_Vc1;
#endif
break;
case 0xA4 : //Dirac
#if defined(MEDIAINFO_DIRAC_YES)
Parser=new File_Dirac;
#endif
break;
case 0xA5 : //AC-3
case 0xA6 : //E-AC-3
case 0xD3 : //AC-3
#if defined(MEDIAINFO_AC3_YES)
Parser=new File_Ac3;
#endif
break;
case 0xA9 : //DTS
case 0xAA : //DTS HRA
case 0xAB : //DTS MA
case 0xAC : //DTS Express
case 0xD4 : //DTS
#if defined(MEDIAINFO_DTS_YES)
Parser=new File_Dts;
#endif
break;
case 0xDD :
case 0xDE : //OGG
#if defined(MEDIAINFO_OGG_YES)
Parser=new File_Ogg;
Parser->MustSynchronize=false;
((File_Ogg*)Parser)->SizedBlocks=true;
#endif
break;
default: ;
}
Element_Code=(int64u)-1;
Open_Buffer_Init(Parser);
Element_ThisIsAList();
FILLING_END();
}
//---------------------------------------------------------------------------
void File_Mpeg4_Descriptors::Descriptor_01()
{
//Parsing
bool URL_Flag;
BS_Begin();
Skip_S2(10, "ObjectDescriptorID");
Get_SB ( URL_Flag, "URL_Flag");
Skip_SB( "includeInlineProfileLevelFlag");
Skip_S1( 4, "reserved");
BS_End();
if (URL_Flag)
{
int8u URLlength;
Get_B1 (URLlength, "URLlength");
Skip_UTF8(URLlength, "URLstring");
}
if (Element_Code==0x02 || Element_Code==0x10)
{
Info_B1(ODProfileLevel, "ODProfileLevelIndication"); Param_Info1(Mpeg4_Descriptors_ODProfileLevelIndication(ODProfileLevel));
Info_B1(SceneProfileLevel, "sceneProfileLevelIndication"); Param_Info1(Mpeg4_Descriptors_SceneProfileLevelIndication(SceneProfileLevel));
Info_B1(AudioProfileLevel, "audioProfileLevelIndication"); Param_Info1(Mpeg4_Descriptors_AudioProfileLevelIndication(AudioProfileLevel));
Info_B1(VisualProfileLevel, "visualProfileLevelIndication"); Param_Info1(Mpeg4v_Profile_Level(VisualProfileLevel));
Info_B1(GraphicsProfileLevel, "graphicsProfileLevelIndication"); Param_Info1(Mpeg4_Descriptors_GraphicsProfileLevelIndication(GraphicsProfileLevel));
}
FILLING_BEGIN();
Element_ThisIsAList();
FILLING_END();
}
//---------------------------------------------------------------------------
// Packet "00"
void File_Dirac::Sequence_header()
{
Element_Name("Sequence header");
//Parsing
int32u version_major, version_minor, profile, level, base_video_format;
BS_Begin();
Get_UI(version_major, "version major");
Get_UI(version_minor, "version minor");
Get_UI(profile, "profile");
Get_UI(level, "level");
if (version_major<=2)
{
Get_UI(base_video_format, "base video format"); //Param_Info1(Dirac_base_video_format(base_video_format));
Dirac_base_video_format(base_video_format, frame_width, frame_height, chroma_format, source_sampling,
clean_width, clean_height, clean_left_offset, clean_top_offset,
frame_rate, pixel_aspect_ratio);
TEST_SB_SKIP( "custom dimensions flag");
Get_UI (frame_width, "frame width");
Get_UI (frame_height, "frame height");
TEST_SB_END();
TEST_SB_SKIP( "custom chroma format flag");
Get_UI (chroma_format, "chroma format"); Param_Info1(Dirac_chroma_format(chroma_format));
TEST_SB_END();
TEST_SB_SKIP( "custom scan format flag");
Get_UI (source_sampling, "source sampling"); Param_Info1(Dirac_source_sampling(source_sampling));
TEST_SB_END();
TEST_SB_SKIP( "frame rate flag");
int32u frame_rate_index;
Get_UI (frame_rate_index, "index"); Param_Info1(Dirac_frame_rate(frame_rate_index));
if (frame_rate_index==0)
{
int32u frame_rate_numer, frame_rate_denom;
Get_UI (frame_rate_numer, "frame rate numer");
Get_UI (frame_rate_denom, "frame rate denom");
frame_rate=((float32)frame_rate_numer)/((float32)frame_rate_denom);
}
else
frame_rate=Dirac_frame_rate(frame_rate_index);
TEST_SB_END();
TEST_SB_SKIP( "pixel aspect ratio flag");
int32u pixel_aspect_ratio_index;
Get_UI (pixel_aspect_ratio_index, "index"); Param_Info1(Dirac_pixel_aspect_ratio(pixel_aspect_ratio_index));
if (pixel_aspect_ratio_index==0)
{
int32u pixel_aspect_ratio_numer, pixel_aspect_ratio_denom;
Get_UI (pixel_aspect_ratio_numer, "pixel aspect ratio numer");
Get_UI (pixel_aspect_ratio_denom, "pixel aspect ratio denom");
pixel_aspect_ratio=((float32)pixel_aspect_ratio_numer)/((float32)pixel_aspect_ratio_denom);
}
else
pixel_aspect_ratio=Dirac_pixel_aspect_ratio(pixel_aspect_ratio_index);
TEST_SB_END();
TESTELSE_SB_SKIP( "custom clean area flag");
Get_UI (clean_width, "clean width");
Get_UI (clean_height, "clean height");
Get_UI (clean_left_offset, "clean left offset");
Get_UI (clean_top_offset, "clean top offset");
TESTELSE_SB_ELSE( "custom clean area flag");
clean_width=frame_width;
clean_height=frame_height;
TESTELSE_SB_END();
TEST_SB_SKIP( "custom signal range flag");
int32u custom_signal_range_index;
Get_UI(custom_signal_range_index, "index");
if (custom_signal_range_index==0)
{
Skip_UI( "luma offset");
Skip_UI( "luma excursion");
Skip_UI( "chroma offset");
Skip_UI( "chroma excursion");
}
TEST_SB_END();
TEST_SB_SKIP( "custom colour spec flag");
int32u custom_colour_spec_index;
Get_UI(custom_colour_spec_index, "index");
if (custom_colour_spec_index==0)
{
TEST_SB_SKIP( "custom colour primaries flag");
Skip_UI( "custom colour primaries index");
TEST_SB_END();
TEST_SB_SKIP( "colour matrix flag");
Skip_UI( "colour matrix index");
TEST_SB_END();
TEST_SB_SKIP( "custom transfer function flag");
Skip_UI( "custom transfer function index");
TEST_SB_END();
}
TEST_SB_END();
Info_UI(picture_coding_mode, "picture coding mode"); Param_Info1(Dirac_picture_coding_mode(picture_coding_mode));
}
else
{
Skip_XX(Element_Size-Element_Offset, "Unknown");
}
FILLING_BEGIN();
//Autorisation of other streams
Streams[0x10].Searching_Payload=true; //End_of_Sequence
Streams[0x20].Searching_Payload=true; //Auxiliary_data
Streams[0x30].Searching_Payload=true; //Padding_data
Streams[0x0C].Searching_Payload=true; //Intra_Reference_Picture
Streams[0x08].Searching_Payload=true; //Intra_Non_Reference_Picture
Streams[0x4C].Searching_Payload=true; //Intra_Reference_Picture_No
Streams[0x48].Searching_Payload=true; //Intra_Non_Reference_Picture_No
Streams[0x0D].Searching_Payload=true; //Inter_Reference_Picture_1
Streams[0x0E].Searching_Payload=true; //Inter_Reference_Picture_2
Streams[0x09].Searching_Payload=true; //Inter_Non_Reference_Picture_1
Streams[0x0A].Searching_Payload=true; //Inter_Non_Reference_Picture_2
Streams[0xCC].Searching_Payload=true; //Reference_Picture_Low
Streams[0xC8].Searching_Payload=true; //Intra_Non_Reference_Picture_Low
FILLING_END();
}
//---------------------------------------------------------------------------
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_Jpeg::SIZ()
{
//Parsing
vector<float> SamplingFactors;
vector<int8u> BitDepths;
int8u SamplingFactors_Max=0;
int32u Xsiz, Ysiz;
int16u Count;
Skip_B2( "Rsiz - Capability of the codestream");
Get_B4 (Xsiz, "Xsiz - Image size X");
Get_B4 (Ysiz, "Ysiz - Image size Y");
Skip_B4( "XOsiz - Image offset X");
Skip_B4( "YOsiz - Image offset Y");
Skip_B4( "tileW - Size of tile W");
Skip_B4( "tileH - Size of tile H");
Skip_B4( "XTOsiz - Upper-left tile offset X");
Skip_B4( "YTOsiz - Upper-left tile offset Y");
Get_B2 (Count, "Components and initialize related arrays");
for (int16u Pos=0; Pos<Count; Pos++)
{
Element_Begin1("Initialize related array");
int8u BitDepth = 0, compSubsX = 0, compSubsY = 0;
BS_Begin();
Skip_SB( "Signed");
Get_S1 (7, BitDepth, "BitDepth"); Param_Info1(1+BitDepth); Element_Info1(1+BitDepth);
BS_End();
Get_B1 ( compSubsX, "compSubsX"); Element_Info1(compSubsX);
Get_B1 ( compSubsY, "compSubsY"); Element_Info1(compSubsY);
Element_End0();
//Filling list of HiVi
if (compSubsX)
{
SamplingFactors.push_back(((float)compSubsY)/compSubsX);
if (((float)compSubsY)/compSubsX>SamplingFactors_Max)
SamplingFactors_Max=(int8u)((float)compSubsY)/compSubsX;
}
if (BitDepths.empty() || BitDepth!=BitDepths[0])
BitDepths.push_back(BitDepth);
}
FILLING_BEGIN_PRECISE();
if (Frame_Count==0 && Field_Count==0)
{
Accept("JPEG 2000");
if (Count_Get(StreamKind_Last)==0)
Stream_Prepare(StreamKind_Last);
Fill(StreamKind_Last, 0, Fill_Parameter(StreamKind_Last, Generic_Format), "JPEG 2000");
Fill(StreamKind_Last, 0, Fill_Parameter(StreamKind_Last, Generic_Codec), "JPEG 2000");
if (StreamKind_Last==Stream_Image)
Fill(Stream_Image, 0, Image_Codec_String, "JPEG 2000", Unlimited, true, true); //To Avoid automatic filling
Fill(StreamKind_Last, 0, StreamKind_Last==Stream_Image?(size_t)Image_Width:(size_t)Video_Width, Xsiz);
Fill(StreamKind_Last, 0, StreamKind_Last==Stream_Image?(size_t)Image_Height:(size_t)Video_Height, Ysiz*(Interlaced?2:1)); //If image is from interlaced content, must multiply height by 2
if (BitDepths.size()==1)
Fill(StreamKind_Last, 0, Fill_Parameter(StreamKind_Last, Generic_BitDepth), 1+BitDepths[0]);
//Chroma subsampling
if (SamplingFactors_Max)
while (SamplingFactors_Max<4)
{
for (size_t Pos=0; Pos<SamplingFactors.size(); Pos++)
SamplingFactors[Pos]*=2;
SamplingFactors_Max*=2;
}
while (SamplingFactors.size()<3)
SamplingFactors.push_back(0);
Ztring ChromaSubsampling;
for (size_t Pos=0; Pos<SamplingFactors.size(); Pos++)
ChromaSubsampling+=Ztring::ToZtring(SamplingFactors[Pos], 0)+__T(':');
if (!ChromaSubsampling.empty())
{
ChromaSubsampling.resize(ChromaSubsampling.size()-1);
Fill(StreamKind_Last, 0, "ChromaSubsampling", ChromaSubsampling);
}
}
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;
}
