自学教程：C++ Get_L4函数代码示例

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

//---------------------------------------------------------------------------// file headervoid File_Rar::Header_Parse_Content_74(){    int16u name_size;    int8u HOST_OS, METHOD, UNP_VER;    Get_L4 (PACK_SIZE,                                          "PACK_SIZE"); //Compressed file size    Skip_L4(                                                    "UNP_SIZE"); //Uncompressed file size    Get_L1 (HOST_OS,                                            "HOST_OS"); Param_Info1((HOST_OS<6?Rar_host_os[HOST_OS]:"Unknown"));    Skip_L4(                                                    "FILE_CRC");    Skip_L4(                                                    "FTIME"); //Date and time in standard MS DOS format    Get_L1 (UNP_VER,                                            "UNP_VER"); Param_Info1(Rar_version_number(UNP_VER)); //RAR version needed to extract file    Get_L1 (METHOD,                                             "METHOD"); Param_Info1(((METHOD>=0x30)&&(METHOD<0x36)?Rar_packing_method[METHOD-0x30]:"Unknown"));    Get_L2 (name_size,                                          "NAME_SIZE"); //File name size    Skip_L4(                                                    "ATTR"); //File attributes    if(high_fields)    {        Get_L4 (HIGH_PACK_SIZE,                                 "HIGH_PACK_SIZE"); //High 4 bytes of 64 bit value of compressed file size.        Skip_L4(                                                "HIGH_UNP_SIZE"); //High 4 bytes of 64 bit value of uncompressed file size.    }    else        HIGH_PACK_SIZE=0;    if (usual_or_utf8)    {        //Must test the content before reading, looking fore zero byte        if (Element_Offset+name_size>Element_Size)        {            Skip_XX(Element_Size-Element_Offset,                "Error");            return;        }        int64u ZeroPos=0;        while (ZeroPos<name_size)        {            if (Buffer[Buffer_Offset+(size_t)(Element_Offset+ZeroPos)]==0)                break; //Found            ZeroPos++;        }        if (ZeroPos==name_size)            Skip_UTF8(name_size,                                "FILE_NAME");        else        {            Skip_Local(ZeroPos,                                 "FILE_NAME"); //Up to ZeroPos            Skip_L1(                                            "Zero");            Skip_UTF16L(name_size-(ZeroPos+1),                  "FILE_NAME"); //Spec is not precise, "Unicode" without encoding format (character size, endianess), because RAR is from Windows, we hope this is the format from Windows (UTF-16 Little Endian)        }    }    else        Skip_Local(name_size,                                   "FILE_NAME");    if (salt)        Skip_L8(                                                "SALT");    //if(exttime)        //Skip_XX("EXT_TIME"); //Which size?}

//---------------------------------------------------------------------------void File_Bmp::Read_Buffer_Continue(){    //Parsing    int32u Size, DIB_Size, Offset;    Element_Begin1("File header");        Skip_C2(                                                "Magic");        Get_L4 (Size,                                           "Size");        Skip_L2(                                                "Reserved");        Skip_L2(                                                "Reserved");        Get_L4 (Offset,                                         "Offset of data");    Element_End0();    FILLING_BEGIN();        if (Size!=(int32u)-1 && Size!=File_Size)        {            Reject("BMP");            return;        }        Accept("BMP");        Fill(Stream_General, 0, General_Format, "Bitmap");        Stream_Prepare(Stream_Image);    FILLING_END();    Element_Begin1("DIB header");        Peek_L4 (DIB_Size);        switch (DIB_Size)        {            case  12 : BitmapCoreHeader(1); break;            case  40 : BitmapInfoHeader(1); break;            case  52 : BitmapInfoHeader(2); break;            case  56 : BitmapInfoHeader(3); break;            case  64 : BitmapCoreHeader(2); break;            case 108 : BitmapInfoHeader(4); break;            case 124 : BitmapInfoHeader(5); break;            default  : if (DIB_Size>124)                       {                           BitmapInfoHeader((int8u)-1); //Future versions of BitmapInfoHeader (OS/2 is abandonned)                           Skip_XX(14+124-Element_Offset,       "Unknown");                       }        }    Element_End0();    if (Element_Offset<Offset)        Skip_XX(Offset-Element_Offset,                          "Other header data");    Skip_XX(File_Size-Offset,                                   "Image data");    //No need of more    Finish("BMP");}

//---------------------------------------------------------------------------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_Dpx::Get_X4(int32u &Info, const char* Name){    if (LittleEndian)        Get_L4 (Info,                                           Name);    else        Get_B4 (Info,                                           Name);}

//---------------------------------------------------------------------------void File_Exr::Header_Parse(){    //Header    if (CC4(Buffer+Buffer_Offset)==0x762F3101) //"v/1"+1    {        //Filling        Header_Fill_Code(0, "File header");        Header_Fill_Size(12);        return;    }    //Image data    if (name_End==0)    {        //Filling        Header_Fill_Code(0, "Image data");        Header_Fill_Size(ImageData_End-(File_Offset+Buffer_Offset));        return;    }            int32u size;    Get_String(name_End, name,                                  "name");    Element_Offset++; //Null byte    Get_String(type_End, type,                                  "type");    Element_Offset++; //Null byte    Get_L4 (size,                                               "size");            //Filling    Header_Fill_Code(0, Ztring().From_Local(name.c_str()));    Header_Fill_Size(name_End+1+type_End+1+4+size);}

//---------------------------------------------------------------------------void Riff_AVI__hdrl_strl_indx::Read_Internal (){    //Filling    Global->AVI__hdrl_strl_indx_Pointers.insert(this);    //Reading    Read_Internal_ReadAllInBuffer();    //Parsing    int32u Entry_Count, ChunkId;    int16u LongsPerEntry;    int8u  IndexType, IndexSubType;    Get_L2 (LongsPerEntry);    Get_L1 (IndexSubType);    Get_L1 (IndexType);    Get_L4 (Entry_Count);    Get_C4 (ChunkId);    //Integrity    if (LongsPerEntry!=4 || (IndexSubType&0xFE) || IndexType!=0x00 || 24+Entry_Count*16>Chunk.Content.Size)        throw exception_valid("hdrl_strl_indx form is not supported");    //Parsing    Skip_XX(12); //Reserved    for (int32u Pos=0; Pos<Entry_Count; Pos++)    {        int64u Offset;        Get_L8 (Offset);        Skip_XX(8); //Size + Duration        //Filling        Global->AVI__hdrl_strl_indx_In_Position_Indexes_List.push_back(Offset);        Global->AVI__movi___ix_WithFields[ChunkId]=(IndexSubType&0x01)?true:false;    }}

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

bool File_Zip::end_of_central_directory(){    if (Element_Offset+22>Element_Size) //end_of_central_directory up to relative offset of .ZIP file comment length included        return false; //Not enough data    //Retrieving complete local_file_header size    int16u zip_comment_length=LittleEndian2int16u(Buffer+(size_t)Element_Offset+20);    if (Element_Offset+22+zip_comment_length>Element_Size) //end_of_central_directory all included        return false; //Not enough data    //Parsing    int32u offset;    Element_Begin1("End of central directory");    Skip_C4(                                                    "end of central dir signature");    Skip_L2(                                                    "number of this disk");    Skip_L2(                                                    "number of the disk");// with the start of the central directory    Skip_L2(                                                    "total number of entries on this disk");// in the central directory    Skip_L2(                                                    "total number of entries");// in the central directory    Skip_L4(                                                    "size of the central directory");    Get_L4 (offset,                                             "offset of start of central directory");// with respect to the starting disk number    Skip_L2(                                                    "zip file comment length");    Skip_XX(zip_comment_length,                                 "zip file comment");    Element_End0();    //Going to first central directory (once)    if (!end_of_central_directory_IsParsed)    {        end_of_central_directory_IsParsed=true;        GoTo(offset);    }    return true;}

//---------------------------------------------------------------------------void File_Pmp::FileHeader_Parse(){     //Parsing    int32u version, video_format=0, nb_frames=0, video_width=0, video_height=0, time_base_num=0, time_base_den=0, audio_format=0, sample_rate=0, channels=0;    Skip_C4(                                                    "Signature");    Get_L4 (version,                                            "Version");    if (version==1)    {        Get_L4 (video_format,                                   "video_format");        Get_L4 (nb_frames,                                      "number of frames");        Get_L4 (video_width,                                    "video_width");        Get_L4 (video_height,                                   "video_height");        Get_L4 (time_base_num,                                  "time_base_num");        Get_L4 (time_base_den,                                  "time_base_den");        Skip_L4(                                                "number of audio streams");        Get_L4 (audio_format,                                   "audio_format");        Get_L4 (channels,                                       "channels");        Skip_L4(                                                "unknown");        Get_L4 (sample_rate,                                    "sample_rate");    }    FILLING_BEGIN();        Accept("PMP");        Fill(Stream_General, 0, General_Format, "PMP");        if (version==1)        {            Stream_Prepare(Stream_Video);            Fill(Stream_Video, 0, Video_Format, Pmp_video_format(video_format));            Fill(Stream_Video, 0, Video_FrameCount, nb_frames);            Fill(Stream_Video, 0, Video_Width, video_width);            Fill(Stream_Video, 0, Video_Height, video_height);            Fill(Stream_Video, 0, Video_FrameRate, (float)time_base_den / 100);            Stream_Prepare(Stream_Audio);            Fill(Stream_Audio, 0, Audio_Format, Pmp_audio_format(audio_format));            Fill(Stream_Audio, 0, Audio_Channel_s_, channels);            Fill(Stream_Audio, 0, Audio_SamplingRate, sample_rate);        }        //No more need data        Finish("PMP");    FILLING_END();}

//---------------------------------------------------------------------------void File_Ogg::Header_Parse(){    //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)");        Skip_Flags(flags, 2,                                    "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_Finnished=true;        }        else            Chunk_Sizes_Finnished=false;    }    if (Chunk_Sizes_Finnished)        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;}

//---------------------------------------------------------------------------void File_Ps2Audio::SShd(){    Element_Begin1("SShd (Header)");        //Parsing        int32u Size, Format, SamplingRate, Channels;        Skip_C4(                                                "ID");        Get_L4 (Size,                                           "Size");        if (Size!=0x18)        {            Trusted_IsNot("Bad size");            return;        }        Get_L4 (Format,                                         "Format");        Get_L4 (SamplingRate,                                   "Sampling rate");        Get_L4 (Channels,                                       "Channels");        Skip_L4(                                                "Bytes per channel");        Skip_L4(                                                "Reserved");        Skip_L4(                                                "Reserved");    Element_End0();    FILLING_BEGIN();        Accept("PS2 Audio");        BitRate=SamplingRate*Channels*16; //Always 16 bits        Stream_Prepare(Stream_Audio);        Ztring FormatS;        switch(Format)        {            case 0x00000001 : FormatS=__T("PCM"); break;            case 0x00000010 : FormatS=__T("ADPCM"); break;            default         : ;        }        Fill(Stream_Audio, 0, Audio_Format, FormatS);        Fill(Stream_Audio, 0, Audio_Codec,  FormatS);        Fill(Stream_Audio, 0, Audio_MuxingMode, "PS2");        Fill(Stream_Audio, 0, Audio_SamplingRate, SamplingRate);        Fill(Stream_Audio, 0, Audio_Channel_s_, Channels);        Fill(Stream_Audio, 0, Audio_BitRate, BitRate);    FILLING_END();}

//---------------------------------------------------------------------------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_Ico::Data_Parse(){    //Parsing    int32u Size, Offset;    int16u BitsPerPixel;    int8u Width, Height;    Get_L1 (Width,                                      "Width");    Get_L1 (Height,                                     "Height");    Skip_L1(                                            "Colour count");    Skip_L1(                                            "Reserved");    Skip_L2(                                            Type==1?"Colour planes":"X hotspot");    Get_L2 (BitsPerPixel,                               Type==1?"Bits per pixel":"Y hotspot");    Get_L4 (Size,                                       "Size of the bitmap data");    Get_L4 (Offset,                                     "Offset of the bitmap data");    FILLING_BEGIN_PRECISE();        stream Stream;        Stream.Width=Width;        Stream.Height=Height;        Stream.BitsPerPixel=BitsPerPixel;        Stream.Size=Size;        Stream.Offset=Offset;        Streams.push_back(Stream);        IcoDataSize+=Size;        if (Offset>File_Size || File_Offset+Buffer_Offset+Element_Size+IcoDataSize>File_Size)            Reject("ICO");        Count--;        if (Count==0)        {            if (File_Offset+Buffer_Offset+Element_Size+IcoDataSize!=File_Size)                Reject("ICO");            else            {                Accept("ICO");                Finish("ICO");            }        }    FILLING_END();}

//---------------------------------------------------------------------------void File_ApeTag::Header_Parse(){    //Testing if begin or end of tags    if (CC8(Buffer+Buffer_Offset)==0x4150455441474558LL) //"APETAGEX"    {        //Filling        Header_Fill_Code((int64u)-1, "File Footer");        Header_Fill_Size(0x20);        return;    }    //Parsing    Ztring Value;    int32u Flags, Length;    Get_L4 (Length,                                         "Length");    Get_L4 (Flags,                                          "Flags");        Skip_Flags(Flags,  0,                               "Read Only");        Skip_Flags(Flags,  1,                               "Binary");        Skip_Flags(Flags,  2,                               "Locator of external stored information");        Skip_Flags(Flags, 29,                               "Is the header");        Skip_Flags(Flags, 30,                               "Contains a footer");        Skip_Flags(Flags, 31,                               "Contains a header");    size_t Pos=(size_t)Element_Offset;    for (; Pos<Element_Size; Pos++)        if (Buffer[Buffer_Offset+Pos]==0x00)            break;    if (Pos==Element_Size)    {        Element_WaitForMoreData();        return;    }    Get_String(Pos-Element_Offset, Key,                     "Key");    Skip_L1(                                                "0x00");    //Filling    Header_Fill_Code(0, Key.c_str());    Header_Fill_Size(Element_Offset+Length);}

//---------------------------------------------------------------------------void File_Tta::FileHeader_Parse(){    //Parsing    int32u SampleRate, Samples, CRC32;    int16u AudioFormat, Channels, BitsPerSample;    Skip_C4(                                                    "Signature");    Get_L2 (AudioFormat,                                        "AudioFormat");    Get_L2 (Channels,                                           "NumChannels");    Get_L2 (BitsPerSample,                                      "BitsPerSample");    Get_L4 (SampleRate,                                         "SampleRate");    Get_L4 (Samples,                                            "DataLength");    Get_L4 (CRC32,                                              "CRC32");    FILLING_BEGIN();        if (SampleRate==0)            return;        Duration=((int64u)Samples)*1000/SampleRate;        if (Duration==0)            return;        UncompressedSize=((int64u)Samples)*Channels*(BitsPerSample/8);        if (UncompressedSize==0)            return;        //Filling data        File__Tags_Helper::Accept("TTA");        File__Tags_Helper::Stream_Prepare(Stream_Audio);        Fill(Stream_Audio, 0, Audio_Format, "TTA");        Fill(Stream_Audio, 0, Audio_Codec, "TTA ");        Fill(Stream_Audio, 0, Audio_BitDepth, BitsPerSample);        Fill(Stream_Audio, StreamPos_Last, Audio_Channel_s_, Channels);        Fill(Stream_Audio, StreamPos_Last, Audio_SamplingRate, SampleRate);        Fill(Stream_Audio, 0, Audio_Duration, Duration);    FILLING_END();    //No more need data    File__Tags_Helper::Finish("TTA");}

//---------------------------------------------------------------------------void File_ApeTag::HeaderFooter(){    //Parsing    int32u Flags;    Skip_C8(                                                    "Preamble");    Skip_L4(                                                    "Version");    Skip_L4(                                                    "Size");    Skip_L4(                                                    "Count");    Get_L4 (Flags,                                              "Flags");        Skip_Flags(Flags,  0,                                   "Read Only");        Skip_Flags(Flags,  1,                                   "Binary");        Skip_Flags(Flags,  2,                                   "Locator of external stored information");        Skip_Flags(Flags, 29,                                   "Is the header");        Skip_Flags(Flags, 30,                                   "Contains a footer");        Skip_Flags(Flags, 31,                                   "Contains a header");    Skip_L8(                                                    "Reserved");}

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

//---------------------------------------------------------------------------void File_Tak::STREAMINFO(){    //Parsing    int32u num_samples_hi, samplerate;    int8u  num_samples_lo, framesizecode, samplesize;    bool   channels;    Skip_L1 (                                                   "unknown");    BS_Begin();    Get_S1 ( 2, num_samples_lo,                                 "num_samples (lo)");    Get_S1 ( 3, framesizecode,                                  "framesizecode");    Skip_S1( 2,                                                 "unknown");    BS_End();    Get_L4 (num_samples_hi,                                     "num_samples (hi)"); Param_Info2((((int64u)num_samples_hi)<<2 | num_samples_lo), " samples");    Get_L3 (samplerate,                                         "samplerate"); Param_Info2((samplerate/16)+6000, " Hz");    BS_Begin();    Skip_S1( 4,                                                 "unknown");    Get_SB (    channels,                                       "channels"); Param_Info1(channels?"Stereo":"Mono");    Get_S1 ( 2, samplesize,                                     "samplesize"); Param_Info1(Tak_samplesize[samplesize]);    Skip_SB(                                                    "unknown");    BS_End();    Skip_L3(                                                    "crc");    FILLING_BEGIN()        //Coherency        if (samplerate==0)            return;        //Computing        int64u Samples=((int64u)num_samples_hi)<<2 | num_samples_lo;        int32u SamplingRate=(samplerate/16)+6000;        //Filling        File__Tags_Helper::Accept("TAK");        File__Tags_Helper::Stream_Prepare(Stream_Audio);        Fill(Stream_Audio, 0, Audio_Format, "TAK");        Fill(Stream_Audio, 0, Audio_Codec, "TAK");        Fill(Stream_Audio, 0, Audio_SamplingRate, SamplingRate);        Fill(Stream_Audio, 0, Audio_Channel_s_, channels?2:1);        if (Tak_samplesize[samplesize])            Fill(Stream_Audio, 0, Audio_BitDepth, Tak_samplesize[samplesize]);        Fill(Stream_Audio, 0, Audio_Duration, Samples*1000/SamplingRate);    FILLING_END();}

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

//---------------------------------------------------------------------------void File_Wvpk::Header_Parse(){    //Specific cases    if (FromMKV)    {        Header_Fill_Size(Element_Size);        Header_Fill_Code(0, "Block");        return;    }    //Parsing    int32u ckSize;    Skip_C4(                                                    "ckID");    Get_L4 (ckSize,                                             "ckSize");    //Filling    Header_Fill_Size(8+ckSize);    Header_Fill_Code(0, "Block");}

//---------------------------------------------------------------------------void File_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_Dpg::FileHeader_Parse(){    //Parsing    int32u  FrameCount, FrameRate, SamplingRate;    Skip_C4(                                                    "Signature");    Get_L4 (FrameCount,                                         "Frame count");    Get_L4 (FrameRate,                                          "Frame rate"); Param_Info2(FrameRate/0x100, " fps");    Get_L4 (SamplingRate,                                       "Sampling rate");    Skip_L4(                                                    "0x00000000");    Get_L4 (Audio_Offset,                                       "Audio Offset");    Get_L4 (Audio_Size,                                         "Audio Size");    Get_L4 (Video_Offset,                                       "Video Offset");    Get_L4 (Video_Size,                                         "Video Size");    FILLING_BEGIN();        Accept("DPG");        Fill(Stream_General, 0, General_Format, "DPG");        Stream_Prepare(Stream_Video);        Fill(Stream_Video, 0, Video_FrameRate, (float)(FrameRate/0x100), 3);        Fill(Stream_Video, 0, Video_FrameCount, FrameCount);        Fill(Stream_Video, 0, Video_StreamSize, Video_Size);        Stream_Prepare(Stream_Audio);        Fill(Stream_Audio, 0, Audio_SamplingRate, SamplingRate);        Fill(Stream_Audio, 0, Audio_StreamSize, Audio_Size);        //Positionning        #if defined(MEDIAINFO_MPEGA_YES)            Parser=new File_Mpega();            Open_Buffer_Init(Parser);            GoTo(Audio_Offset, "DPG");        #elif defined(MEDIAINFO_MPEGV_YES)            Audio_Size=0;            Parser=new File_Mpegv();            Open_Buffer_Init(Parser);            GoTo(Video_Offset, "DPG");        #else            Finish("DPG");        #endif    FILLING_END();}

//---------------------------------------------------------------------------void File_Ps2Audio::SSbd(){    if (Count_Get(Stream_Audio)!=1)    {        Trusted_IsNot("Element should not be here");        return;    }    Element_Begin1("SSbd (Body)");        int32u Size;        Skip_C4(                                                "ID");        Get_L4 (Size,                                           "Size");        Skip_XX(Element_Size-Element_Offset,                    "Data (Partial)");    Element_End0();    FILLING_BEGIN();        Fill(Stream_Audio, 0, Audio_StreamSize, Size);        if (BitRate)            Fill(Stream_Audio, 0, Audio_Duration, ((int64u)Size)*1000*8/BitRate);        Finish("PS2 Audio");    FILLING_END();}