//--------------------------------------------------------------------------- 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; }