//---------------------------------------------------------------------------
void File_Exr::Header_Parse()
{
//Header
if (CC4(Buffer+Buffer_Offset)==0x762F3101) //"v/1"+1
{
//Filling
Header_Fill_Code(0, "File header");
Header_Fill_Size(12);
return;
}
//Image data
if (name_End==0)
{
//Filling
Header_Fill_Code(0, "Image data");
Header_Fill_Size(ImageData_End-(File_Offset+Buffer_Offset));
return;
}
int32u size;
Get_String(name_End, name, "name");
Element_Offset++; //Null byte
Get_String(type_End, type, "type");
Element_Offset++; //Null byte
Get_L4 (size, "size");
//Filling
Header_Fill_Code(0, Ztring().From_Local(name.c_str()));
Header_Fill_Size(name_End+1+type_End+1+4+size);
}
//---------------------------------------------------------------------------
void File_DvbSubtitle::Header_Parse()
{
//Parsing
int8u sync_byte;
Get_B1 (sync_byte, "sync_byte");
switch (sync_byte)
{
case 0xFF : //Stuffing
MustFindDvbHeader=true;
//Filling
Header_Fill_Code(0xFF, "end of PES data field marker");
Header_Fill_Size(1);
return;
default : ; //Normal (0x0F)
}
int16u segment_length;
int8u segment_type;
Get_B1 (segment_type, "segment_type");
Get_B2 (page_id, "page_id");
Get_B2 (segment_length, "segment_length");
//Filling
Header_Fill_Code(segment_type);
Header_Fill_Size(Element_Offset+segment_length);
}
//---------------------------------------------------------------------------
void File_Lyrics3v2::Header_Parse()
{
if (TotalSize<=15) //First 10 is minimum size of a tag, Second 10 is ID3v2 header size
{
//Place for footer
Header_Fill_Code((int64u)-1, "File Footer");
Header_Fill_Size(TotalSize);
return;
}
//Parsing
Ztring SizeT;
int64u Size;
int32u Field;
Get_C3 (Field, "Field");
Get_Local(5, SizeT, "Size");
Size=8+SizeT.To_int64u();
//Filling
if (Size+15>TotalSize)
Size=TotalSize-15;
Header_Fill_Code(Field, Ztring().From_CC3(Field));
Header_Fill_Size(Size);
TotalSize-=Size;
}
//---------------------------------------------------------------------------
void File_Nut::Header_Parse()
{
//Parsing
int8u N;
Peek_B1(N);
if (N==0x4E) //'N'
{
//Header
int64u startcode, forward_ptr;
Get_B8(startcode, "startcode");
Get_VS(forward_ptr, "forward_ptr");
if (forward_ptr>4096)
Skip_B4( "header_checksum");
Header_Fill_Code(startcode, Ztring().From_Number(startcode, 16)); //Quick filling for CC8 with text
Header_Fill_Size(Element_Offset+forward_ptr); //4 for cheksum
}
else
{
//Frame
Header_Fill_Code(0, "Frame");
Header_Fill_Size(0);
Finish();
}
}
//---------------------------------------------------------------------------
void File_Mpeg4_Descriptors::Header_Parse()
{
//Parsing
size_t Size=0;
int8u type, Size_ToAdd;
Get_B1(type, "type");
if (type==0)
{
Header_Fill_Code(0x00, "Padding");
Header_Fill_Size(1);
return;
}
do
{
Get_B1(Size_ToAdd, "size");
Size=(Size<<7) | (Size_ToAdd&0x7F);
}
while (Size_ToAdd&0x80);
//Filling
Header_Fill_Code(type, Ztring().From_CC1(type));
if (Element_Offset+Size>=Element_Size)
Size=(size_t)(Element_Size-Element_Offset); //Found one file with too big size but content is OK, cutting the block
Header_Fill_Size(Element_Offset+Size);
}
//---------------------------------------------------------------------------
void File_Vc3::Header_Parse()
{
int32u CompressionID=BigEndian2int32u(Buffer+Buffer_Offset+0x28);
Header_Fill_Code(0, "Frame");
Header_Fill_Size(Vc3_CompressedFrameSize(CompressionID));
}
//---------------------------------------------------------------------------
// An Element
// Size 2 bytes, Pos=4
// Code 5 bytes, Pos=6
//
void File_Jpeg::Header_Parse()
{
//Parsing
int16u code, size=0;
Get_B2 (code, "code");
switch (code)
{
case Elements::TEM :
case Elements::RST0 :
case Elements::RST1 :
case Elements::RST2 :
case Elements::RST3 :
case Elements::RST4 :
case Elements::RST5 :
case Elements::RST6 :
case Elements::RST7 :
case Elements::SOI :
case Elements::EOI :
break; //Size=0
default : Get_B2 (size, "size");
}
//Filling
Header_Fill_Code(code, Ztring().From_CC2(code));
Header_Fill_Size(2+size);
}
//---------------------------------------------------------------------------
void File_Pcm::Header_Parse()
{
//Filling
Header_Fill_Code(0, "Block");
if (BitDepth && Channels)
Header_Fill_Size((Element_Size/(BitDepth*Channels/8))*(BitDepth*Channels/8)); //A complete sample
else
Header_Fill_Size(Element_Size); // Unknown sample size
}
//---------------------------------------------------------------------------
void File_Dts::Header_Parse()
{
//Parsing
int16u Primary_Frame_Byte_Size_minus_1;
int8u EncoderSoftwareRevision;
bool crc_present;
Skip_B4( "Sync");
BS_Begin();
Info_SB( FrameType, "Frame Type"); Param_Info(DTS_FrameType[FrameType]);
Skip_S1( 5, "Deficit Sample Count");
Get_SB ( crc_present, "CRC Present");
Skip_S1( 7, "Number of PCM Sample Blocks");
Get_S2 (14, Primary_Frame_Byte_Size_minus_1, "Primary Frame Byte Size minus 1");
Primary_Frame_Byte_Size_minus_1+=1;
if (!Word) Primary_Frame_Byte_Size_minus_1=Primary_Frame_Byte_Size_minus_1*8/14*2; Param_Info(Ztring::ToZtring(Primary_Frame_Byte_Size_minus_1)+_T(" bytes")); //Word is on 14 bits!
Get_S1 ( 6, channel_arrangement, "Audio Channel Arrangement"); Param_Info(Ztring::ToZtring(DTS_Channels[channel_arrangement])+_T(" channels"));
Get_S1 ( 4, sample_frequency, "Core Audio Sampling Frequency"); Param_Info(Ztring::ToZtring(DTS_SamplingRate[sample_frequency])+_T(" Hz"));
Get_S1 ( 5, bit_rate, "Transmission Bit Rate"); Param_Info(Ztring::ToZtring(DTS_BitRate[bit_rate])+_T(" bps"));
Skip_SB( "Embedded Down Mix Enabled");
Skip_SB( "Embedded Dynamic Range");
Skip_SB( "Embedded Time Stamp");
Skip_SB( "Auxiliary Data");
Skip_SB( "HDCD");
Get_S1 ( 3, ExtensionAudioDescriptor, "Extension Audio Descriptor"); Param_Info(DTS_ExtensionAudioDescriptor[ExtensionAudioDescriptor]);
Get_SB ( ExtendedCoding, "Extended Coding");
Skip_SB( "Audio Sync Word Insertion");
Get_S1 ( 2, lfe_effects, "Low Frequency Effects");
Skip_SB( "Predictor History");
if (crc_present)
Skip_S2(16, "Header CRC Check");
Skip_SB( "Multirate Interpolator");
Get_S1 ( 4, EncoderSoftwareRevision, "Encoder Software Revision");
Skip_S1( 2, "Copy History");
Get_S1 ( 2, bits_per_sample, "Source PCM Resolution"); Param_Info(Ztring::ToZtring(DTS_Resolution[bits_per_sample])+_T(" bits"));
Skip_SB( "ES");
Skip_SB( "Front Sum/Difference");
Skip_SB( "Surrounds Sum/Difference");
Skip_S1( 4, "Dialog Normalisation Parameter");
switch (EncoderSoftwareRevision)
{
case 6 :
Skip_S1( 4, "Dialog Normalisation Parameter");
break;
case 7 :
Skip_S1( 4, "Dialog Normalisation Parameter");
break;
default :
Skip_S1( 4, "Unspecified");
break;
}
BS_End();
//Filling
Header_Fill_Size(Primary_Frame_Byte_Size_minus_1+DTS_HD_Unknown_Size); //TODO: change this, for DTS-HD
Header_Fill_Code(0, "Frame");
}
//---------------------------------------------------------------------------
void File_Wvpk::Header_Parse()
{
//Specific cases
if (FromMKV)
{
Header_Fill_Size(Element_Size);
Header_Fill_Code(0, "Block");
return;
}
//Parsing
int32u ckSize;
Skip_C4( "ckID");
Get_L4 (ckSize, "ckSize");
//Filling
Header_Fill_Size(8+ckSize);
Header_Fill_Code(0, "Block");
}
//---------------------------------------------------------------------------
void File_Png::Header_Parse()
{
if (!Signature_Parsed)
{
//Filling
Header_Fill_Size(8);
Header_Fill_Code(0, "File header");
return;
}
//Parsing
int32u Length, Chunk_Type;
Get_B4 (Length, "Length");
Get_C4 (Chunk_Type, "Chunk Type");
//Filling
Header_Fill_Size(12+Length); //+4 for CRC
Header_Fill_Code(Chunk_Type, Ztring().From_CC4(Chunk_Type));
}
//---------------------------------------------------------------------------
void File_Lyrics3v2::Header_Parse()
{
if (Buffer_Offset+15>=Buffer_Size) //first 10 is minimum size of a tag, Second 10 is ID3v2 header size
{
//Place for footer
Header_Fill_Code(0xFFFFFFFF, "Footer");
Header_Fill_Size(Buffer_Size-Buffer_Offset);
return;
}
//Parsing
Ztring Size;
int32u Field;
Get_C3 (Field, "Field");
Get_Local(5, Size, "Size");
//Filling
Header_Fill_Code(Field, Ztring().From_CC3(Field));
Header_Fill_Size(8+Size.To_int64u());
}
//---------------------------------------------------------------------------
void File_TwinVQ::Header_Parse()
{
//Parsing
int32u id, size;
Get_C4 (id, "id");
Get_B4 (size, "size");
//Filling
Header_Fill_Code(id, Ztring().From_CC4(id));
Header_Fill_Size(8+(id==Elements::DATA?0:size)); //DATA chunk indicates the end of the header, with no chunk size
}
//---------------------------------------------------------------------------
void File_Wm::Header_Parse()
{
if (!MustUseAlternativeParser)
{
//Parsing
int128u Name;
int64u Size;
Get_GUID(Name, "Name");
Get_L8 (Size, "Size");
//Filling
Header_Fill_Code(Name.hi, Ztring().From_GUID(Name));
Header_Fill_Size(Size);
}
else
{
Header_Fill_Code(0, "Packet");
Header_Fill_Size(MaximumDataPacketSize);
}
}
//---------------------------------------------------------------------------
void File_Png::Header_Parse()
{
//Parsing
int32u Length, Chunk_Type;
Get_B4 (Length, "Length");
Get_C4 (Chunk_Type, "Chunk Type");
//Filling
Header_Fill_Size(12+Length); //+4 for CRC
Header_Fill_Code(Chunk_Type, Ztring().From_CC4(Chunk_Type));
}
//---------------------------------------------------------------------------
void File_Tak::Header_Parse()
{
//Parsing
int32u block_length;
int8u block_type;
Get_L1 (block_type, "Block Type");
Get_L3 (block_length, "Block Length");
//Filling
Header_Fill_Code(block_type, Ztring().From_CC1(block_type));
Header_Fill_Size(Element_Offset+block_length);
}
//---------------------------------------------------------------------------
void File_Latm::Header_Parse()
{
int16u audioMuxLengthBytes;
BS_Begin();
Skip_S2(11, "syncword");
Get_S2 (13, audioMuxLengthBytes, "audioMuxLengthBytes");
BS_End();
//Filling
Header_Fill_Size(3+audioMuxLengthBytes);
Header_Fill_Code(0, "LATM");
}
//---------------------------------------------------------------------------
void File_Eia708::Header_Parse()
{
//Parsing
int8u packet_size, sequence_number;
BS_Begin();
Get_S1(2, sequence_number, "sequence_number");
Get_S1(6, packet_size, "packet_size");
BS_End();
Header_Fill_Code(0, _T("DTVCC packet"));
Header_Fill_Size(packet_size*2);
}
//---------------------------------------------------------------------------
void File_TimedText::Header_Parse()
{
//Parsing
int16u Size;
Get_B2 (Size, "Size");
//Filling
Header_Fill_Code(0, "Block");
Header_Fill_Size(Element_Offset+Size);
//TODO: if IsChapter, it may be UTF-16 (with BOM), it may also be followed by an encd atom (e.g. for UTF-8 00 00 00 0C 65 6E 63 64 00 00 01 00)
}
//---------------------------------------------------------------------------
void File_MpcSv8::Header_Parse()
{
//Parsing
int64u Size;
int16u Key;
Get_C2 (Key, "Key");
Get_VS (Size, "Size");
//Filling
Header_Fill_Code(Key, Ztring().From_CC4(Key<<16)); //Quick filling for CC2 with text
Header_Fill_Size(Key==Elements::AP?Element_Offset:Size); //We don't need the data of audio packet, and we will stop here...
}
//---------------------------------------------------------------------------
void File_Ibi::Header_Parse()
{
//Test of zero padding
int8u Null;
Peek_B1(Null);
if (Null==0x00)
{
Skip_B1( "Zero byte");
Header_Fill_Code((int32u)-1); //Should be (int64u)-1 but Borland C++ does not like this
Header_Fill_Size(1);
return;
}
//Parsing
int64u Name, Size;
Get_EB (Name, "Name");
Get_EB (Size, "Size");
//Filling
Header_Fill_Code(Name, Ztring().From_Number(Name, 16));
Header_Fill_Size(Element_Offset+Size);
}
//---------------------------------------------------------------------------
void File_Exr::Header_Parse()
{
//Image data
if (name_End==0)
{
//Filling
Header_Fill_Code(0, "Image data");
Header_Fill_Size(ImageData_End-(File_Offset+Buffer_Offset));
return;
}
int32u size;
Get_String(name_End, name, "name");
Element_Offset++; //Null byte
Get_String(type_End, type, "type");
Element_Offset++; //Null byte
Get_L4 (size, "size");
//Filling
Header_Fill_Code(0, Ztring().From_ISO_8859_1(name.c_str()));
Header_Fill_Size(name_End+1+type_End+1+4+size);
}
//---------------------------------------------------------------------------
void File_Jpeg::Header_Parse()
{
if (SOS_SOD_Parsed)
{
Header_Fill_Code(0, "Data");
if (!Header_Parser_Fill_Size())
{
Element_WaitForMoreData();
return;
}
return;
}
//Parsing
int16u code, size;
Get_B2 (code, "Marker");
switch (code)
{
case Elements::TEM :
case Elements::RST0 :
case Elements::RST1 :
case Elements::RST2 :
case Elements::RST3 :
case Elements::RST4 :
case Elements::RST5 :
case Elements::RST6 :
case Elements::RST7 :
case Elements::SOC :
case Elements::SOD :
case Elements::SOI :
case Elements::EOI :
size=0; break;
default : Get_B2 (size, "Fl - Frame header length");
}
//Filling
Header_Fill_Code(code, Ztring().From_CC2(code));
Header_Fill_Size(2+size);
}
//---------------------------------------------------------------------------
void File_Cdxa::Header_Parse()
{
//Parsing
Skip_B4( "Sync1");
Skip_B4( "Sync2");
Skip_B4( "Sync3");
Skip_B4( "Header");
Skip_B8( "SubHeader");
//Filling
Header_Fill_Size(2352);
Header_Fill_Code(0, "Chunk");
}
//---------------------------------------------------------------------------
void File_ApeTag::Header_Parse()
{
//Testing if begin or end of tags
if (CC8(Buffer+Buffer_Offset)==0x4150455441474558LL) //"APETAGEX"
{
//Filling
Header_Fill_Code((int64u)-1, "File Footer");
Header_Fill_Size(0x20);
return;
}
//Parsing
Ztring Value;
int32u Flags, Length;
Get_L4 (Length, "Length");
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");
size_t Pos=(size_t)Element_Offset;
for (; Pos<Element_Size; Pos++)
if (Buffer[Buffer_Offset+Pos]==0x00)
break;
if (Pos==Element_Size)
{
Element_WaitForMoreData();
return;
}
Get_String(Pos-Element_Offset, Key, "Key");
Skip_L1( "0x00");
//Filling
Header_Fill_Code(0, Key.c_str());
Header_Fill_Size(Element_Offset+Length);
}
//---------------------------------------------------------------------------
void File_Ibi::Header_Parse()
{
//Test of zero padding
int8u Null;
Peek_B1(Null);
if (Null==0x00)
{
if (Buffer_Offset_Temp==0)
Buffer_Offset_Temp=Buffer_Offset+1;
while (Buffer_Offset_Temp<Buffer_Size)
{
if (Buffer[Buffer_Offset_Temp])
break;
Buffer_Offset_Temp++;
}
if (Buffer_Offset_Temp>=Buffer_Size)
{
Element_WaitForMoreData();
return;
}
Header_Fill_Code((int32u)-1); //Should be (int64u)-1 but Borland C++ does not like this
Header_Fill_Size(Buffer_Offset_Temp-Buffer_Offset);
Buffer_Offset_Temp=0;
return;
}
//Parsing
int64u Name, Size;
Get_EB (Name, "Name");
Get_EB (Size, "Size");
//Filling
Header_Fill_Code(Name, Ztring().From_Number(Name, 16));
Header_Fill_Size(Element_Offset+Size);
}
//---------------------------------------------------------------------------
void File_Dirac::Header_Parse()
{
//Parsing
int32u Next_Parse_Offset, Previous_Parse_Offset;
int8u Parse_Code;
Skip_C4( "Parse Info Prefix");
Get_B1 (Parse_Code, "Parse Code");
Get_B4 (Next_Parse_Offset, "Next Parse Offset");
Get_B4 (Previous_Parse_Offset, "Previous Parse Offset");
//Filling
Header_Fill_Code(Parse_Code, Ztring().From_CC1(Parse_Code));
Header_Fill_Size(Next_Parse_Offset);
}
//---------------------------------------------------------------------------
void File_Vc1::Header_Parse()
{
//Specific
if (From_WMV3 || Only_0D)
{
Header_Fill_Size(Buffer_Size);
Header_Fill_Code(From_WMV3?0x0F:0x0D, Ztring().From_CC1(From_WMV3?0x0F:0x0D));
return;
}
//Parsing
int8u start_code;
Skip_B3( "synchro");
Get_B1 (start_code, "start_code");
if (!Header_Parser_Fill_Size())
{
Element_WaitForMoreData();
return;
}
//Filling
Header_Fill_Code(start_code, Ztring().From_CC1(start_code));
}
//---------------------------------------------------------------------------
void File_Dirac::Header_Parse()
{
//Parsing
int32u Next_Parse_Offset, Previous_Parse_Offset;
int8u Parse_Code;
Skip_C4( "Parse Info Prefix");
Get_B1 (Parse_Code, "Parse Code");
Get_B4 (Next_Parse_Offset, "Next Parse Offset");
Get_B4 (Previous_Parse_Offset, "Previous Parse Offset");
//Filling
Header_Fill_Code(Parse_Code, Ztring().From_CC1(Parse_Code));
Header_Fill_Size((Parse_Code==0x10 && Next_Parse_Offset==0)?13:Next_Parse_Offset); //Speacial case if this is the End Of Sequence
}
//---------------------------------------------------------------------------
void File_Tiff::Header_Parse()
{
//Handling remaining IFD data
if (!IfdItems.empty())
{
if (File_Offset+Buffer_Offset!=IfdItems.begin()->first)
IfdItems.clear(); //There was a problem during the seek, trashing remaining positions from last IFD
else
{
Header_Fill_Code(IfdItems.begin()->second.Tag, Tiff_Tag_Name(IfdItems.begin()->second.Tag));
Header_Fill_Size(Tiff_Type_Size(IfdItems.begin()->second.Type)*IfdItems.begin()->second.Count);
return;
}
}
/* A tiff images consist in principle of two types of blocks, IFD's and data blocks */
/* Each datablock, which could be a image, tiles, transperancy filter is described by one IFD. */
/* These IFD's can be placed at any offset in the file and are linked in a chain fashion way. */
/* where one IFD points out where the next IFD is placed */
/* */
/* A creator of a tiff file must describe the "main image" in the first IFD, this means that a */
/* reader, such this one, only need to read the first IFD in order to get the bitdepth, resolution etc. */
/* of the main image. */
/* Read one IFD and print out the result */
/* Scan the tiff file for the IFD's (Image File Directory) */
/* As long as the IFD offset to the next IFD in the file is not 0 */
/* Get number of directories for this IFD */
int16u NrOfDirectories;
Get_X2 (NrOfDirectories, "NrOfDirectories");
//Filling
Header_Fill_Code(0xFFFFFFFF, "IFD"); //OxFFFFFFFF can not be a Tag, so using it as a magic value
Header_Fill_Size(2+12*((int64u)NrOfDirectories)+4); //2 for header + 12 per directory + 4 for next IFD offset
}
