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

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

//---------------------------------------------------------------------------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_Jpeg::COD(){    //Parsing    int16u Levels;    int8u Style, Style2, MultipleComponentTransform;    bool PrecinctUsed;    Get_B1 (Style,                                              "Scod - Style");        Get_Flags (Style, 0, PrecinctUsed,                      "Precinct used");        Skip_Flags(Style, 1,                                    "Use SOP (start of packet)");        Skip_Flags(Style, 2,                                    "Use EPH (end of packet header)");    Skip_B1(                                                    "Number of decomposition levels");    Skip_B1(                                                    "Progression order");    Get_B2 (Levels,                                             "Number of layers");    Info_B1(DimX,                                               "Code-blocks dimensions X (2^(n+2))"); Param_Info2(1<<(DimX+2), " pixels");    Info_B1(DimY,                                               "Code-blocks dimensions Y (2^(n+2))"); Param_Info2(1<<(DimY+2), " pixels");    Get_B1 (Style2,                                             "Style of the code-block coding passes");        Skip_Flags(Style, 0,                                    "Selective arithmetic coding bypass");        Skip_Flags(Style, 1,                                    "MQ states for all contexts");        Skip_Flags(Style, 2,                                    "Regular termination");        Skip_Flags(Style, 3,                                    "Vertically stripe-causal context formation");        Skip_Flags(Style, 4,                                    "Error resilience info is embedded on MQ termination");        Skip_Flags(Style, 5,                                    "Segmentation marker is to be inserted at the end of each normalization coding pass");    Skip_B1(                                                    "Transform");    Get_B1(MultipleComponentTransform,                          "Multiple component transform");    if (PrecinctUsed)    {        BS_Begin();        Skip_S1(4,                                              "LL sub-band width");        Skip_S1(4,                                              "LL sub-band height");        BS_End();        for (int16u Pos=0; Pos<Levels; Pos++)        {            Element_Begin1("Decomposition level");            BS_Begin();            Skip_S1(4,                                          "decomposition level width");            Skip_S1(4,                                          "decomposition level height");            BS_End();            Element_End0();        }    }    FILLING_BEGIN();        if (Frame_Count==0 && Field_Count==0)        {            switch (MultipleComponentTransform)            {                case 0x01 : Fill(StreamKind_Last, 0, "Compression_Mode", "Lossless"); break;                case 0x02 : Fill(StreamKind_Last, 0, "Compression_Mode", "Lossy"); break;                default   : ;            }        }    FILLING_END();}

//---------------------------------------------------------------------------void File_Sdp::Header_Parse(){    //Parsing    int8u Length, FormatCode;    Skip_B2(                                                    "Identifier");    Get_B1 (Length,                                             "Length");    Get_B1 (FormatCode,                                         "Format Code");    for (int8u Pos=0; Pos<5; Pos++)    {        FieldLines[Pos]=0;        #if MEDIAINFO_TRACE            Element_Begin1("Field/Line");            BS_Begin();            Info_SB(   Field,                                   "Field Number");            Info_S1(2, Reserved,                                "Reserved");            Info_S1(5, Line,                                    "Line Number");            BS_End();            FieldLines[Pos]=((Field?1:0)<<7) |(Reserved<<5) | Line; //Removing field information ((Field?1:0)<<7) |            if (FieldLines[Pos])            {                Element_Info1(Field?2:1);                Element_Info1(Line);            }            else                Element_Info1("None");            Element_End0();        #else //MEDIAINFO_TRACE            Get_B1(FieldLines[Pos],                             "Field/Line");            FieldLines[Pos]&=0x7F; //Removing field information        #endif //MEDIAINFO_TRACE    }    Header_Fill_Size(3+Length);}

//---------------------------------------------------------------------------void File_Flac::STREAMINFO(){    Element_Info("STREAMINFO");    //Parsing    int64u Samples;    int32u FrameSize_Min, FrameSize_Max, SampleRate;    int8u  Channels, BitPerSample;    Skip_B2(                                                    "BlockSize_Min"); //The minimum block size (in samples) used in the stream.    Skip_B2(                                                    "BlockSize_Max"); //The maximum block size (in samples) used in the stream. (Minimum blocksize == maximum blocksize) implies a fixed-blocksize stream.    Get_B3 (    FrameSize_Min,                                  "FrameSize_Min"); //The minimum frame size (in bytes) used in the stream. May be 0 to imply the value is not known.    Get_B3 (    FrameSize_Max,                                  "FrameSize_Max"); //The maximum frame size (in bytes) used in the stream. May be 0 to imply the value is not known.    BS_Begin();    Get_S3 (20, SampleRate,                                     "SampleRate"); //Sample rate in Hz. Though 20 bits are available, the maximum sample rate is limited by the structure of frame headers to 1048570Hz. Also, a value of 0 is invalid.    Get_S1 ( 3, Channels,                                       "Channels"); Param_Info(Channels+1, " channels"); //(number of channels)-1. FLAC supports from 1 to 8 channels    Get_S1 ( 5, BitPerSample,                                   "BitPerSample"); Param_Info(BitPerSample+1, " bits"); //(bits per sample)-1. FLAC supports from 4 to 32 bits per sample. Currently the reference encoder and decoders only support up to 24 bits per sample.    Get_S5 (36, Samples,                                        "Samples");    BS_End();    Skip_B16(                                                   "MD5 signature of the unencoded audio data");    //Filling    if (SampleRate==0)        return;    Stream_Prepare(Stream_Audio);    Fill(Stream_Audio, 0, Audio_Format, "FLAC");    Fill(Stream_Audio, 0, Audio_Codec, "FLAC");    if (FrameSize_Min==FrameSize_Max && FrameSize_Min!=0 ) // 0 means it is unknown        Fill(Stream_Audio, 0, Audio_BitRate_Mode, "CBR");     else        Fill(Stream_Audio, 0, Audio_BitRate_Mode, "VBR");    Fill(Stream_Audio, 0, Audio_SamplingRate, SampleRate);    Fill(Stream_Audio, 0, Audio_Channel_s_, Channels+1);    Fill(Stream_Audio, 0, Audio_Resolution, BitPerSample+1);    Fill(Stream_Audio, 0, Audio_Duration, Samples*1000/SampleRate);}

//---------------------------------------------------------------------------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_Vc3::CodingControlA(){    //Parsing    Element_Begin("Coding Control A", 3);    BS_Begin();    Mark_0();    Mark_0();    Mark_0();    Mark_0();    Mark_0();    Mark_0();    Info_S1(2, FFC,                                             "Field/Frame Count"); Param_Info(Vc3_FFC[FFC]);    Mark_1();    Mark_0();    Mark_0();    Get_SB (   CRCF,                                             "CRC flag");    Mark_0();    Mark_0();    Mark_0();    Mark_0();    Mark_1();    Mark_0();    Mark_1();    Mark_0();    Mark_0();    Mark_0();    Mark_0();    Mark_0();    BS_End();    Element_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_Pcm_M2ts::Read_Buffer_Continue(){    if (Buffer_Size==0)        return;    //Parsing    int16u  audio_data_payload_size;    Get_B2 (   audio_data_payload_size,                         "audio_data_payload_size");    BS_Begin();    Get_S1 (4, channel_assignment,                              "channel_assignment"); Param_Info2(Pcm_M2TS_channel_assignment[channel_assignment], " channel(s)");    Get_S1 (4, sampling_frequency,                              "sampling_frequency"); Param_Info2(Pcm_M2TS_sampling_frequency[sampling_frequency], " Hz");    Get_S1 (2, bits_per_sample,                                 "bits_per_sample"); Param_Info2(Pcm_M2TS_bits_per_sample[bits_per_sample], " bits");    Skip_SB(                                                    "start_flag");    Skip_S1(5,                                                  "reserved");    BS_End();    Skip_XX(audio_data_payload_size,                            "audio_data_payload");    FILLING_BEGIN_PRECISE();        if (!Status[IsAccepted])        {            Accept();            Finish();        }    FILLING_END();}

//---------------------------------------------------------------------------void File_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_Vc3::TimeCode(){    //Parsing    Element_Begin1("Time Code");    bool TCP;    BS_Begin();    Get_SB (   TCP,                                             "TCP: Time Code Present");    Mark_0();    Mark_0();    Mark_0();    Mark_0();    Mark_0();    Mark_0();    Mark_0();    BS_End();    if (TCP)    {        Skip_B8(                                                "Time Code");    }    else        Skip_B8(                                                "Junk");    Element_End0();}

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

//---------------------------------------------------------------------------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_Dts::Header_Parse(){    //Parsing    int16u Primary_Frame_Byte_Size_minus_1;    int8u  EncoderSoftwareRevision;    bool   crc_present;    Skip_B4(                                                    "Sync");    BS_Begin();    Info_SB(    FrameType,                                      "Frame Type"); Param_Info(DTS_FrameType[FrameType]);    Skip_S1( 5,                                                 "Deficit Sample Count");    Get_SB (    crc_present,                                    "CRC Present");    Skip_S1( 7,                                                 "Number of PCM Sample Blocks");    Get_S2 (14, Primary_Frame_Byte_Size_minus_1,                "Primary Frame Byte Size minus 1");    Primary_Frame_Byte_Size_minus_1+=1;    if (!Word) Primary_Frame_Byte_Size_minus_1=Primary_Frame_Byte_Size_minus_1*8/14*2; Param_Info(Ztring::ToZtring(Primary_Frame_Byte_Size_minus_1)+_T(" bytes")); //Word is on 14 bits!    Get_S1 ( 6, channel_arrangement,                            "Audio Channel Arrangement"); Param_Info(Ztring::ToZtring(DTS_Channels[channel_arrangement])+_T(" channels"));    Get_S1 ( 4, sample_frequency,                               "Core Audio Sampling Frequency"); Param_Info(Ztring::ToZtring(DTS_SamplingRate[sample_frequency])+_T(" Hz"));    Get_S1 ( 5, bit_rate,                                       "Transmission Bit Rate"); Param_Info(Ztring::ToZtring(DTS_BitRate[bit_rate])+_T(" bps"));    Skip_SB(                                                    "Embedded Down Mix Enabled");    Skip_SB(                                                    "Embedded Dynamic Range");    Skip_SB(                                                    "Embedded Time Stamp");    Skip_SB(                                                    "Auxiliary Data");    Skip_SB(                                                    "HDCD");    Get_S1 ( 3, ExtensionAudioDescriptor,                       "Extension Audio Descriptor"); Param_Info(DTS_ExtensionAudioDescriptor[ExtensionAudioDescriptor]);    Get_SB (    ExtendedCoding,                                 "Extended Coding");    Skip_SB(                                                    "Audio Sync Word Insertion");    Get_S1 ( 2, lfe_effects,                                    "Low Frequency Effects");    Skip_SB(                                                    "Predictor History");    if (crc_present)        Skip_S2(16,                                             "Header CRC Check");    Skip_SB(                                                    "Multirate Interpolator");    Get_S1 ( 4, EncoderSoftwareRevision,                        "Encoder Software Revision");    Skip_S1( 2,                                                 "Copy History");    Get_S1 ( 2, bits_per_sample,                                "Source PCM Resolution"); Param_Info(Ztring::ToZtring(DTS_Resolution[bits_per_sample])+_T(" bits"));    Skip_SB(                                                    "ES");    Skip_SB(                                                    "Front Sum/Difference");    Skip_SB(                                                    "Surrounds Sum/Difference");    Skip_S1( 4,                                                 "Dialog Normalisation Parameter");    switch (EncoderSoftwareRevision)    {        case 6 :                Skip_S1( 4,                                     "Dialog Normalisation Parameter");                break;        case 7 :                Skip_S1( 4,                                     "Dialog Normalisation Parameter");                break;        default :                Skip_S1( 4,                                     "Unspecified");                break;    }    BS_End();    //Filling    Header_Fill_Size(Primary_Frame_Byte_Size_minus_1+DTS_HD_Unknown_Size); //TODO: change this, for DTS-HD    Header_Fill_Code(0, "Frame");}

//---------------------------------------------------------------------------void File_Aac::Read_Buffer_Continue_AudioSpecificConfig(){    File__Analyze::Accept(); //We automaticly trust it    BS_Begin();    AudioSpecificConfig(0); //Up to the end of the block    BS_End();    Mode=Mode_raw_data_block; //Mode_AudioSpecificConfig only once}

//---------------------------------------------------------------------------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_Aac::FileHeader_Parse_ADIF(){    adif_header();    BS_Begin();    raw_data_block();    BS_End();    FILLING_BEGIN();        File__Tags_Helper::Finish();    FILLING_END();}

//---------------------------------------------------------------------------void File_Latm::Header_Parse(){    int16u audioMuxLengthBytes;    BS_Begin();    Skip_S2(11,                                                 "syncword");    Get_S2 (13, audioMuxLengthBytes,                            "audioMuxLengthBytes");    BS_End();    //Filling    Header_Fill_Size(3+audioMuxLengthBytes);    Header_Fill_Code(0, "LATM");}

//---------------------------------------------------------------------------void File_Eia708::Header_Parse(){    //Parsing    int8u packet_size, sequence_number;    BS_Begin();    Get_S1(2, sequence_number,                                  "sequence_number");    Get_S1(6, packet_size,                                      "packet_size");    BS_End();    Header_Fill_Code(0, _T("DTVCC packet"));    Header_Fill_Size(packet_size*2);}

//---------------------------------------------------------------------------void File_MpcSv8::EI(){    //Parsing    int8u  Quality, Version1, Version2, Version3;    bool   PNS;    BS_Begin();    Get_S1 (7, Quality,                                         "Quality");    Get_SB (   PNS,                                             "PNS");    BS_End();    Get_B1 (Version1,                                           "Major version");    Get_B1 (Version2,                                           "Minor version");    Get_B1 (Version3,                                           "Build");}

//---------------------------------------------------------------------------// Packet "0E"void File_Vc1::EntryPointHeader(){    Element_Name("EntryPointHeader");    //Parsing    bool extended_mv;    BS_Begin();    Skip_SB(                                                    "broken_link");    Skip_SB(                                                    "closed_entry");    Get_SB (    panscan_flag,                                   "panscan_flag");    Skip_SB(                                                    "refdist_flag");    Skip_SB(                                                    "loopfilter");    Skip_SB(                                                    "fastuvmc");    Get_SB (    extended_mv,                                    "extended_mv");    Skip_S1( 2,                                                 "dquant");    Skip_SB(                                                    "vstransform");    Skip_SB(                                                    "overlap");    Skip_S1( 2,                                                 "quantizer");    if (hrd_param_flag)        for (int8u Pos=0; Pos<hrd_num_leaky_buckets; Pos++)        {            Element_Begin("leaky_bucket");            Skip_S2( 8,                                         "hrd_full");            Element_End();        }    TEST_SB_SKIP(                                               "coded_size_flag");        Info_S2(12, coded_width,                                "coded_width"); Param_Info((coded_width+1)*2, " pixels");        Info_S2(12, coded_height,                               "coded_height"); Param_Info((coded_height+1)*2, " pixels");    TEST_SB_END();    if (extended_mv)        Skip_SB(                                                "extended_dmv");    TEST_SB_SKIP(                                               "luma_sampling");        Skip_S1( 3,                                             "y_range");    TEST_SB_END();    TEST_SB_SKIP(                                               "chroma_sampling");        Skip_S1( 3,                                             "uv_range");    TEST_SB_END();    BS_End();        FILLING_BEGIN();        //NextCode        NextCode_Test();        NextCode_Clear();        NextCode_Add(0x0D);        //Autorisation of other streams        Streams[0x0D].Searching_Payload=true;        EntryPoint_Parsed=true;    FILLING_END();}

//---------------------------------------------------------------------------void File_Flac::Header_Parse(){    //Parsing    int32u Length;    int8u BLOCK_TYPE;    BS_Begin();    Get_SB (   Last_metadata_block,                             "Last-metadata-block");    Get_S1 (7, BLOCK_TYPE,                                      "BLOCK_TYPE");    BS_End();    Get_B3 (Length,                                             "Length");    //Filling    Header_Fill_Code(BLOCK_TYPE, Ztring().From_CC1(BLOCK_TYPE));    Header_Fill_Size(Element_Offset+Length);}