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_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_Flac::FileHeader_Parse()
{
//Parsing
int32u Signature;
if (VorbisHeader)
{
Skip_B1( "Signature");
Skip_Local(4, "Signature");
Skip_B1( "Major version");
Skip_B1( "Minor version");
Skip_B2( "Number of header");
}
Get_C4 (Signature, "Signature");
FILLING_BEGIN();
//Integrity
if (Signature!=CC4("fLaC"))
{
Finished();
return;
}
Stream_Prepare(Stream_General);
Fill(Stream_General, 0, General_Format, "FLAC");
FILLING_END();
}
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_Info(Pos);
Param_Info(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_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();
}
//---------------------------------------------------------------------------
void File_Tak::ENCODERINFO()
{
//Parsing
int8u Revision, Minor, Major, Preset_hi, Preset_lo;
Get_L1 (Revision, "Revision");
Get_L1 (Minor, "Minor");
Get_L1 (Major, "Major");
BS_Begin();
Get_S1 (4, Preset_hi, "Preset (hi)");
Get_S1 (4, Preset_lo, "Preset (lo)");
BS_End();
FILLING_BEGIN();
Ztring Version=Ztring::ToZtring(Major)+__T('.')+Ztring::ToZtring(Minor)+__T('.')+Ztring::ToZtring(Revision);
Ztring Preset=__T("-p")+Ztring::ToZtring(Preset_lo);
switch (Preset_hi)
{
case 0x00 : break;
case 0x01 : Preset+=__T('e'); break;
case 0x02 : Preset+=__T('m'); break;
default : Preset+=__T('-')+Ztring::ToZtring(Preset_hi, 16); //Unknown
}
Fill(Stream_Audio, 0, Audio_Encoded_Library, "TAK");
Fill(Stream_Audio, 0, Audio_Encoded_Library_String, __T("TAK ")+Version);
Fill(Stream_Audio, 0, Audio_Encoded_Library_Name, "TAK");
Fill(Stream_Audio, 0, Audio_Encoded_Library_Version, Version);
Fill(Stream_Audio, 0, Audio_Encoded_Library_Settings, Preset);
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_Cdxa::FileHeader_Parse()
{
//Parsing
Skip_C4( "RIFF header");
Skip_L4( "RIFF data size");
Skip_C4( "CDXA");
Skip_C4( "fmt header");
Skip_L4( "fmt size");
Skip_L2( "user_id");
Skip_L2( "group_id");
Skip_L2( "attributes");
Skip_C2( "xa_signature");
Skip_L4( "xa_track_number");
Skip_L4( "reserved");
Skip_C4( "data header");
Skip_L4( "data size");
FILLING_BEGIN();
Accept("CDXA");
MI=new MediaInfo_Internal;
MI->Option(_T("FormatDetection_MaximumOffset"), _T("1048576"));
//MI->Option(_T("File_IsSub"), _T("1"));
MI->Open_Buffer_Init(File_Size, File_Offset+Buffer_Offset);
FILLING_END();
}
//---------------------------------------------------------------------------
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_Info(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_Resolution, 16); //MPC support only 16 bits
FILLING_END();
}
//---------------------------------------------------------------------------
void File_Amr::FileHeader_Parse()
{
//From a container
if (!Codec.empty())
{
Accept("AMR");
Finish("AMR");
return;
}
//Parsing
int64u Signature;
Skip_C5( "Signature (Common)");
Peek_B8(Signature);
if ((Signature&0xFF00000000000000LL)==0x0A00000000000000LL) //\n
{
IsWB=false;
Channels=1;
}
else if ((Signature&0xFFFFFFFFFFFFFF00LL)==0x5F4D43312E300A00LL) //_MC1.0\n
{
IsWB=false;
Channels=2; //Or more, see later
}
else if ((Signature&0xFFFFFF0000000000LL)==0x2D57420000000000LL) //-WB
{
Skip_C3( "Signature (WB)");
IsWB=true;
Peek_B8(Signature);
if ((Signature&0xFF00000000000000LL)==0x0A00000000000000LL) //\n
{
Channels=1;
}
else if ((Signature&0xFFFFFFFFFFFFFF00LL)==0x5F4D43312E300A00LL) //_MC1.0\n
{
Channels=2; //Or more, see later
}
}
else
Channels=0;
Skip_B1( "Signature (Carriage return)");
/*
if (Channels==2) //Mutli-channels
{
BS_Begin();
Skip_S4(28, "Reserved");
Get_S1 ( 4, Channels, "Channels");
}
*/
Header_Size=(int8u)Element_Offset;
FILLING_BEGIN();
Accept("AMR");
if (Channels!=1 || IsWB)
Finish("AMR");
FILLING_END();
}
//---------------------------------------------------------------------------
void File_Mpeg4_Descriptors::Descriptor_02()
{
//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");
}
Info_B1(ODProfileLevel, "ODProfileLevelIndication"); Param_Info(Mpeg4_Descriptors_ODProfileLevelIndication(ODProfileLevel));
Info_B1(SceneProfileLevel, "sceneProfileLevelIndication"); Param_Info(Mpeg4_Descriptors_SceneProfileLevelIndication(SceneProfileLevel));
Info_B1(AudioProfileLevel, "audioProfileLevelIndication"); Param_Info(Mpeg4_Descriptors_AudioProfileLevelIndication(AudioProfileLevel));
Info_B1(VisualProfileLevel, "visualProfileLevelIndication"); Param_Info(Mpeg4_Descriptors_VisualProfileLevelIndication(VisualProfileLevel));
Info_B1(GraphicsProfileLevel, "graphicsProfileLevelIndication"); Param_Info(Mpeg4_Descriptors_GraphicsProfileLevelIndication(GraphicsProfileLevel));
FILLING_BEGIN();
Element_ThisIsAList();
FILLING_END();
}
//---------------------------------------------------------------------------
void File_Jpeg::APP0_AVI1()
{
//Parsing
int8u FieldOrder=(int8u)-1;
Element_Begin1("AVI1");
if (Element_Size==16-4)
{
Get_B1 (FieldOrder, "Field Order");
Skip_XX(7, "Zeroes");
}
if (Element_Size==18-4)
{
Get_B1 (FieldOrder, "Field Order");
Skip_B1( "Zero");
Skip_B4( "Size of 1st Field");
Skip_B4( "Size of 2nd Field");
}
Element_End0();
FILLING_BEGIN();
if (Frame_Count==0 && Field_Count==0)
{
switch (FieldOrder)
{
case 0x00 : Fill(Stream_Video, 0, Video_Interlacement, "PPF"); Fill(Stream_Video, 0, Video_ScanType, "Progressive"); break;
case 0x01 : Fill(Stream_Video, 0, Video_Interlacement, "TFF"); Fill(Stream_Video, 0, Video_ScanType, "Interlaced"); Fill(Stream_Video, 0, Video_ScanOrder, "TFF"); Height_Multiplier=2; break;
case 0x02 : Fill(Stream_Video, 0, Video_Interlacement, "BFF"); Fill(Stream_Video, 0, Video_ScanType, "Interlaced"); Fill(Stream_Video, 0, Video_ScanOrder, "BFF"); Height_Multiplier=2; break;
default : ;
}
}
FILLING_END();
}
//---------------------------------------------------------------------------
void File_Caf::desc()
{
//Parsing
float64 SampleRate;
int32u FormatID, FormatFlags, BytesPerPacket, FramesPerPacket, ChannelsPerFrame, BitsPerChannel;
Get_BF8(SampleRate, "SampleRate");
Get_C4 (FormatID, "FormatID");
Get_B4 (FormatFlags, "FormatFlags");
Get_B4 (BytesPerPacket, "BytesPerPacket");
Get_B4 (FramesPerPacket, "FramesPerPacket");
Get_B4 (ChannelsPerFrame, "ChannelsPerFrame");
Get_B4 (BitsPerChannel, "BitsPerChannel");
FILLING_BEGIN();
if (SampleRate)
Fill(Stream_Audio, 0, Audio_SamplingRate, SampleRate);
CodecID_Fill(Ztring().From_CC4(FormatID), Stream_Audio, 0, InfoCodecID_Format_Mpeg4);
if (ChannelsPerFrame)
Fill(Stream_Audio, 0, Audio_Channel_s_, ChannelsPerFrame);
if (BitsPerChannel)
Fill(Stream_Audio, 0, Audio_BitDepth, BitsPerChannel);
if (BytesPerPacket && SampleRate && FramesPerPacket)
Fill(Stream_Audio, 0, Audio_BitRate, SampleRate*BytesPerPacket*8/FramesPerPacket);
FILLING_END();
}
//---------------------------------------------------------------------------
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_Aac::Read_Buffer_Continue_raw_data_block()
{
if (Frame_Count>Frame_Count_Valid)
{
Skip_XX(Element_Size, "Data");
return; //Parsing completely only the 1st frame
}
BS_Begin();
raw_data_block();
BS_End();
if (FrameIsAlwaysComplete && Element_Offset<Element_Size)
Skip_XX(Element_Size-Element_Offset, "Unknown");
FILLING_BEGIN();
//Counting
Frame_Count++;
if (Frame_Count_NotParsedIncluded!=(int64u)-1)
Frame_Count_NotParsedIncluded++;
Element_Info1(Ztring::ToZtring(Frame_Count));
//Filling
if (!Status[IsAccepted])
File__Analyze::Accept();
if (Frame_Count>=Frame_Count_Valid)
{
//No more need data
if (Mode==Mode_LATM)
File__Analyze::Accept();
File__Analyze::Finish();
}
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_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_Lagarith::Read_Buffer_Continue()
{
//Parsing
int8u version;
Get_L1 (version, "version");
Skip_XX(Element_Size-Element_Offset, "data");
FILLING_BEGIN();
Accept();
Fill();
switch (version)
{
case 0x02 :
case 0x04 : Fill(Stream_Video, 0, Video_ColorSpace, "RGB"); Fill(Stream_Video, 0, Video_BitDepth, 8); break;
case 0x03 : Fill(Stream_Video, 0, Video_ColorSpace, "YUV"); Fill(Stream_Video, 0, Video_ChromaSubsampling, "4:2:2"); Fill(Stream_Video, 0, Video_BitDepth, 8); break;
case 0x05 : Fill(Stream_Video, 0, Video_ColorSpace, "Y"); break;
case 0x06 :
case 0x07 : Fill(Stream_Video, 0, Video_ColorSpace, "RGB"); break;
case 0x08 :
case 0x09 : Fill(Stream_Video, 0, Video_ColorSpace, "RGBA"); break;
case 0x0A :
case 0x0B : Fill(Stream_Video, 0, Video_ColorSpace, "YUV"); Fill(Stream_Video, 0, Video_ChromaSubsampling, "4:2:0"); Fill(Stream_Video, 0, Video_BitDepth, 8); break;
default : ;
}
FILLING_END();
Finish();
}
//---------------------------------------------------------------------------
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();
}
//---------------------------------------------------------------------------
void File_Bmp::BitmapInfoHeader()
{
//Parsing
Element_Begin("Bitmap Info header", 40);
int32u Width, Height, CompressionMethod;
int16u BitsPerPixel;
Skip_L4( "Size");
Get_L4 (Width, "Width");
Get_L4 (Height, "Height");
Skip_L2( "Color planes");
Get_L2 (BitsPerPixel, "Bits per pixel");
Get_L4 (CompressionMethod, "Compression method"); Param_Info(Bmp_CompressionMethod(CompressionMethod));
Skip_L4( "Image size");
Skip_L4( "Horizontal resolution");
Skip_L4( "Vertical resolution");
Skip_L4( "Number of colors in the color palette");
Skip_L4( "Number of important colors used");
Element_End();
FILLING_BEGIN();
Fill(Stream_Image, 0, Image_Width, Width);
Fill(Stream_Image, 0, Image_Height, Height);
Fill(Stream_Image, 0, Image_BitDepth, BitsPerPixel);
Fill(Stream_Image, 0, Image_Format, Bmp_CompressionMethod(CompressionMethod));
Fill(Stream_Image, 0, Image_Codec, Bmp_CompressionMethod(CompressionMethod));
FILLING_END();
}
//---------------------------------------------------------------------------
void File_Cdp::Read_Buffer_Continue()
{
if (Buffer_Size==0)
return;
if (WithAppleHeader)
{
int32u Size, Magic;
Get_B4 (Size, "Size");
Get_B4 (Magic, "Magic");
FILLING_BEGIN();
if (Magic!=0x63636470)
{
Reject("CDP");
return;
}
FILLING_END();
}
//CRC
int8u CRC=0;
for (size_t Pos=WithAppleHeader?8:0; Pos<Buffer_Size; Pos++)
CRC+=Buffer[Pos];
if (CRC)
{
Skip_XX(Element_Size-Element_Offset, "Invalid data (CRC fails)");
return;
}
cdp_header();
while(Element_Offset<Element_Size)
{
int8u section_id;
Peek_L1(section_id);
switch (section_id)
{
case 0x71 :
time_code_section();
break;
case 0x72 :
ccdata_section();
break;
case 0x73 :
ccsvcinfo_section();
break;
case 0x74 :
cdp_footer();
break;
case 0xFF :
Skip_B1("Padding?");
break;
default :
if (section_id>=0x75 && section_id<=0xEF)
future_section();
else
Skip_XX(Element_Size-Element_Offset, "Unknown");
}
}
}
//---------------------------------------------------------------------------
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_Module::FileHeader_Parse()
{
//Parsing
Ztring ModuleName, SamplesName;
int32u Signature;
Get_Local(20, ModuleName, "Module name");
for (int8u Pos=0; Pos<31; Pos++)
{
Element_Begin();
Get_Local(22, SamplesName, "Sample's name"); Element_Name(SamplesName);
Skip_B2( "Sample length");
Skip_B1( "Finetune value for the sample");
Skip_B1( "Volume of the sample");
Skip_B2( "Start of sample repeat offset");
Skip_B2( "Length of sample repeat");
Element_End();
}
Skip_B1( "Number of song positions");
Skip_B1( "0x8F");
Skip_XX(128, "Pattern table");
Get_C4 (Signature, "Signature");
FILLING_BEGIN();
switch (Signature)
{
case 0x4D2E4B2E : //M.K.
case 0x4D214B21 : //M!K!
case 0x664C5434 : //FLT4
case 0x664C5438 : //FLT8
case 0x3663684E : //6CHN
case 0x3863684E : //8CHN
break;
default : Finished();
return;
}
FILLING_END()
FILLING_BEGIN();
Stream_Prepare(Stream_General);
Fill(Stream_General, 0, General_Format, "Module");
Stream_Prepare(Stream_Audio);
Finished();
FILLING_END();
}
//---------------------------------------------------------------------------
void File_DolbyE::Data_Parse()
{
//In case of scrambling
const int8u* Save_Buffer=NULL;
size_t Save_Buffer_Offset=0;
int64u Save_File_Offset=0;
if (ScrambledBitStream)
{
//We must change the buffer,
Save_Buffer=Buffer;
Save_Buffer_Offset=Buffer_Offset;
Save_File_Offset=File_Offset;
File_Offset+=Buffer_Offset;
Buffer_Offset=0;
Descrambled_Buffer=new int8u[(size_t)Element_Size];
std::memcpy(Descrambled_Buffer, Save_Buffer+Save_Buffer_Offset, (size_t)Element_Size);
Buffer=Descrambled_Buffer;
}
//Parsing
BS_Begin();
Block();
BS_End();
//In case of scrambling
if (ScrambledBitStream)
{
delete[] Buffer; Buffer=Save_Buffer;
Buffer_Offset=Save_Buffer_Offset;
File_Offset=Save_File_Offset;
}
FILLING_BEGIN();
if (!Status[IsAccepted])
{
Accept("Dolby E");
//Guard band
GuardBand_Before_Initial=GuardBand_Before;
GuardBand_After_Initial=GuardBand_After;
}
Frame_Count++;
if (Frame_Count_NotParsedIncluded!=(int64u)-1)
Frame_Count_NotParsedIncluded++;
if (Mpegv_frame_rate[FrameRate])
FrameInfo.DUR=float64_int64s(1000000000/Mpegv_frame_rate[FrameRate]);
else
FrameInfo.DUR=(int64u)-1;
if (FrameInfo.DTS!=(int64u)-1)
FrameInfo.PTS=FrameInfo.DTS+=FrameInfo.DUR;
if (Frame_Count==1)
{
Finish("Dolby E");
}
FILLING_END();
if (Frame_Count==0 && Buffer_TotalBytes>Buffer_TotalBytes_FirstSynched_Max)
Reject("Dolby E");
}
//---------------------------------------------------------------------------
// 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_Info(AvsV_aspect_ratio[aspect_ratio]);
Get_S1 ( 4, frame_rate_code, "frame_rate_code"); Param_Info(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_Info(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();
}
//---------------------------------------------------------------------------
// ALS is detected
// Format is unknown
void File_Mpeg4_AudioSpecificConfig::ALS ()
{
//Parsing
BS_End();
FILLING_BEGIN();
//Filling
Accept("AudioSpecificConfig");
Stream_Prepare(Stream_Audio);
Fill(Stream_Audio, StreamPos_Last, Audio_Format, "ALS");
Fill(Stream_Audio, StreamPos_Last, Audio_Codec, "ALS");
FILLING_END();
std::string Riff;
Riff.append((const char*)Buffer+Buffer_Offset, (size_t)(Element_Size-Element_Offset));
if (Riff.find("RIFF") && Riff.find("WAVEfmt"))
{
#if defined(MEDIAINFO_RIFF_YES)
//Creating the parser
File_Riff MI;
Open_Buffer_Init(&MI);
//Parsing
size_t Riff_Pos=Riff.find("RIFF");
Skip_XX(Riff_Pos, "Unknown");
Open_Buffer_Continue(&MI);
//Filling
Finish(&MI);
Merge(MI, StreamKind_Last, 0, StreamPos_Last);
//The RIFF header is for PCM
Clear(Stream_Audio, StreamPos_Last, Audio_ID);
Clear(Stream_Audio, StreamPos_Last, Audio_Codec_String);
Clear(Stream_Audio, StreamPos_Last, Audio_Codec_Family);
Fill(Stream_Audio, StreamPos_Last, Audio_Format, "ALS", Unlimited, true, true);
Fill(Stream_Audio, StreamPos_Last, Audio_Codec, "ALS", Unlimited, true, true);
Clear(Stream_Audio, StreamPos_Last, Audio_CodecID);
Clear(Stream_Audio, StreamPos_Last, Audio_CodecID_Hint);
Clear(Stream_Audio, StreamPos_Last, Audio_CodecID_Url);
Clear(Stream_Audio, StreamPos_Last, Audio_BitRate);
Clear(Stream_Audio, StreamPos_Last, Audio_BitRate_Mode);
Clear(Stream_Audio, StreamPos_Last, Audio_Codec_CC);
#else
Skip_XX(Element_Size-Element_Offset, "(RIFF chunck)");
#endif
}
else
Skip_XX(Element_Size-Element_Offset, "Unknown");
//No need more
Finish("AudioSpecificConfig");
}
//---------------------------------------------------------------------------
// Packet "B1"
void File_AvsV::video_sequence_end()
{
Element_Name("video_sequence_start");
FILLING_BEGIN();
//NextCode
NextCode_Clear();
NextCode_Add(0xB0); //SeqenceHeader
FILLING_END();
}
//---------------------------------------------------------------------------
void File_Skm::FileHeader_Parse()
{
Skip_C5( "Signature");
FILLING_BEGIN();
Accept("SKM");
Fill(Stream_General, 0, General_Format, "SKM");
FILLING_END();
}
//---------------------------------------------------------------------------
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_Iso9660::Read_Buffer_Continue()
{
Skip_XX(32768, "System Area");
Primary_Volume_Descriptor();
FILLING_BEGIN();
Fill(Stream_General, 0, General_Format, "ISO 9660");
Finish("ISO 9660");
FILLING_END();
}
