//---------------------------------------------------------------------------
void File_La::FileHeader_Parse()
{
//Parsing
Ztring Major, Minor;
int32u SampleRate, Samples, BytesPerSecond, UnCompSize, WAVEChunk, FmtSize, FmtChunk, CRC32;
int16u RawFormat, Channels, BytesPerSample, BitsPerSample;
Skip_Local(2, "signature");
Get_Local (1, Major, "major_version");
Get_Local (1, Minor, "minor_version");
Get_L4 (UnCompSize, "uncompressed_size");
Get_L4 (WAVEChunk, "chunk");
Skip_L4( "fmt_size");
Get_L4 (FmtChunk, "fmt_chunk");
Get_L4 (FmtSize, "fmt_size");
Get_L2 (RawFormat, "raw_format");
Get_L2 (Channels, "channels"); Param_Info2(Channels, " channel(s)");
Get_L4 (SampleRate, "sample_rate");
Get_L4 (BytesPerSecond, "bytes_per_second");
Get_L2 (BytesPerSample, "bytes_per_sample");
Get_L2 (BitsPerSample, "bits_per_sample");
Get_L4 (Samples, "samples");
Skip_L1( "flags");
Get_L4 (CRC32, "crc");
FILLING_BEGIN()
if (SampleRate==0)
return;
Duration=((int64u)Samples/Channels)*1000/SampleRate; // Seems that it's samples per channels otherwise Duration is doubled ??!!
if (Duration==0)
return;
UncompressedSize=(Samples)*Channels*(BitsPerSample/8);
if (UncompressedSize==0)
return;
File__Tags_Helper::Accept("LA");
Fill(Stream_General, 0, General_Format_Version, Major+__T('.')+Minor);
File__Tags_Helper::Stream_Prepare(Stream_Audio);
Fill(Stream_Audio, 0, Audio_Format, "LA");
Fill(Stream_Audio, 0, Audio_Codec, "LA");
Fill(Stream_Audio, 0, Audio_Format_Version, Major+__T('.')+Minor);
Fill(Stream_Audio, 0, Audio_BitDepth, BitsPerSample);
Fill(Stream_Audio, 0, Audio_Channel_s_, Channels);
Fill(Stream_Audio, 0, Audio_SamplingRate, SampleRate);
Fill(Stream_Audio, 0, Audio_Duration, Duration);
//No more need data
File__Tags_Helper::Finish("LA");
FILLING_END();
}
//---------------------------------------------------------------------------
void File_Lyrics3v2::Header_Parse()
{
if (TotalSize<=15) //First 10 is minimum size of a tag, Second 10 is ID3v2 header size
{
//Place for footer
Header_Fill_Code((int64u)-1, "File Footer");
Header_Fill_Size(TotalSize);
return;
}
//Parsing
Ztring SizeT;
int64u Size;
int32u Field;
Get_C3 (Field, "Field");
Get_Local(5, SizeT, "Size");
Size=8+SizeT.To_int64u();
//Filling
if (Size+15>TotalSize)
Size=TotalSize-15;
Header_Fill_Code(Field, Ztring().From_CC3(Field));
Header_Fill_Size(Size);
TotalSize-=Size;
}
//---------------------------------------------------------------------------
void File_Flac::PICTURE()
{
//Parsing
int32u PictureType, MimeType_Size, Description_Size, Data_Size;
Ztring MimeType, Description;
Get_B4 (PictureType, "Picture type"); Element_Info1(Id3v2_PictureType((int8u)PictureType));
Get_B4 (MimeType_Size, "MIME type size");
Get_Local(MimeType_Size, MimeType, "MIME type");
Get_B4 (Description_Size, "Description size");
Get_UTF8(Description_Size, Description, "Description");
Skip_B4( "Width");
Skip_B4( "Height");
Skip_B4( "Color depth");
Skip_B4( "Number of colors used");
Get_B4 (Data_Size, "Data size");
if (Element_Offset+Data_Size>Element_Size)
return; //There is a problem
std::string Data_Raw((const char*)(Buffer+(size_t)(Buffer_Offset+Element_Offset)), Data_Size);
std::string Data_Base64(Base64::encode(Data_Raw));
Skip_XX(Element_Size-Element_Offset, "Data");
//Filling
Fill(Stream_General, 0, General_Cover, "Yes");
Fill(Stream_General, 0, General_Cover_Description, Description);
Fill(Stream_General, 0, General_Cover_Type, Id3v2_PictureType((int8u)PictureType));
Fill(Stream_General, 0, General_Cover_Mime, MimeType);
Fill(Stream_General, 0, General_Cover_Data, Data_Base64);
}
//---------------------------------------------------------------------------
void File_Celt::Comment()
{
Element_Name("Comment?");
while (Element_Offset<Element_Size)
{
Ztring value;
int32u size;
Get_L4(size, "size");
if (size)
Get_Local(size, value, "value");
//Filling
if (value.find(__T("CELT "))!=std::string::npos)
{
Ztring Version=value.SubString(__T("CELT "), __T(" ("));
Fill(Stream_Audio, 0, Audio_Encoded_Library, __T("CELT ")+Version);
Fill(Stream_Audio, 0, Audio_Encoded_Library_Name, __T("CELT"));
Fill(Stream_Audio, 0, Audio_Encoded_Library_Version, Version);
}
else if (!value.empty())
Fill(Stream_Audio, 0, "Comment", value);
}
Finish("CELT");
}
//---------------------------------------------------------------------------
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_Lyrics3v2::EAR()
{
//Parsing
Ztring Value;
Get_Local(Element_Size, Value, "Value");
//Filling
Fill(Stream_General, 0, General_Performer, Value);
}
//---------------------------------------------------------------------------
void File_Lyrics3v2::INF()
{
//Parsing
Ztring Value;
Get_Local(Element_Size, Value, "Value");
//Filling
Fill(Stream_General, 0, General_Comment, Value);
}
//---------------------------------------------------------------------------
void File_TwinVQ::_____char(const char* Parameter)
{
//Parsing
Ztring Value;
Get_Local(Element_Size, Value, "Value");
//Filling
Fill(Stream_General, 0, Parameter, Value);
}
//---------------------------------------------------------------------------
void File_ExtendedModule::Read_Buffer_Continue()
{
//Parsing
Ztring ModuleName, TrackerName;
int32u HeaderSize;
int16u Length, Channels, Patterns, Instruments, Flags, Tempo, BPM;
int8u VersionMinor, VersionMajor;
Skip_String(17, "Signature");
Get_Local(20, ModuleName, "Module name");
Skip_L1( "0x1A");
Get_Local(20, TrackerName, "Tracker name");
Get_L1 (VersionMinor, "Version (minor)");
Get_L1 (VersionMajor, "Version (major)");
Get_L4 (HeaderSize, "Header size");
Get_L2 (Length, "Song Length");
Skip_L2( "Restart position");
Get_L2 (Channels, "Number of channels");
Get_L2 (Patterns, "Number of patterns");
Get_L2 (Instruments, "Number of instruments");
Get_L2 (Flags, "Flags");
Get_L2 (Tempo, "Tempo");
Get_L2 (BPM, "BPM");
Skip_XX(256, "Pattern order table");
FILLING_BEGIN();
Accept("Extended Module");
Fill(Stream_General, 0, General_Format, "Extended Module");
Fill(Stream_General, 0, General_Format_Version, Ztring::ToZtring(VersionMajor)+__T(".")+Ztring::ToZtring(VersionMinor/10)+Ztring::ToZtring(VersionMinor%10));
Fill(Stream_General, 0, General_Track, ModuleName.Trim(__T(' ')));
Fill(Stream_General, 0, General_Encoded_Application, TrackerName.Trim(__T(' ')));
Fill(Stream_General, 0, "Tempo", Tempo);
Fill(Stream_General, 0, "BPM", BPM);
Stream_Prepare(Stream_Audio);
Fill(Stream_Audio, 0, "Sampler, Channels", Channels);
Fill(Stream_Audio, 0, "Sampler, Patterns", Patterns);
Fill(Stream_Audio, 0, "Sampler, Instruments", Instruments);
//No more need data
Finish("Extended Module");
FILLING_END();
}
//---------------------------------------------------------------------------
void File_Exr::comments ()
{
//Parsing
Ztring value;
Get_Local(Element_Size, value, "value");
//Filling
if (Frame_Count==1)
Fill(StreamKind_Last, 0, General_Comment, value);
}
//---------------------------------------------------------------------------
void File_Lyrics3v2::ETT()
{
Element_Info("Extended Track Title");
//Parsing
Ztring Value;
Get_Local(Element_Size, Value, "Value");
//Filling
Fill(Stream_General, 0, General_Title, Value);
}
//---------------------------------------------------------------------------
void File_Tar::Read_Buffer_Continue()
{
if (File_Size<257)
{
Reject();
return;
}
if (Buffer_Size<257)
return; //Wait for more data
//Parsing
Ztring ChecksumO;
Skip_Local(100, "File name");
Skip_Local( 8, "File mode");
Skip_Local( 8, "Owner's numeric user ID");
Skip_Local( 12, "Group's numeric user ID");
Skip_Local( 12, "File size in bytes");
Skip_Local( 8, "Last modification time in numeric Unix time format");
Get_Local ( 8, ChecksumO, "Checksum for header block");
Skip_B1( "Link indicator (file type)");
Skip_Local(100, "Name of linked file");
Skip_XX(File_Size-257, "Data");
FILLING_BEGIN();
//Handling Checksum
int32u Checksum=ChecksumO.To_int32u(8);
int32u ChecksumU=0;
int32u ChecksumS=0;
for (size_t Pos=0; Pos<257; Pos++)
{
if (Pos==148)
{
ChecksumU+=32*8; //8 spaces
ChecksumS+=32*8; //8 spaces
Pos+=7; //Skiping Checksum
}
ChecksumU+=(int8u)Buffer[Pos];
ChecksumS+=(int8s)Buffer[Pos];
}
if (ChecksumU!=Checksum && ChecksumS!=Checksum)
{
Reject("Tar");
return;
}
//Filling
Accept("Tar");
Fill(Stream_General, 0, General_Format, "Tar");
Reject("Tar");
FILLING_END();
}
//---------------------------------------------------------------------------
void File_Lyrics3v2::INF()
{
Element_Info("Additional information");
//Parsing
Ztring Value;
Get_Local(Element_Size, Value, "Value");
//Filling
Fill(Stream_General, 0, General_Comment, Value);
}
//---------------------------------------------------------------------------
void File_Lyrics3v2::EAL()
{
Element_Info("Extended Album name");
//Parsing
Ztring Value;
Get_Local(Element_Size, Value, "Value");
//Filling
Fill(Stream_General, 0, General_Album, Value);
}
//---------------------------------------------------------------------------
void File_Cdp::ccsvcinfo_section()
{
//Parsing
int8u svc_count;
Element_Begin1("ccsvcinfo_section");
Skip_B1( "ccsvcinfo_id");
BS_Begin();
Skip_SB( "reserved");
Skip_SB( "svc_info_start");
Skip_SB( "svc_info_change");
Skip_SB( "svc_info_complete");
Get_S1 (4, svc_count, "svc_count");
BS_End();
for (int8u Pos=0; Pos<svc_count; Pos++)
{
Element_Begin1("svc");
bool csn_size;
BS_Begin();
Skip_SB( "reserved");
Get_SB ( csn_size, "csn_size");
if (csn_size)
{
Skip_SB( "reserved");
Skip_S1(5, "caption_service_number");
}
else
Skip_S1(6, "caption_service_number");
BS_End();
//svc_data_byte - caption_service_descriptor
Element_Begin1("service");
Ztring language;
bool digital_cc;
Get_Local(3, language, "language");
BS_Begin();
Get_SB (digital_cc, "digital_cc");
Skip_SB( "reserved");
if (digital_cc) //line21
{
Skip_S1(5, "reserved");
Skip_SB( "line21_field");
}
else
Skip_S1(6, "caption_service_number");
Skip_SB( "easy_reader");
Skip_SB( "wide_aspect_ratio");
Skip_S2(14, "reserved");
BS_End();
Element_End0();
Element_End0();
}
Element_End0();
}
//---------------------------------------------------------------------------
void File_Speex::Identification()
{
Element_Name("Identification");
//Parsing
Ztring speex_version;
int32u Speex_version_id, header_size, rate, nb_channels, bitrate, vbr;
Skip_Local(8, "speex_string");
Get_Local(20, speex_version, "speex_version");
Get_L4 (Speex_version_id, "Speex_version_id");
if (Speex_version_id==1)
{
Get_L4 (header_size, "header_size");
Get_L4 (rate, "rate");
Skip_L4( "mode");
Skip_L4( "mode_bitstream_version");
Get_L4 (nb_channels, "nb_channels");
Get_L4 (bitrate, "bitrate");
Skip_L4( "frame_size");
Get_L4 (vbr, "vbr");
Skip_L4( "frames_per_packet");
Skip_L4( "extra_headers");
Skip_L4( "reserved1");
Skip_L4( "reserved2");
if (header_size<Element_Size)
Skip_XX(Element_Size-header_size, "Unknown");
//Filling
FILLING_BEGIN()
Accept("Speex");
Stream_Prepare(Stream_Audio);
Fill(Stream_Audio, 0, Audio_Format, "Speex");
Fill(Stream_Audio, 0, Audio_Codec, "Speex");
if (Speex_version_id==1)
{
if (!speex_version.empty())
Fill(Stream_Audio, 0, Audio_Encoded_Library, speex_version);
Fill(Stream_Audio, 0, Audio_SamplingRate, rate);
Fill(Stream_Audio, 0, Audio_Channel_s_, nb_channels);
if (bitrate!=(int32u)-1)
Fill(Stream_Audio, 0, Audio_BitRate, bitrate);
Fill(Stream_Audio, 0, Audio_BitRate_Mode, vbr?"VBR":"CBR");
}
FILLING_END();
}
//Filling
Identification_Done=true;
}
//---------------------------------------------------------------------------
void File_Rkau::FileHeader_Parse()
{
//Parsing
Ztring version;
int32u SampleRate, source_bytes;
int8u Channels, BitsPerSample, Quality, Flags;
bool joint_stereo, streaming, vrq_lossy_mode;
Skip_Local(3, "Signature");
Get_Local (1, version, "Version");
Get_L4 (source_bytes, "SourceBytes");
Get_L4 (SampleRate, "SampleRate");
Get_L1 (Channels, "Channels");
Get_L1 (BitsPerSample, "BitsPerSample");
Get_L1 (Quality, "Quality");
Get_L1 (Flags, "Flags");
Get_Flags (Flags, 0, joint_stereo, "JointStereo");
Get_Flags (Flags, 1, streaming, "Streaming");
Get_Flags (Flags, 2, vrq_lossy_mode, "VRQLossyMode");
FILLING_BEGIN();
if (SampleRate==0)
return;
Duration=(((int64u)source_bytes*1000)/4)/SampleRate;
if (Duration==0)
return;
UncompressedSize=Channels*(BitsPerSample/8);
if (UncompressedSize==0)
return;
//Filling data
File__Tags_Helper::Accept("RKAU");
File__Tags_Helper::Stream_Prepare(Stream_Audio);
Fill(Stream_Audio, 0, Audio_Format, "RK Audio");
Fill(Stream_Audio, 0, Audio_Codec, "Rkau");
Fill(Stream_Audio, 0, Audio_Encoded_Library, __T("1.0") + version);
Fill(Stream_Audio, 0, Audio_Compression_Mode, (Quality==0)?"Lossless":"Lossy");
Fill(Stream_Audio, 0, Audio_BitDepth, BitsPerSample);
Fill(Stream_Audio, 0, Audio_Channel_s_, Channels);
Fill(Stream_Audio, 0, Audio_SamplingRate, SampleRate);
Fill(Stream_Audio, 0, Audio_Duration, Duration);
FILLING_END();
//No more needed data
File__Tags_Helper::Finish("RKAU");
}
//---------------------------------------------------------------------------
void File_Speex::Comment()
{
Element_Name("Comment?");
while (Element_Offset<Element_Size)
{
Ztring value;
int32u size;
Get_L4(size, "size");
if (size)
Get_Local(size, value, "value");
//Filling
if (!value.empty())
Fill(Stream_Audio, 0, "Comment", value);
}
Finish("Speex");
}
//---------------------------------------------------------------------------
// Packet "B2", User defined size, this is often used of library name
void File_AvsV::user_data_start()
{
Element_Name("user_data_start");
//Rejecting junk from the end
size_t Library_End_Offset=(size_t)Element_Size;
while (Library_End_Offset>0
&& (Buffer[Buffer_Offset+Library_End_Offset-1]<0x20
|| Buffer[Buffer_Offset+Library_End_Offset-1]>0x7D
|| (Buffer[Buffer_Offset+Library_End_Offset-1]>=0x3A
&& Buffer[Buffer_Offset+Library_End_Offset-1]<=0x40)))
Library_End_Offset--;
if (Library_End_Offset==0)
return; //No good info
//Accepting good data after junk
size_t Library_Start_Offset=Library_End_Offset-1;
while (Library_Start_Offset>0 && (Buffer[Buffer_Offset+Library_Start_Offset-1]>=0x20 && Buffer[Buffer_Offset+Library_Start_Offset-1]<=0x7D))
Library_Start_Offset--;
//But don't accept non-alpha caracters at the beginning (except for "3ivx")
if (Library_End_Offset-Library_Start_Offset!=4 || CC4(Buffer+Buffer_Offset+Library_Start_Offset)!=0x33697678) //3ivx
while (Library_Start_Offset<Element_Size && Buffer[Buffer_Offset+Library_Start_Offset]<=0x40)
Library_Start_Offset++;
//Parsing
Ztring Temp;
if (Library_Start_Offset>0)
Skip_XX(Library_Start_Offset, "junk");
if (Library_End_Offset-Library_Start_Offset)
Get_Local(Library_End_Offset-Library_Start_Offset, Temp,"data");
if (Element_Offset<Element_Size)
Skip_XX(Element_Size-Element_Offset, "junk");
FILLING_BEGIN();
//NextCode
NextCode_Test();
if (Temp.size()>=4)
Library=Temp;
FILLING_END();
}
//---------------------------------------------------------------------------
void File_Lyrics3v2::Header_Parse()
{
if (Buffer_Offset+15>=Buffer_Size) //first 10 is minimum size of a tag, Second 10 is ID3v2 header size
{
//Place for footer
Header_Fill_Code(0xFFFFFFFF, "Footer");
Header_Fill_Size(Buffer_Size-Buffer_Offset);
return;
}
//Parsing
Ztring Size;
int32u Field;
Get_C3 (Field, "Field");
Get_Local(5, Size, "Size");
//Filling
Header_Fill_Code(Field, Ztring().From_CC3(Field));
Header_Fill_Size(8+Size.To_int64u());
}
//---------------------------------------------------------------------------
void File_Ibi::Ebml_DocType()
{
Element_Name("DocType");
//Parsing
Ztring Data;
Get_Local(Element_Size, Data, "Data"); Element_Info1(Data);
//Filling
FILLING_BEGIN();
if (Data==__T("MediaInfo Index"))
Accept("Ibi");
else
{
Reject("Ibi");
return;
}
FILLING_END();
}
//---------------------------------------------------------------------------
void File_Celt::Identification()
{
Element_Name("Identification");
//Parsing
Ztring celt_version;
int32u Celt_version_id, sample_rate, nb_channels;
Skip_Local(8, "celt_codec_id");
Get_Local(20, celt_version, "celt_version");
Get_L4 (Celt_version_id, "celt_version_id");
Skip_L4( "header_size");
Get_L4 (sample_rate, "rate");
Get_L4 (nb_channels, "nb_channels");
Skip_L4( "frame_size");
Skip_L4( "overlap");
Skip_L4( "bytes_per_packet");
Skip_L4( "extra_headers");
//Filling
FILLING_BEGIN()
Accept("CELT");
Stream_Prepare(Stream_Audio);
Fill(Stream_Audio, 0, Audio_Format, "CELT");
Fill(Stream_Audio, 0, Audio_Codec, "CELT");
if (!celt_version.empty())
{
//Fill(Stream_Audio, 0, Audio_Encoded_Library, celt_version); //Need more info about hte different possibilities, in the meanwhile trusting more the comment part
Fill(Stream_Audio, 0, Audio_SamplingRate, sample_rate);
Fill(Stream_Audio, 0, Audio_Channel_s_, nb_channels);
}
FILLING_END();
//Filling
Identification_Done=true;
}
//---------------------------------------------------------------------------
void File_Tga::Image_Color_Map_Data()
{
Element_Begin1("Image/Color Map Data");
Get_Local(ID_Length, Image_ID, "Image ID");
if (Color_Map_Type==1)
{
int64u EntrySizeInBits=8;
if (Color_map_Entry_Size<24)
EntrySizeInBits=Color_map_Entry_Size/3;
Skip_XX(Color_map_Length*EntrySizeInBits/8, "Color Map Data");
}
if (Element_Offset+26<Element_Size
&& Buffer[Buffer_Size- 18]==0x54
&& Buffer[Buffer_Size- 17]==0x52
&& Buffer[Buffer_Size- 16]==0x55
&& Buffer[Buffer_Size- 15]==0x45
&& Buffer[Buffer_Size- 14]==0x56
&& Buffer[Buffer_Size- 13]==0x49
&& Buffer[Buffer_Size- 12]==0x53
&& Buffer[Buffer_Size- 11]==0x49
&& Buffer[Buffer_Size- 10]==0x4F
&& Buffer[Buffer_Size- 9]==0x4E
&& Buffer[Buffer_Size- 8]==0x2D
&& Buffer[Buffer_Size- 7]==0x58
&& Buffer[Buffer_Size- 6]==0x46
&& Buffer[Buffer_Size- 5]==0x49
&& Buffer[Buffer_Size- 4]==0x4C
&& Buffer[Buffer_Size- 3]==0x45
&& Buffer[Buffer_Size- 2]==0x2E
&& Buffer[Buffer_Size- 1]==0x00)
Version=2;
else
Version=1;
Skip_XX(Element_Size-Element_Offset-(Version==2?26:0), "Image Data");
Element_End0();
}
//---------------------------------------------------------------------------
void File_Au::FileHeader_Parse()
{
//Parsing
Ztring arbitrary;
int32u data_start, data_size, sample_format, sample_rate, channels;
Skip_B4( "Magic");
Get_B4 (data_start, "data_start");
Get_B4 (data_size, "data_size");
Get_B4 (sample_format, "sample_format");
Get_B4 (sample_rate, "sample_rate");
Get_B4 (channels, "channels");
if (data_start>24)
Get_Local(data_start-24, arbitrary, "arbitrary data");
FILLING_BEGIN();
Accept("AU");
Fill(Stream_General, 0, General_Format, "AU");
Stream_Prepare(Stream_Audio);
Fill(Stream_Audio, 0, Audio_Format, Au_Format(sample_format));
Fill(Stream_Audio, 0, Audio_CodecID, Au_sample_format(sample_format));
Fill(Stream_Audio, 0, Audio_Codec, Au_sample_format(sample_format));
Fill(Stream_Audio, 0, Audio_Channel_s_, channels);
Fill(Stream_Audio, 0, Audio_SamplingRate, sample_rate);
if (File_Size!=(int64u)-1)
data_size=(int32u)File_Size-data_start; //Priority for File size
if (sample_rate && data_size!=0 && data_size!=0xFFFFFFFF)
Fill(Stream_Audio, 0, Audio_Duration, ((int64u)data_size)*1000/sample_rate);
Fill(Stream_Audio, 0, Audio_StreamSize, File_Size-Element_Offset);
Fill(Stream_Audio, 0, Audio_BitRate_Mode, "CBR");
Fill(Stream_General, 0, General_Comment, arbitrary);
//No more need data
Finish("AU");
FILLING_END();
}
//---------------------------------------------------------------------------
void File_Gif::Read_Buffer_Continue()
{
//Parsing
Ztring Version;
int16u Width, Height;
int8u BackgroundColorIndex, PixelAspectRatio, Resolution, GCT_Size;
bool GCT_Flag, Sort;
Skip_Local(3, "Header");
Get_Local (3, Version, "Version");
Get_L2 (Width, "Logical Screen Width");
Get_L2 (Height, "Logical Screen Height");
BS_Begin();
Get_SB ( GCT_Flag, "Global Color Table Flag");
Get_S1 (3, Resolution, "Color Resolution");
Get_SB ( Sort, "Sort Flag to Global Color Table");
Get_S1 (3, GCT_Size, "Size of Global Color Table"); Param_Info(Ztring::ToZtring((int16u)pow(2.0, 1+GCT_Size)));
BS_End();
Get_L1 (BackgroundColorIndex, "Background Color Index");
Get_L1 (PixelAspectRatio, "Pixel Aspect Ratio");
if (GCT_Flag)
Skip_XX((int16u)pow(2.0, 1+GCT_Size)*3, "Global Color Table");
Element_End();
FILLING_BEGIN();
Accept("GIF");
Stream_Prepare(Stream_Image);
Fill(Stream_Image, 0, Image_Width, Width);
Fill(Stream_Image, 0, Image_Height, Height);
Fill(Stream_Image, 0, Image_Format, _T("GIF"));
Fill(Stream_Image, 0, Image_Format_Profile, Version);
Fill(Stream_Image, 0, Image_Codec, _T("GIF")+Version);
Finish("GIF");
FILLING_END();
}
//---------------------------------------------------------------------------
void File_Id3::Read_Buffer_Continue()
{
//Buffer size
if (Buffer_Size<128)
return;
int32u Magic;
Peek_B4(Magic);
Ztring TitleAddition;
Ztring ArtistAddition;
Ztring AlbumAddition;
Ztring GenreAddition;
if (Magic==0x5441472B)
{
if (Buffer_Size<227+128)
return;
Skip_C4 ( "ID");
Get_Local (60, TitleAddition, "Title");
Get_Local (60, ArtistAddition, "Artist");
Get_Local (60, AlbumAddition, "Album");
Skip_B1 ( "Speed");
Get_Local (30, GenreAddition, "Genre");
Skip_Local(6, "Start time"); //mmm:ss
Skip_Local(6, "End time"); //mmm:ss
TitleAddition.TrimRight();
ArtistAddition.TrimRight();
AlbumAddition.TrimRight();
GenreAddition.TrimRight();
}
//Parsing
Ztring Title, Artist, Album, Year, Comment;
int8u Track=0, Genre;
Skip_C3 ( "ID");
Get_Local (30, Title, "Title");
Get_Local (30, Artist, "Artist");
Get_Local (30, Album, "Album");
Get_Local ( 4, Year, "Year");
Get_Local (30, Comment, "Comment");
if (Comment.size()<29) //Id3v1.1 specifications : Track number addition
{
Element_Offset-=2;
int8u Zero;
Peek_B1(Zero);
if (Zero==0)
{
Skip_B1( "Zero");
Get_B1 (Track, "Track");
}
else
Element_Offset+=2;
}
Get_B1 (Genre, "Genre");
FILLING_BEGIN();
if (TitleAddition.empty())
Title.TrimRight();
if (ArtistAddition.empty())
Artist.TrimRight();
if (AlbumAddition.empty())
Album.TrimRight();
Year.TrimRight();
Comment.TrimRight();
Accept("Id3");
Stream_Prepare(Stream_General);
Fill(Stream_General, 0, General_Album, Album+AlbumAddition);
Fill(Stream_General, 0, General_Track, Title+TitleAddition);
Fill(Stream_General, 0, General_Performer, Artist+ArtistAddition);
Fill(Stream_General, 0, General_Comment, Comment);
Fill(Stream_General, 0, General_Recorded_Date, Year);
if (GenreAddition.empty())
Fill(Stream_General, 0, General_Genre, GenreAddition);
if (Genre && Genre!=(int8u)-1)
Fill(Stream_General, 0, General_Genre, Genre);
if (Track)
Fill(Stream_General, 0, General_Track_Position, Track);
Finish("Id3");
FILLING_END();
}
//---------------------------------------------------------------------------
void File_Y4m::FileHeader_Parse()
{
//Parsing
Ztring Header;
Get_Local(HeaderEnd, Header, "Data");
ZtringList List; List.Separator_Set(0, " ");
List.Write(Header);
int64u Width=0, Height=0, Multiplier=0, Divisor=1;
float64 FrameRate=0;
for (size_t Pos=1; Pos<List.size(); Pos++)
{
if (!List[Pos].empty())
{
switch (List[Pos][0])
{
case 'A' : //Pixel aspect ratio
{
ZtringList Value; Value.Separator_Set(0, ":");
Value.Write(List[Pos].substr(1));
if (Value.size()==2)
{
float64 x=Value[0].To_float64();
float64 y=Value[1].To_float64();
if (x && y)
Fill(Stream_Video, 0, Video_PixelAspectRatio, x/y, 3);
}
}
break;
case 'C' : //Color space
if (List[Pos]==__T("C420jpeg") || List[Pos]==__T("C420paldv") || List[Pos]==__T("C420"))
{
Fill(Stream_Video, 0, Video_ChromaSubsampling, "4:2:0");
Multiplier=3;
Divisor=2;
}
if (List[Pos]==__T("C422"))
{
Fill(Stream_Video, 0, Video_ChromaSubsampling, "4:2:2");
Multiplier=2;
}
if (List[Pos]==__T("C444"))
{
Fill(Stream_Video, 0, Video_ChromaSubsampling, "4:4:4");
Multiplier=3;
}
break;
case 'F' : //Frame rate
{
ZtringList Value; Value.Separator_Set(0, ":");
Value.Write(List[Pos].substr(1));
if (Value.size()==2)
{
float64 N=Value[0].To_float64();
float64 D=Value[1].To_float64();
if (N && D)
{
FrameRate=N/D;
Fill(Stream_Video, 0, Video_FrameRate, FrameRate, 3);
}
}
}
break;
case 'H' : //Height
{
Ztring Value=List[Pos].substr(1);
Height=Value.To_int64u();
Fill(Stream_Video, 0, Video_Height, Height); break;
}
break;
case 'I' : //Interlacing
if (List[Pos].size()==2)
switch (List[Pos][1])
{
case 'p' : Fill(Stream_Video, 0, Video_ScanType, "Progressive"); break;
case 't' : Fill(Stream_Video, 0, Video_ScanType, "Progressive"); Fill(Stream_Video, 0, Video_ScanOrder, "TFF"); break;
case 'b' : Fill(Stream_Video, 0, Video_ScanType, "Progressive"); Fill(Stream_Video, 0, Video_ScanOrder, "BFF"); break;
case 'm' : Fill(Stream_Video, 0, Video_ScanType, "Mixed"); break;
default : ;
}
break;
case 'W' : //Width
{
Ztring Value=List[Pos].substr(1);
Width=Value.To_int64u();
Fill(Stream_Video, 0, Video_Width, Width); break;
}
break;
default : ;
}
}
}
//Duration (we expect no meta per frame)
if (Width && Height && Multiplier)
{
int64u Frame_ByteSize=6+Width*Height*Multiplier/Divisor; //5 for "FRAME\0"
Fill(Stream_Video, 0, Video_FrameCount, File_Size/Frame_ByteSize);
if (FrameRate)
Fill(Stream_Video, 0, Video_BitRate, Width*Height*Multiplier/Divisor*8*FrameRate);
}
Finish();
}
//---------------------------------------------------------------------------
void File_ImpulseTracker::Read_Buffer_Continue()
{
//Parsing
Ztring SongName;
int16u OrdNum, InsNum, SmpNum, PatNum, Flags, Special;
int8u VersionMajor, VersionMinor, SoftwareVersionMajor, SoftwareVersionMinor, IS, TS;
bool Stereo;
Skip_B4( "Signature");
Get_Local(26, SongName, "Song name");
Skip_L1( "Unknown");
Skip_L1( "Unknown");
Get_L2 (OrdNum, "Orders count");
Get_L2 (InsNum, "Instruments count");
Get_L2 (SmpNum, "Samples count");
Get_L2 (PatNum, "Paterns count");
Get_L1 (SoftwareVersionMinor, "Cwt/v (Minor)");
Get_L1 (SoftwareVersionMajor, "Cwt/v (Major)");
Get_L1 (VersionMinor, "Cwt (Minor)");
Get_L1 (VersionMajor, "Cwt (Major)");
Get_L2 (Flags, "Flags");
Get_Flags (Flags, 0, Stereo, "Stereo");
Skip_Flags(Flags, 1, "Vol0MixOptimizations");
Skip_Flags(Flags, 2, "Use instruments/Samples");
Skip_Flags(Flags, 3, "Linear/Amiga slides");
Skip_Flags(Flags, 4, "Old/IT Effects");
Get_L2 (Special, "Special");
Skip_Flags(Special, 0, "Song Message attached");
Skip_L1( "Global volume");
Skip_L1( "Mix volume");
Get_L1 (IS, "Initial Speed");
Get_L1 (TS, "Initial Temp");
Skip_L1( "Panning separation between channels");
Skip_L1( "0");
Skip_L2( "Message Length");
Skip_L4( "Message Offset");
Skip_L1( "Unknown");
Skip_L1( "Unknown");
Skip_L1( "Unknown");
Skip_L1( "Unknown");
Skip_L1( "Unknown");
Skip_XX(64, "Chnl Pan");
Skip_XX(64, "Chnl Vol");
Skip_XX(OrdNum, "Orders");
Skip_XX(InsNum*4, "Instruments");
Skip_XX(SmpNum*4, "Samples");
Skip_XX(PatNum*4, "Patterns");
FILLING_BEGIN();
Stream_Prepare(Stream_General);
Fill(Stream_General, 0, General_Format, "Impulse Tracker");
Fill(Stream_General, 0, General_Format_Version, Ztring(_T("Version "))+Ztring::ToZtring(VersionMajor)+_T(".")+Ztring::ToZtring(VersionMinor/16)+Ztring::ToZtring(VersionMinor%16));
Fill(Stream_General, 0, General_Track, SongName);
Fill(Stream_General, 0, General_Encoded_Application, Ztring(_T("Impulse Tracker ")+Ztring::ToZtring(SoftwareVersionMajor)+_T(".")+Ztring::ToZtring(SoftwareVersionMinor/16)+Ztring::ToZtring(SoftwareVersionMinor%16)));
Fill(Stream_General, 0, "BPM", TS);
Stream_Prepare(Stream_Audio);
Fill(Stream_Audio, StreamPos_Last, Audio_Channel_s_, Stereo?2:1);
Accept("Impulse Tracker");
Finish("Impulse Tracker");
FILLING_END();
}
//---------------------------------------------------------------------------
void File_Adif::FileHeader_Parse()
{
//Parsing
Ztring comment_field_data;
int32u bitrate;
int8u num_program_config_elements;
int8u object_type=(int8u)-1;
int8u sampling_frequency_index=(int8u)-1;
int8u num_front_channel_elements=(int8u)-1;
int8u num_side_channel_elements=(int8u)-1;
int8u num_back_channel_elements=(int8u)-1;
int8u num_lfe_channel_elements=(int8u)-1;
int8u num_assoc_data_elements;
int8u num_valid_cc_elements;
bool bitstream_type;
Skip_C4( "adif_id");
BS_Begin();
TEST_SB_SKIP( "copyright_id_present");
Skip_S4(32, "copyright_id");
Skip_S4(32, "copyright_id");
Skip_S4( 8, "copyright_id");
TEST_SB_END();
Skip_SB( "original_copy");
Skip_SB( "home");
Get_SB ( bitstream_type, "bitstream_type"); Param_Info(bitstream_type?"VBR":"CBR");
Get_S3 (23, bitrate, "bitrate");
Get_S1 ( 4, num_program_config_elements, "num_program_config_elements");
if (!bitstream_type)
Skip_S3(20, "adif_buffer_fullness");
for (int8u Pos=0; Pos<num_program_config_elements+1; Pos++)
{
Element_Begin("program_config_element");
int8u comment_field_bytes;
Skip_S1(4, "element_instance_tag");
Get_S1 (2, object_type, "object_type"); Param_Info(ADIF_object_type[object_type]);
Get_S1 (4, sampling_frequency_index, "sampling_frequency_index"); Param_Info(ADIF_sampling_frequency[sampling_frequency_index]);
Get_S1 (4, num_front_channel_elements, "num_front_channel_elements");
Get_S1 (4, num_side_channel_elements, "num_side_channel_elements");
Get_S1 (4, num_back_channel_elements, "num_back_channel_elements");
Get_S1 (2, num_lfe_channel_elements, "num_lfe_channel_elements");
Get_S1 (3, num_assoc_data_elements, "num_assoc_data_elements");
Get_S1 (4, num_valid_cc_elements, "num_valid_cc_elements");
TEST_SB_SKIP( "mono_mixdown_present");
Skip_S1(4, "mono_mixdown_element_number");
TEST_SB_END();
TEST_SB_SKIP( "stereo_mixdown_present");
Skip_S1(4, "stereo_mixdown_element_number");
TEST_SB_END();
TEST_SB_SKIP( "matrix_mixdown_idx_present");
Skip_S1(2, "matrix_mixdown_idx");
Skip_S1(2, "pseudo_surround_enable");
TEST_SB_END();
for (int8u Pos2=0; Pos2<num_front_channel_elements; Pos2++)
{
Element_Begin("front_channel_element");
Skip_SB( "front_element_is_cpe");
Skip_S1(4, "front_element_tag_select");
Element_End();
}
for (int8u Pos2=0; Pos2<num_side_channel_elements; Pos2++)
{
Element_Begin("side_channel_element");
Skip_SB( "back_element_is_cpe");
Skip_S1(4, "back_element_tag_select");
Element_End();
}
for (int8u Pos2=0; Pos2<num_back_channel_elements; Pos2++)
{
Element_Begin("back_channel_element");
Skip_SB( "back_element_is_cpe");
Skip_S1(4, "back_element_tag_select");
Element_End();
}
for (int8u Pos2=0; Pos2<num_lfe_channel_elements; Pos2++)
{
Element_Begin("lfe_channel_element");
Skip_S1(4, "lfe_element_tag_select");
Element_End();
}
for (int8u Pos2=0; Pos2<num_assoc_data_elements; Pos2++)
{
Element_Begin("assoc_data_element");
Skip_S1(4, "assoc_data_element_tag_select");
Element_End();
}
for (int8u Pos2=0; Pos2<num_valid_cc_elements; Pos2++)
{
Element_Begin("valid_cc_element");
Skip_SB( "cc_element_is_ind_sw");
Skip_S1(4, "valid_cc_element_tag_select");
Element_End();
}
BS_End();
Get_B1 (comment_field_bytes, "comment_field_bytes");
if (comment_field_bytes>0)
Get_Local(comment_field_bytes, comment_field_data, "comment_field_data");
BS_Begin();
Element_End();
//We only support 1 element in ADIF
Pos=num_program_config_elements;
}
BS_End();
FILLING_BEGIN();
File__Tags_Helper::Stream_Prepare(Stream_General);
Fill(Stream_General, 0, General_Format, "ADIF");
Fill(Stream_General, 0, General_Comment, comment_field_data);
File__Tags_Helper::Stream_Prepare(Stream_Audio);
Fill (Stream_Audio, 0, Audio_Format, "AAC");
Fill (Stream_Audio, 0, Audio_Format_Version, "Version 2");
if (object_type!=(int8u)-1)
Fill (Stream_Audio, 0, Audio_Format_Profile, ADIF_Format_Profile[object_type]);
Fill (Stream_Audio, 0, Audio_Codec, ADIF_object_type[object_type]);
Fill(Stream_Audio, 0, Audio_BitRate_Mode, bitstream_type?"VBR":"CBR");
if (bitrate>0)
Fill(Stream_Audio, 0, bitstream_type?Audio_BitRate_Maximum:Audio_BitRate, bitrate);
if (sampling_frequency_index!=(int8u)-1)
Fill(Stream_Audio, 0, Audio_SamplingRate, ADIF_sampling_frequency[sampling_frequency_index]);
if (num_front_channel_elements!=(int8u)-1)
Fill(Stream_Audio, 0, Audio_Channel_s_, num_front_channel_elements+num_side_channel_elements+num_back_channel_elements+num_lfe_channel_elements);
Fill(Stream_Audio, 0, Audio_Resolution, 16);
Fill(Stream_Audio, 0, Audio_MuxingMode, "ADIF");
//No more need data
File__Tags_Helper::Accept("ADIF");
File__Tags_Helper::Finish("ADIF");
FILLING_END();
}
//---------------------------------------------------------------------------
void File_ScreamTracker3::Read_Buffer_Continue()
{
//Parsing
Ztring SongName;
int16u OrdNum, InsNum, PatNum, Flags, Special;
int8u SoftwareVersionMajor, SoftwareVersionMinor, IS, TS;
Get_Local(28, SongName, "Song name");
Skip_L1( "0x1A");
Skip_L1( "Type");
Skip_L1( "Unknown");
Skip_L1( "Unknown");
Get_L2 (OrdNum, "Orders count");
Get_L2 (InsNum, "Instruments count");
Get_L2 (PatNum, "Paterns count");
Get_L2 (Flags, "Flags");
Skip_Flags(Flags, 0, "st2vibrato");
Skip_Flags(Flags, 1, "st2tempo");
Skip_Flags(Flags, 2, "amigaslides");
Skip_Flags(Flags, 3, "0vol optimizations");
Skip_Flags(Flags, 4, "amiga limits");
Skip_Flags(Flags, 5, "enable filter/sfx with sb");
Skip_Flags(Flags, 6, "st3.00 volumeslides");
Skip_Flags(Flags, 7, "pecial custom data in file");
Get_L1 (SoftwareVersionMajor, "Cwt/v (Major)");
Get_L1 (SoftwareVersionMinor, "Cwt/v (Minor)");
Skip_L2( "File format information");
Skip_B4( "Signature");
Skip_L1( "global volume");
Get_L1 (IS, "Initial Speed");
Get_L1 (TS, "Initial Temp");
Skip_L1( "master volume");
Skip_L1( "ultra click removal");
Skip_L1( "Default channel pan positions are present");
Skip_L1( "Unknown");
Skip_L1( "Unknown");
Skip_L1( "Unknown");
Skip_L1( "Unknown");
Skip_L1( "Unknown");
Skip_L1( "Unknown");
Skip_L1( "Unknown");
Skip_L1( "Unknown");
Get_L2 (Special, "Special");
Skip_XX(32, "Channel settings");
Skip_XX(OrdNum, "Orders");
Skip_XX(InsNum*2, "Instruments");
Skip_XX(PatNum*2, "Patterns");
FILLING_BEGIN();
Accept("Scream Tracker 3");
Fill(Stream_General, 0, General_Format, "Scream Tracker 3");
Fill(Stream_General, 0, General_Track, SongName);
if ((SoftwareVersionMajor&0xF0)==0x10)
Fill(Stream_General, 0, General_Encoded_Application, Ztring(__T("Scream Tracker ")+Ztring::ToZtring(SoftwareVersionMajor)+__T(".")+Ztring::ToZtring(SoftwareVersionMinor/16)+Ztring::ToZtring(SoftwareVersionMinor%16)));
Fill(Stream_General, 0, "BPM", TS);
Stream_Prepare(Stream_Audio);
Finish("Scream Tracker 3");
FILLING_END();
}
