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

//---------------------------------------------------------------------------void File_Nut::Header_Parse(){    //Parsing    int8u  N;    Peek_B1(N);    if (N==0x4E) //'N'    {        //Header        int64u startcode, forward_ptr;        Get_B8(startcode,                                       "startcode");        Get_VS(forward_ptr,                                     "forward_ptr");        if (forward_ptr>4096)            Skip_B4(                                            "header_checksum");        Header_Fill_Code(startcode, Ztring().From_Number(startcode, 16)); //Quick filling for CC8 with text        Header_Fill_Size(Element_Offset+forward_ptr); //4 for cheksum    }    else    {        //Frame        Header_Fill_Code(0, "Frame");        Header_Fill_Size(0);        Finish();    }}

//---------------------------------------------------------------------------void File_Mpeg4_Descriptors::Header_Parse(){    //Parsing    size_t Size=0;    int8u type, Size_ToAdd;    Get_B1(type,                                            "type");    if (type==0)    {        Header_Fill_Code(0x00, "Padding");        Header_Fill_Size(1);        return;    }    do    {        Get_B1(Size_ToAdd,                                  "size");        Size=(Size<<7) | (Size_ToAdd&0x7F);    }    while (Size_ToAdd&0x80);    //Filling    Header_Fill_Code(type, Ztring().From_CC1(type));    if (Element_Offset+Size>=Element_Size)        Size=(size_t)(Element_Size-Element_Offset); //Found one file with too big size but content is OK, cutting the block    Header_Fill_Size(Element_Offset+Size);}

//---------------------------------------------------------------------------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 File_DvbSubtitle::Header_Parse(){    //Parsing    int8u sync_byte;    Get_B1 (sync_byte,                                          "sync_byte");    switch (sync_byte)    {        case 0xFF : //Stuffing                    MustFindDvbHeader=true;                    //Filling                    Header_Fill_Code(0xFF, "end of PES data field marker");                    Header_Fill_Size(1);                    return;        default   : ; //Normal (0x0F)    }    int16u segment_length;    int8u  segment_type;    Get_B1 (segment_type,                                       "segment_type");    Get_B2 (page_id,                                            "page_id");    Get_B2 (segment_length,                                     "segment_length");    //Filling    Header_Fill_Code(segment_type);    Header_Fill_Size(Element_Offset+segment_length);}

//---------------------------------------------------------------------------void File_Lyrics3v2::Header_Parse(){    if (TotalSize<=15) //First 10 is minimum size of a tag, Second 10 is ID3v2 header size    {        //Place for footer        Header_Fill_Code((int64u)-1, "File Footer");        Header_Fill_Size(TotalSize);        return;    }    //Parsing    Ztring SizeT;    int64u Size;    int32u Field;    Get_C3 (Field,                                           "Field");    Get_Local(5, SizeT,                                      "Size");    Size=8+SizeT.To_int64u();    //Filling    if (Size+15>TotalSize)        Size=TotalSize-15;    Header_Fill_Code(Field, Ztring().From_CC3(Field));    Header_Fill_Size(Size);    TotalSize-=Size;}

//---------------------------------------------------------------------------void File_Pcm::Header_Parse(){    //Filling    Header_Fill_Code(0, "Block");    if (BitDepth && Channels)        Header_Fill_Size((Element_Size/(BitDepth*Channels/8))*(BitDepth*Channels/8)); //A complete sample    else        Header_Fill_Size(Element_Size); // Unknown sample size}

//---------------------------------------------------------------------------void File_Vc3::Header_Parse(){    int32u CompressionID=BigEndian2int32u(Buffer+Buffer_Offset+0x28);    Header_Fill_Code(0, "Frame");    Header_Fill_Size(Vc3_CompressedFrameSize(CompressionID));}

//---------------------------------------------------------------------------bool File_AvsV::Header_Parser_Fill_Size(){    //Look for next Sync word    if (Buffer_Offset_Temp==0) //Buffer_Offset_Temp is not 0 if Header_Parse_Fill_Size() has already parsed first frames        Buffer_Offset_Temp=Buffer_Offset+4;    while (Buffer_Offset_Temp+4<=Buffer_Size        && CC3(Buffer+Buffer_Offset_Temp)!=0x000001)    {        Buffer_Offset_Temp+=2;        while(Buffer_Offset_Temp<Buffer_Size && Buffer[Buffer_Offset_Temp]!=0x00)            Buffer_Offset_Temp+=2;        if (Buffer_Offset_Temp<Buffer_Size && Buffer[Buffer_Offset_Temp-1]==0x00 || Buffer_Offset_Temp>=Buffer_Size)            Buffer_Offset_Temp--;    }    //Must wait more data?    if (Buffer_Offset_Temp+4>Buffer_Size)    {        if (FrameIsAlwaysComplete || File_Offset+Buffer_Size==File_Size)            Buffer_Offset_Temp=Buffer_Size; //We are sure that the next bytes are a start        else            return false;    }    //OK, we continue    Header_Fill_Size(Buffer_Offset_Temp-Buffer_Offset);    Buffer_Offset_Temp=0;    return true;}

//---------------------------------------------------------------------------// An Element// Size                             2 bytes, Pos=4// Code                             5 bytes, Pos=6//void File_Jpeg::Header_Parse(){    //Parsing    int16u code, size=0;    Get_B2 (code,                                               "code");    switch (code)    {        case Elements::TEM :        case Elements::RST0 :        case Elements::RST1 :        case Elements::RST2 :        case Elements::RST3 :        case Elements::RST4 :        case Elements::RST5 :        case Elements::RST6 :        case Elements::RST7 :        case Elements::SOI  :        case Elements::EOI  :                    break; //Size=0        default   : Get_B2 (size,                                  "size");    }    //Filling    Header_Fill_Code(code, Ztring().From_CC2(code));    Header_Fill_Size(2+size);}

//---------------------------------------------------------------------------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_DolbyE::Header_Parse(){    //Filling    if (IsSub)        Header_Fill_Size(Buffer_Size-Buffer_Offset);    else    {        //Looking for synchro        //Synchronizing        Buffer_Offset_Temp=Buffer_Offset+3;        if (BitDepth==16)            while (Buffer_Offset_Temp+2<=Buffer_Size)            {                if ((CC2(Buffer+Buffer_Offset_Temp)&0xFFFE)==0x078E) //16-bit                    break; //while()                Buffer_Offset_Temp++;            }        if (BitDepth==20)            while (Buffer_Offset_Temp+3<=Buffer_Size)            {                if ((CC3(Buffer+Buffer_Offset_Temp)&0xFFFFE0)==0x0788E0) //20-bit                    break; //while()                Buffer_Offset_Temp++;            }        if (BitDepth==24)            while (Buffer_Offset_Temp+3<=Buffer_Size)            {                if ((CC3(Buffer+Buffer_Offset_Temp)&0xFFFFFE)==0x07888E) //24-bit                    break; //while()                Buffer_Offset_Temp++;            }        if (Buffer_Offset_Temp+(BitDepth>16?3:2)>Buffer_Size)        {            if (File_Offset+Buffer_Size==File_Size)                Buffer_Offset_Temp=Buffer_Size;            else            {                Element_WaitForMoreData();                return;            }        }        Header_Fill_Size(Buffer_Offset_Temp-Buffer_Offset);    }    Header_Fill_Code(0, "Frame");}

//---------------------------------------------------------------------------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_Dpx::Header_Parse(){    //Filling    Header_Fill_Code(Sizes_Pos); //We use Sizes_Pos as the unique key    if (Sizes.empty())    {        if (Element_Size<28)        {            Element_WaitForMoreData();            return;        }        int32u Size=LittleEndian?LittleEndian2int32u(Buffer+Buffer_Offset+24):BigEndian2int32u(Buffer+Buffer_Offset+24);        if (Size==(int32u)-1)            Size=LittleEndian?LittleEndian2int32u(Buffer+Buffer_Offset+4):BigEndian2int32u(Buffer+Buffer_Offset+4);        Header_Fill_Size(Size);    }    else        Header_Fill_Size(Sizes[Sizes_Pos]);}

//---------------------------------------------------------------------------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_Lyrics3v2::Header_Parse(){    if (Buffer_Offset+15>=Buffer_Size) //first 10 is minimum size of a tag, Second 10 is ID3v2 header size    {        //Place for footer        Header_Fill_Code(0xFFFFFFFF, "Footer");        Header_Fill_Size(Buffer_Size-Buffer_Offset);        return;    }    //Parsing    Ztring Size;    int32u Field;    Get_C3 (Field,                                           "Field");    Get_Local(5, Size,                                       "Size");    //Filling    Header_Fill_Code(Field, Ztring().From_CC3(Field));    Header_Fill_Size(8+Size.To_int64u());}

//---------------------------------------------------------------------------void File_Png::Header_Parse(){    //Parsing    int32u Length, Chunk_Type;    Get_B4 (Length,                                             "Length");    Get_C4 (Chunk_Type,                                         "Chunk Type");    //Filling    Header_Fill_Size(12+Length); //+4 for CRC    Header_Fill_Code(Chunk_Type, Ztring().From_CC4(Chunk_Type));}

//---------------------------------------------------------------------------void File_Wm::Header_Parse(){    if (!MustUseAlternativeParser)    {        //Parsing        int128u Name;        int64u Size;        Get_GUID(Name,                                              "Name");        Get_L8 (Size,                                               "Size");        //Filling        Header_Fill_Code(Name.hi, Ztring().From_GUID(Name));        Header_Fill_Size(Size);    }    else    {        Header_Fill_Code(0, "Packet");        Header_Fill_Size(MaximumDataPacketSize);    }}

//---------------------------------------------------------------------------void File_TwinVQ::Header_Parse(){    //Parsing    int32u id, size;    Get_C4 (id,                                                 "id");    Get_B4 (size,                                               "size");    //Filling    Header_Fill_Code(id, Ztring().From_CC4(id));    Header_Fill_Size(8+(id==Elements::DATA?0:size)); //DATA chunk indicates the end of the header, with no chunk size}

//---------------------------------------------------------------------------void File_Png::Header_Parse(){    if (!Signature_Parsed)    {        //Filling        Header_Fill_Size(8);        Header_Fill_Code(0, "File header");        return;    }    //Parsing    int32u Length, Chunk_Type;    Get_B4 (Length,                                             "Length");    Get_C4 (Chunk_Type,                                         "Chunk Type");    //Filling    Header_Fill_Size(12+Length); //+4 for CRC    Header_Fill_Code(Chunk_Type, Ztring().From_CC4(Chunk_Type));}

//---------------------------------------------------------------------------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_Tak::Header_Parse(){    //Parsing    int32u block_length;    int8u block_type;    Get_L1 (block_type,                                         "Block Type");    Get_L3 (block_length,                                       "Block Length");    //Filling    Header_Fill_Code(block_type, Ztring().From_CC1(block_type));    Header_Fill_Size(Element_Offset+block_length);}

//---------------------------------------------------------------------------void File_Caf::Header_Parse(){    //Parsing    int64u  ChunkSize;    int32u  ChunkType;    Get_B4 (ChunkType,                                          "ChunkType");    Get_B8(ChunkSize,                                           "ChunkSize");    //Filling    Header_Fill_Code2(ChunkType, Ztring().From_CC4(ChunkType));    Header_Fill_Size(12+ChunkSize);}

//---------------------------------------------------------------------------void File_TimedText::Header_Parse(){    //Parsing    int16u Size;    Get_B2 (Size,                                               "Size");    //Filling    Header_Fill_Code(0, "Block");    Header_Fill_Size(Element_Offset+Size);    //TODO: if IsChapter, it may be UTF-16 (with BOM), it may also be followed by an encd atom (e.g. for UTF-8 00 00 00 0C 65 6E 63 64 00 00 01 00)}

//---------------------------------------------------------------------------void File_MpcSv8::Header_Parse(){    //Parsing    int64u Size;    int16u Key;    Get_C2 (Key,                                                "Key");    Get_VS (Size,                                               "Size");    //Filling    Header_Fill_Code(Key, Ztring().From_CC4(Key<<16)); //Quick filling for CC2 with text    Header_Fill_Size(Key==Elements::AP?Element_Offset:Size); //We don't need the data of audio packet, and we will stop here...}

//---------------------------------------------------------------------------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_Ibi::Header_Parse(){    //Test of zero padding    int8u Null;    Peek_B1(Null);    if (Null==0x00)    {        Skip_B1(                                                "Zero byte");        Header_Fill_Code((int32u)-1); //Should be (int64u)-1 but Borland C++ does not like this        Header_Fill_Size(1);        return;    }    //Parsing    int64u Name, Size;    Get_EB (Name,                                               "Name");    Get_EB (Size,                                               "Size");    //Filling    Header_Fill_Code(Name, Ztring().From_Number(Name, 16));    Header_Fill_Size(Element_Offset+Size);}

//---------------------------------------------------------------------------void File_Cdxa::Header_Parse(){    //Parsing    Skip_B4(                                                    "Sync1");    Skip_B4(                                                    "Sync2");    Skip_B4(                                                    "Sync3");    Skip_B4(                                                    "Header");    Skip_B8(                                                    "SubHeader");    //Filling    Header_Fill_Size(2352);    Header_Fill_Code(0, "Chunk");}

//---------------------------------------------------------------------------void File_Ibi::Header_Parse(){    //Test of zero padding    int8u Null;    Peek_B1(Null);    if (Null==0x00)    {        if (Buffer_Offset_Temp==0)            Buffer_Offset_Temp=Buffer_Offset+1;        while (Buffer_Offset_Temp<Buffer_Size)        {            if (Buffer[Buffer_Offset_Temp])                break;            Buffer_Offset_Temp++;        }        if (Buffer_Offset_Temp>=Buffer_Size)        {            Element_WaitForMoreData();            return;        }        Header_Fill_Code((int32u)-1); //Should be (int64u)-1 but Borland C++ does not like this        Header_Fill_Size(Buffer_Offset_Temp-Buffer_Offset);        Buffer_Offset_Temp=0;        return;    }    //Parsing    int64u Name, Size;    Get_EB (Name,                                               "Name");    Get_EB (Size,                                               "Size");    //Filling    Header_Fill_Code(Name, Ztring().From_Number(Name, 16));    Header_Fill_Size(Element_Offset+Size);}