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

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

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