//---------------------------------------------------------------------------
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_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_DvbSubtitle::page_composition_segment()
{
Element_Name("page composition segment");
//Parsing
Skip_B1( "page_time_out");
BS_Begin();
Skip_S1(4, "page_version_number");
Skip_S1(2, "page_state");
Skip_S1(2, "reserved");
BS_End();
while(Element_Offset<Element_Size)
{
Element_Begin1("Region");
int16u region_horizontal_address, region_vertical_address;
int8u region_id;
Get_B1 (region_id, "region_id");
Skip_B1( "reserved");
Get_B2 (region_horizontal_address, "region_horizontal_address");
Get_B2 (region_vertical_address, "region_vertical_address");
Element_End0();
FILLING_BEGIN();
subtitle_streams[subtitle_stream_id].pages[page_id].regions[region_id].page_composition_segment=true;
subtitle_streams[subtitle_stream_id].pages[page_id].regions[region_id].region_horizontal_address=region_horizontal_address;
subtitle_streams[subtitle_stream_id].pages[page_id].regions[region_id].region_vertical_address=region_vertical_address;
FILLING_END();
}
}
//---------------------------------------------------------------------------
void File_Vc3::ImageGeometry()
{
//Parsing
Element_Begin("Image Geometry", 11);
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");
Mark_0();
Mark_0();
BS_End();
Element_End();
}
//---------------------------------------------------------------------------
void File_Jpeg::SOF_()
{
//Parsing
int16u Height, Width;
int8u Resolution, Count;
Get_B1 (Resolution, "Resolution");
Get_B2 (Height, "Height");
Get_B2 (Width, "Width");
Get_B1 (Count, "Number of image components in frame");
for (int8u Pos=0; Pos<Count; Pos++)
{
Skip_B1( "Identifier");
Skip_B1( "sampling factor");
Skip_B1( "Quantization table destination selector");
}
FILLING_BEGIN();
Stream_Prepare(Stream_General);
Fill(Stream_General, 0, General_Format, "JPEG");
if (Count_Get(StreamKind)==0)
Stream_Prepare(StreamKind);
Fill(StreamKind, 0, "Format", StreamKind==Stream_Image?"JPEG":"M-JPEG");
Fill(StreamKind, 0, "Codec", StreamKind==Stream_Image?"JPEG":"M-JPEG");
if (StreamKind==Stream_Image)
Fill(Stream_Image, 0, Image_Codec_String, "JPEG"); //To Avoid automatic filling
Fill(StreamKind, 0, "Resolution", Resolution*3);
Fill(StreamKind, 0, "Height", Height*Height_Multiplier);
Fill(StreamKind, 0, "Width", Width);
FILLING_END();
}
//---------------------------------------------------------------------------
// 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_DvbSubtitle::region_composition_segment()
{
Element_Name("region composition segment");
//Parsing
int16u region_width, region_height;
int8u region_id, region_depth;
Get_B1 ( region_id, "region_id");
BS_Begin();
Skip_S1(4, "region_version_number");
Skip_S1(1, "region_fill_flag");
Skip_S1(3, "reserved");
BS_End();
Get_B2 ( region_width, "region_width");
Get_B2 ( region_height, "region_height");
BS_Begin();
Skip_S1(3, "region_level_of_compatibility");
Get_S1 (3, region_depth, "region_depth"); Param_Info2(DvbSubtitle_region_depth[region_depth], " bits");
Skip_S1(2, "reserved");
BS_End();
Skip_B1( "CLUT_id");
Skip_B1( "region_8-bit_pixel_code");
BS_Begin();
Skip_S1(4, "region_4-bit_pixel-code");
Skip_S1(2, "region_2-bit_pixel-code");
Skip_S1(2, "reserved");
BS_End();
while(Element_Offset<Element_Size)
{
Element_Begin1("Object");
int8u object_type;
Skip_B2( "object_id");
BS_Begin();
Get_S1 ( 2, object_type, "object_type");
Skip_S1( 2, "object_provider_flag");
Skip_S1(12, "object_horizontal_position");
Skip_S1( 4, "reserved");
Skip_S1(12, "object_vertical_position");
BS_End();
switch (object_type)
{
case 0x01 :
case 0x02 :
Skip_B2( "foreground_pixel_code");
Skip_B2( "background_pixel_code");
break;
default : ;
}
Element_End0();
}
FILLING_BEGIN();
region_data& region = subtitle_streams[subtitle_stream_id].pages[page_id].regions[region_id];
region.region_composition_segment=true;
region.region_width=region_width;
region.region_height=region_height;
region.region_depth=region_depth;
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_Dpx::Get_X2(int16u &Info, const char* Name)
{
if (LittleEndian)
Get_L2 (Info, Name);
else
Get_B2 (Info, Name);
}
//---------------------------------------------------------------------------
void File_Als::FileHeader_Parse()
{
//Parsing
int32u SampleRate, Samples;
int16u Channels;
int8u BitsPerSample, FileType;
Skip_C4( "signature");
Get_B4 (SampleRate, "sample rate");
Get_B4 (Samples, "samples");
Get_B2 (Channels, "channels-1"); Param_Info2(Channels+1, " channel(s)");
BS_Begin();
Get_S1 (3, FileType, "file type"); // WAV, RIFF, AIFF
Get_S1 (3, BitsPerSample, "bits per sample"); Param_Info2((BitsPerSample+1)*8, " bits");
Skip_SB( "floating point");
Skip_SB( "samples are big-endian");
BS_End();
FILLING_BEGIN();
if (!CalcDurationUncompressedSize(Samples, SampleRate, (BitsPerSample+1)*8, Channels))
return;
File__Tags_Helper::Accept("ALS");
File__Tags_Helper::Stream_Prepare(Stream_Audio);
Fill(Stream_Audio, 0, Audio_Format, "ALS");
Fill(Stream_Audio, 0, Audio_Codec, "ALS");
Fill(Stream_Audio, 0, Audio_BitDepth, (BitsPerSample+1)*8);
Fill(Stream_Audio, StreamPos_Last, Audio_Channel_s_, Channels+1);
Fill(Stream_Audio, StreamPos_Last, Audio_SamplingRate, SampleRate);
Fill(Stream_Audio, 0, Audio_Duration, Duration);
//No more need data
File__Tags_Helper::Finish("ALS");
FILLING_END();
}
//---------------------------------------------------------------------------
void File_Pcm_M2ts::Read_Buffer_Continue()
{
if (Buffer_Size==0)
return;
//Parsing
int16u audio_data_payload_size;
Get_B2 ( audio_data_payload_size, "audio_data_payload_size");
BS_Begin();
Get_S1 (4, channel_assignment, "channel_assignment"); Param_Info2(Pcm_M2TS_channel_assignment[channel_assignment], " channel(s)");
Get_S1 (4, sampling_frequency, "sampling_frequency"); Param_Info2(Pcm_M2TS_sampling_frequency[sampling_frequency], " Hz");
Get_S1 (2, bits_per_sample, "bits_per_sample"); Param_Info2(Pcm_M2TS_bits_per_sample[bits_per_sample], " bits");
Skip_SB( "start_flag");
Skip_S1(5, "reserved");
BS_End();
Skip_XX(audio_data_payload_size, "audio_data_payload");
FILLING_BEGIN_PRECISE();
if (!Status[IsAccepted])
{
Accept();
Finish();
}
FILLING_END();
}
//---------------------------------------------------------------------------
void File_Jpeg::APP0_JFIF()
{
//Parsing
Skip_B1( "Zero");
Element_Begin1("JFIF");
int16u Width, Height;
int8u Unit, ThumbailX, ThumbailY;
Skip_B2( "Version");
Get_B1 (Unit, "Unit"); //0=Pixels, 1=dpi, 2=dpcm
Get_B2 (Width, "Xdensity");
Get_B2 (Height, "Ydensity");
Get_B1 (ThumbailX, "Xthumbail");
Get_B1 (ThumbailY, "Ythumbail");
Skip_XX(3*ThumbailX*ThumbailY, "RGB Thumbail");
Element_End0();
}
//---------------------------------------------------------------------------
void File_Mpeg4_Descriptors::Descriptor_03()
{
//Parsing
bool streamDependenceFlag, URL_Flag, OCRstreamFlag;
Get_B2 (ES_ID, "ES_ID");
BS_Begin();
Get_SB ( streamDependenceFlag, "streamDependenceFlag");
Get_SB ( URL_Flag, "URL_Flag");
Get_SB ( OCRstreamFlag, "OCRstreamFlag");
Skip_S1(5, "streamPriority");
BS_End();
if (streamDependenceFlag)
Skip_B2( "dependsOn_ES_ID");
if (URL_Flag)
{
int8u URLlength;
Get_B1 (URLlength, "URLlength");
Skip_UTF8(URLlength, "URLstring");
}
if (OCRstreamFlag)
Skip_B2( "OCR_ES_Id");
FILLING_BEGIN();
Element_ThisIsAList();
FILLING_END();
}
//---------------------------------------------------------------------------
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();
}
//---------------------------------------------------------------------------
int64u File_Ibi::UInteger_Get()
{
switch (Element_Size)
{
case 1 :
{
int8u Data;
Get_B1 (Data, "Data"); Element_Info(Data);
return Data;
}
case 2 :
{
int16u Data;
Get_B2 (Data, "Data"); Element_Info(Data);
return Data;
}
case 3 :
{
int32u Data;
Get_B3 (Data, "Data"); Element_Info(Data);
return Data;
}
case 4 :
{
int32u Data;
Get_B4 (Data, "Data"); Element_Info(Data);
return Data;
}
case 5 :
{
int64u Data;
Get_B5 (Data, "Data"); Element_Info(Data);
return Data;
}
case 6 :
{
int64u Data;
Get_B6 (Data, "Data"); Element_Info(Data);
return Data;
}
case 7 :
{
int64u Data;
Get_B7 (Data, "Data"); Element_Info(Data);
return Data;
}
case 8 :
{
int64u Data;
Get_B8 (Data, "Data"); Element_Info(Data);
return Data;
}
default : Skip_XX(Element_Size, "Data");
return 0;
}
}
//---------------------------------------------------------------------------
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_Jpeg::COD()
{
//Parsing
int16u Levels;
int8u Style, Style2, MultipleComponentTransform;
bool PrecinctUsed;
Get_B1 (Style, "Scod - Style");
Get_Flags (Style, 0, PrecinctUsed, "Precinct used");
Skip_Flags(Style, 1, "Use SOP (start of packet)");
Skip_Flags(Style, 2, "Use EPH (end of packet header)");
Skip_B1( "Number of decomposition levels");
Skip_B1( "Progression order");
Get_B2 (Levels, "Number of layers");
Info_B1(DimX, "Code-blocks dimensions X (2^(n+2))"); Param_Info2(1<<(DimX+2), " pixels");
Info_B1(DimY, "Code-blocks dimensions Y (2^(n+2))"); Param_Info2(1<<(DimY+2), " pixels");
Get_B1 (Style2, "Style of the code-block coding passes");
Skip_Flags(Style, 0, "Selective arithmetic coding bypass");
Skip_Flags(Style, 1, "MQ states for all contexts");
Skip_Flags(Style, 2, "Regular termination");
Skip_Flags(Style, 3, "Vertically stripe-causal context formation");
Skip_Flags(Style, 4, "Error resilience info is embedded on MQ termination");
Skip_Flags(Style, 5, "Segmentation marker is to be inserted at the end of each normalization coding pass");
Skip_B1( "Transform");
Get_B1(MultipleComponentTransform, "Multiple component transform");
if (PrecinctUsed)
{
BS_Begin();
Skip_S1(4, "LL sub-band width");
Skip_S1(4, "LL sub-band height");
BS_End();
for (int16u Pos=0; Pos<Levels; Pos++)
{
Element_Begin1("Decomposition level");
BS_Begin();
Skip_S1(4, "decomposition level width");
Skip_S1(4, "decomposition level height");
BS_End();
Element_End0();
}
}
FILLING_BEGIN();
if (Frame_Count==0 && Field_Count==0)
{
switch (MultipleComponentTransform)
{
case 0x01 : Fill(StreamKind_Last, 0, "Compression_Mode", "Lossless"); break;
case 0x02 : Fill(StreamKind_Last, 0, "Compression_Mode", "Lossy"); break;
default : ;
}
}
FILLING_END();
}
//---------------------------------------------------------------------------
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_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_Caf::FileHeader_Parse()
{
//Parsing
int16u FileVersion;
Skip_C4( "FileType");
Get_B2 (FileVersion, "FileVersion");
Skip_B2( "FileFlags");
FILLING_BEGIN();
Accept();
Fill(Stream_General, 0, General_Format, "CAF");
Fill(Stream_General, 0, General_Format_Version, __T("Version ")+Ztring::ToZtring(FileVersion));
Stream_Prepare(Stream_Audio);
if (FileVersion!=1)
Finish(); //Version 0 or 2+ are not supported
FILLING_END();
}
//---------------------------------------------------------------------------
void File_Tiff::GetValueOffsetu(ifditem &IfdItem)
{
ZtringList &Info=Infos[IfdItem.Tag]; Info.clear(); Info.Separator_Set(0, __T(" / "));
const char* Name=Tiff_Tag_Name(IfdItem.Tag);
if (IfdItem.Count>=10)
{
//Too many data, we don't currently need it and we skip it
Skip_XX(Element_Size-(Element_Offset+4), Name);
Info.clear();
return;
}
switch (IfdItem.Type)
{
case 1: /* 8-bit unsigned integer. */
for (int16u Pos=0; Pos<IfdItem.Count; Pos++)
{
int8u Ret8;
#if MEDIAINFO_TRACE
if (LittleEndian)
Get_L1 (Ret8, Name);
else
Get_B1 (Ret8, Name);
Element_Info1(Ztring::ToZtring(Ret8));
#else //MEDIAINFO_TRACE
if (Element_Offset+1>Element_Size)
{
Trusted_IsNot();
break;
}
if (LittleEndian)
Ret8=LittleEndian2int8u(Buffer+Buffer_Offset+(size_t)Element_Offset);
else
Ret8=BigEndian2int8u(Buffer+Buffer_Offset+(size_t)Element_Offset);
Element_Offset++;
#endif //MEDIAINFO_TRACE
Info.push_back(Ztring::ToZtring(Ret8));
}
break;
case 3: /* 16-bit (2-byte) unsigned integer. */
for (int16u Pos=0; Pos<IfdItem.Count; Pos++)
{
int16u Ret16;
#if MEDIAINFO_TRACE
if (LittleEndian)
Get_L2 (Ret16, Name);
else
Get_B2 (Ret16, Name);
switch (IfdItem.Tag)
{
case Tiff_Tag::Compression : Element_Info1(Tiff_Compression(Ret16)); break;
case Tiff_Tag::PhotometricInterpretation : Element_Info1(Tiff_PhotometricInterpretation(Ret16)); break;
default : Element_Info1(Ztring::ToZtring(Ret16));
}
#else //MEDIAINFO_TRACE
if (Element_Offset+2>Element_Size)
{
Trusted_IsNot();
break;
}
if (LittleEndian)
Ret16=LittleEndian2int16u(Buffer+Buffer_Offset+(size_t)Element_Offset);
else
Ret16=BigEndian2int16u(Buffer+Buffer_Offset+(size_t)Element_Offset);
Element_Offset+=2;
#endif //MEDIAINFO_TRACE
Info.push_back(Ztring::ToZtring(Ret16));
}
break;
case 4: /* 32-bit (4-byte) unsigned integer */
for (int16u Pos=0; Pos<IfdItem.Count; Pos++)
{
int32u Ret32;
#if MEDIAINFO_TRACE
if (LittleEndian)
Get_L4 (Ret32, Name);
else
Get_B4 (Ret32, Name);
Element_Info1(Ztring::ToZtring(Ret32));
#else //MEDIAINFO_TRACE
if (Element_Offset+4>Element_Size)
{
Trusted_IsNot();
break;
}
if (LittleEndian)
Ret32=LittleEndian2int32u(Buffer+Buffer_Offset+(size_t)Element_Offset);
else
Ret32=BigEndian2int32u(Buffer+Buffer_Offset+(size_t)Element_Offset);
Element_Offset+=4;
#endif //MEDIAINFO_TRACE
Info.push_back(Ztring::ToZtring(Ret32));
}
break;
default: //Unknown
{
if (LittleEndian)
Skip_L4( Name);
else
Skip_B4( Name);
Info.clear(); //We actually do not know the type
}
}
}
//---------------------------------------------------------------------------
void File_Jpeg::SOF_()
{
//Parsing
vector<Jpeg_samplingfactor> SamplingFactors;
int16u Height, Width;
int8u Resolution, Count;
Get_B1 (Resolution, "P - Sample precision");
Get_B2 (Height, "Y - Number of lines");
Get_B2 (Width, "X - Number of samples per line");
Get_B1 (Count, "Nf - Number of image components in frame");
for (int8u Pos=0; Pos<Count; Pos++)
{
Jpeg_samplingfactor SamplingFactor;
Element_Begin1("Component");
Info_B1(Ci, "Ci - Component identifier"); Element_Info1(Ci);
BS_Begin();
Get_S1 (4, SamplingFactor.Hi, "Hi - Horizontal sampling factor"); Element_Info1(SamplingFactor.Hi);
Get_S1 (4, SamplingFactor.Vi, "Vi - Vertical sampling factor"); Element_Info1(SamplingFactor.Vi);
BS_End();
Skip_B1( "Tqi - Quantization table destination selector");
Element_End0();
//Filling list of HiVi
SamplingFactors.push_back(SamplingFactor);
}
FILLING_BEGIN_PRECISE();
if (Frame_Count==0 && Field_Count==0)
{
Accept("JPEG");
if (Count_Get(StreamKind_Last)==0)
Stream_Prepare(StreamKind_Last);
Fill(StreamKind_Last, 0, Fill_Parameter(StreamKind_Last, Generic_Format), "JPEG");
Fill(StreamKind_Last, 0, Fill_Parameter(StreamKind_Last, Generic_Codec), "JPEG");
if (StreamKind_Last==Stream_Image)
Fill(Stream_Image, 0, Image_Codec_String, "JPEG", Unlimited, true, true); //To Avoid automatic filling
if (StreamKind_Last==Stream_Video)
Fill(Stream_Video, 0, Video_InternetMediaType, "video/JPEG", Unlimited, true, true);
Fill(StreamKind_Last, 0, "ColorSpace", "YUV");
Fill(StreamKind_Last, 0, Fill_Parameter(StreamKind_Last, Generic_BitDepth), Resolution);
Fill(StreamKind_Last, 0, "Height", Height*(Interlaced?2:1));
Fill(StreamKind_Last, 0, "Width", Width);
//Chroma subsampling
if (SamplingFactors.size()==3 && SamplingFactors[1].Hi==1 && SamplingFactors[2].Hi==1 && SamplingFactors[1].Vi==1 && SamplingFactors[2].Vi==1)
{
string ChromaSubsampling;
switch (SamplingFactors[0].Hi)
{
case 1 :
switch (SamplingFactors[0].Vi)
{
case 1 : ChromaSubsampling="4:4:4"; break;
default: ;
}
break;
case 2 :
switch (SamplingFactors[0].Vi)
{
case 1 : ChromaSubsampling="4:2:2"; break;
case 2 : ChromaSubsampling="4:2:0"; break;
default: ;
}
break;
case 4 :
switch (SamplingFactors[0].Vi)
{
case 1 : ChromaSubsampling="4:1:1"; break;
default: ;
}
break;
default: ;
}
if (!ChromaSubsampling.empty())
Fill(StreamKind_Last, 0, "ChromaSubsampling", ChromaSubsampling);
}
}
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_ProRes::Read_Buffer_Continue()
{
//Parsing
int32u Name, creatorID;
int16u hdrSize, version, frameWidth, frameHeight;
int8u chrominance_factor, frame_type, primaries, transf_func, colorMatrix;
bool IsOk=true, luma, chroma;
Element_Begin1("Header");
Skip_B4( "Size");
Get_C4 (Name, "Name");
Element_End();
Element_Begin1("Frame header");
Get_B2 (hdrSize, "hdrSize");
Get_B2 (version, "version");
Get_C4 (creatorID, "creatorID");
Get_B2 (frameWidth, "frameWidth");
Get_B2 (frameHeight, "frameHeight");
BS_Begin();
Get_S1 (2, chrominance_factor, "chrominance factor"); Param_Info1(ProRes_chrominance_factor(chrominance_factor));
Skip_S1(2, "reserved");
Get_S1 (2, frame_type, "frame type"); Param_Info1(ProRes_frame_type_ScanType(frame_type)); Param_Info1(ProRes_frame_type_ScanOrder(frame_type));
Skip_S1(2, "reserved");
BS_End();
Skip_B1( "reserved");
Get_B1 (primaries, "primaries"); Param_Info1(Mpegv_colour_primaries(primaries));
Get_B1 (transf_func, "transf_func"); Param_Info1(Mpegv_transfer_characteristics(transf_func));
Get_B1 (colorMatrix, "colorMatrix"); Param_Info1(Mpegv_matrix_coefficients(colorMatrix));
BS_Begin();
Skip_S1(4, "src_pix_fmt");
Skip_S1(4, "alpha_info");
BS_End();
Skip_B1( "reserved");
BS_Begin();
Skip_S1(6, "reserved");
Get_SB (luma, "custom luma quant matrix present");
Get_SB (chroma, "custom chroma quant matrix present");
BS_End();
if (luma)
Skip_XX(64, "QMatLuma");
if (chroma)
Skip_XX(64, "QMatChroma");
Element_End();
if (Element_Offset!=8+(int32u)hdrSize)
IsOk=false;
for (int8u PictureNumber=0; PictureNumber<(frame_type?2:1); PictureNumber++)
{
Element_Begin1("Picture layout");
int16u total_slices;
vector<int16u> slices_size;
Element_Begin1("Picture header");
int64u pic_hdr_End, pic_data_End;
int32u pic_data_size;
int8u pic_hdr_size;
Get_B1 (pic_hdr_size, "pic_hdr_size");
if (pic_hdr_size<64)
{
Trusted_IsNot("pic_hdr_size");
Element_End();
Element_End();
return;
}
pic_hdr_End=Element_Offset+pic_hdr_size/8-((pic_hdr_size%8)?0:1);
Get_B4 (pic_data_size, "pic_data_size");
if (pic_data_size<8)
{
Trusted_IsNot("pic_data_size");
Element_End();
Element_End();
return;
}
pic_data_End=Element_Offset+pic_data_size-5;
Get_B2 (total_slices, "total_slices");
BS_Begin();
Skip_S1(4, "slice_width_factor");
Skip_S1(4, "slice_height_factor");
BS_End();
if (Element_Offset<pic_hdr_End)
Skip_XX(pic_hdr_End-Element_Offset, "Unknown");
Element_End();
Element_Begin1("Slice index table");
for (int16u Pos=0; Pos<total_slices; Pos++)
{
int16u slice_size;
Get_B2 (slice_size, "slice_size");
slices_size.push_back(slice_size);
}
Element_End();
for (int16u Pos=0; Pos<slices_size.size(); Pos++)
{
Skip_XX(slices_size[Pos], "slice data");
}
if (Element_Offset<pic_data_End)
Skip_XX(pic_data_End-Element_Offset, "Unknown");
Element_End();
}
bool IsZeroes=true;
for (size_t Pos=(size_t)Element_Offset; Pos<(size_t)Element_Size; Pos++)
if (Buffer[Buffer_Offset+Pos])
{
IsZeroes=false;
break;
}
Skip_XX(Element_Size-Element_Offset, IsZeroes?"Zeroes":"Unknown");
FILLING_BEGIN();
if (IsOk && Name==0x69637066 && !Status[IsAccepted]) //icpf
{
Accept();
Fill();
Fill(Stream_Video, 0, Video_Format_Version, __T("Version ")+Ztring::ToZtring(version));
Fill(Stream_Video, 0, Video_Width, frameWidth);
Fill(Stream_Video, 0, Video_Height, frameHeight);
Fill(Stream_Video, 0, Video_Encoded_Library, ProRes_creatorID(creatorID));
Fill(Stream_Video, 0, Video_ChromaSubsampling, ProRes_chrominance_factor(chrominance_factor));
Fill(Stream_Video, 0, Video_ScanType, ProRes_frame_type_ScanType(frame_type));
Fill(Stream_Video, 0, Video_ScanOrder, ProRes_frame_type_ScanOrder(frame_type));
Fill(Stream_Video, 0, Video_colour_description_present, "Yes");
Fill(Stream_Video, 0, Video_colour_primaries, Mpegv_colour_primaries(primaries));
Fill(Stream_Video, 0, Video_transfer_characteristics, Mpegv_transfer_characteristics(transf_func));
Fill(Stream_Video, 0, Video_matrix_coefficients, Mpegv_matrix_coefficients(colorMatrix));
Finish();
}
FILLING_END();
}
//---------------------------------------------------------------------------
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_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;
}
