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

//---------------------------------------------------------------------------bool File_Dirac::Detect_NonDirac (){    //File_Size    if (File_Size<188*4)        return false; //We can't do detection    //Element_Size    if (Buffer_Size<188*4)        return true; //Must wait for more data    //Detect mainly DAT files, and the parser is not enough precise to detect them later    if (CC4(Buffer)==CC4("RIFF"))    {        Finnished();        return true;    }    //Detect TS files, and the parser is not enough precise to detect them later    while (Buffer_Offset<188 && CC1(Buffer+Buffer_Offset)!=0x47) //Look for first Sync word        Buffer_Offset++;    if (Buffer_Offset<188 && CC1(Buffer+Buffer_Offset+188)==0x47 && CC1(Buffer+Buffer_Offset+188*2)==0x47 && CC1(Buffer+Buffer_Offset+188*3)==0x47)    {        Finnished();        return true;    }    Buffer_Offset=0;    //Seems OK    return false;}

//---------------------------------------------------------------------------bool File_Dirac::Synchronize(){    //Synchronizing    while (Buffer_Offset+5<=Buffer_Size        && CC4(Buffer+Buffer_Offset)!=0x42424344)  //"BBCD"        Buffer_Offset++;    if (Buffer_Offset+5>Buffer_Size)    {        //Parsing last bytes        if (Buffer_Offset+4==Buffer_Size)        {            if (CC4(Buffer+Buffer_Offset)!=0x42424344)            {                Buffer_Offset++;                if (CC3(Buffer+Buffer_Offset)!=0x424243)                {                    Buffer_Offset++;                    if (CC2(Buffer+Buffer_Offset)!=0x4242)                    {                        Buffer_Offset++;                        if (CC1(Buffer+Buffer_Offset)!=0x42)                            Buffer_Offset++;                    }                }            }        }        return false;    }    //Synched is OK    Synched=true;    return true;}

//---------------------------------------------------------------------------void File_Aac::Read_Buffer_Continue (){    //Tags    if (File_Offset==0)    {        if (!Skip_ID3v2())            return;    }    //Parsing headers    if (Buffer_Size<=8)                                  ES();   //AAC in ES (.MP4)    else if (CC4(Buffer)==CC4("ADIF"))                   ADIF(); //ADIF header    else if ((CC2(Buffer+Buffer_Offset)&0xFFF6)==0xFFF0) ADTS(); //ADTS header (12 bits + ID + 2 bits)    else if (CC3(Buffer)==CC3("AAC"))                    AAC();  //AAC header    //No need of more    File_Offset=File_Size;    //Tags    #if defined(MEDIAINFO_ID3_YES)        /*        File_Id3 Id3;        if (Id3.Open(CompleteFileName)<0)            Id3.Open(Buffer, Id3v2_Size);        Merge(Id3);        */    #endif //ID3}

//---------------------------------------------------------------------------bool File_Wvpk::Header_Begin(){    //Specific cases    if (FromMKV)        return true;            if (!File__Tags_Helper::Header_Begin())        return false;    //Must have enough buffer for having header    if (Buffer_Offset+4>Buffer_Size)        return false;    //Quick test of synchro    if (Synched && CC4(Buffer+Buffer_Offset)!=CC4("wvpk"))    {        Trusted_IsNot("WavPack, Synchronisation lost");        Synched=false;    }    //Synchro    if (!Synched && !Synchronize())        return false;    return true;}

//---------------------------------------------------------------------------void File_Jpeg::APP0(){    //Parsing    int32u Name;    Get_C4(Name,                                                "Name");    if (Name==CC4("AVI1"))        APP0_AVI1();    if (Name==CC4("JFIF"))        APP0_JFIF();    if (Name==CC4("JFFF"))        APP0_JFXX();}

//---------------------------------------------------------------------------bool File_Tiff::FileHeader_Begin(){    //Element_Size    if (Buffer_Size<4)        return false; //Must wait for more data    if (CC4(Buffer)!=0x49492A00 && CC4(Buffer)!=0x4D4D002A)    {        Reject("TIFF");        return false;    }    //All should be OK...    return true;}

//---------------------------------------------------------------------------bool File_Wvpk::Synchronize(){    //Specific case    if (FromMKV)        return true;    //Tags    bool Tag_Found;    if (!File__Tags_Helper::Synchronize(Tag_Found))        return false;    if (Tag_Found)        return true;    //Synchronizing    while (Buffer_Offset+8<=Buffer_Size)    {        while (Buffer_Offset+8<=Buffer_Size            && CC4(Buffer+Buffer_Offset)!=CC4("wvpk"))        {            Buffer_Offset++;        }        if (Buffer_Offset+8<=Buffer_Size)//Testing if size is coherant        {            //Testing next start, to be sure            size_t Size=LittleEndian2int32u(Buffer+Buffer_Offset+4)+8;            if (Buffer_Offset+Size+8>Buffer_Size)                return false; //Need more data            //Testing            if (CC4(Buffer+Buffer_Offset+Size)!=CC4("wvpk"))                Buffer_Offset++;            else                break; //while()        }    }    //Parsing last bytes if needed    if (Buffer_Offset+8>Buffer_Size)    {        if (Buffer_Offset+7==Buffer_Size && CC4(Buffer+Buffer_Offset)!=0x7776706B) //"wvpk"            Buffer_Offset++;        if (Buffer_Offset+6==Buffer_Size && CC4(Buffer+Buffer_Offset)!=0x7776706B) //"wvpk"            Buffer_Offset++;        if (Buffer_Offset+5==Buffer_Size && CC4(Buffer+Buffer_Offset)!=0x7776706B) //"wvpk"            Buffer_Offset++;        if (Buffer_Offset+4==Buffer_Size && CC4(Buffer+Buffer_Offset)!=0x7776706B) //"wvpk"            Buffer_Offset++;        if (Buffer_Offset+3==Buffer_Size && CC3(Buffer+Buffer_Offset)!=0x777670)   //"wv"            Buffer_Offset++;        if (Buffer_Offset+2==Buffer_Size && CC2(Buffer+Buffer_Offset)!=0x7776)     //"wv"            Buffer_Offset++;        if (Buffer_Offset+1==Buffer_Size && CC1(Buffer+Buffer_Offset)!=0x77)       //"w"            Buffer_Offset++;        return false;    }    //Synched is OK    return true;}

//---------------------------------------------------------------------------bool File_Png::FileHeader_Begin(){    //Element_Size    if (Buffer_Size<8)        return false; //Must wait for more data    if (CC4(Buffer+4)!=0x0D0A1A0A) //Byte order    {        Reject("PNG");        return false;    }    switch (CC4(Buffer)) //Signature    {        case 0x89504E47 :            Accept("PNG");            Fill(Stream_General, 0, General_Format, "PNG");            Fill(StreamKind_Last, 0, Fill_Parameter(StreamKind_Last, Generic_Format), "PNG");            Fill(StreamKind_Last, 0, Fill_Parameter(StreamKind_Last, Generic_Codec), "PNG");            break;        case 0x8A4E4E47 :            Accept("PNG");            Fill(Stream_General, 0, General_Format, "MNG");            Fill(StreamKind_Last, 0, Fill_Parameter(StreamKind_Last, Generic_Format), "MNG");            Fill(StreamKind_Last, 0, Fill_Parameter(StreamKind_Last, Generic_Codec), "MNG");            Finish("PNG");            break;        case 0x8B4A4E47 :            Accept("PNG");            Fill(Stream_General, 0, General_Format, "JNG");            Fill(StreamKind_Last, 0, Fill_Parameter(StreamKind_Last, Generic_Format), "JNG");            Fill(StreamKind_Last, 0, Fill_Parameter(StreamKind_Last, Generic_Codec), "JNG");            Finish("PNG");            break;        default:            Reject("PNG");    }    //All should be OK...    return true;}

//---------------------------------------------------------------------------bool File_Cdxa::Synchronize(){    //Synchronizing    while (           Buffer_Offset+2352*3+12<=Buffer_Size      && !(CC8(Buffer+Buffer_Offset+2352*0)==0x00FFFFFFFFFFFFFFLL && CC4(Buffer+Buffer_Offset+2352*0+8)==0xFFFFFF00        && CC8(Buffer+Buffer_Offset+2352*1)==0x00FFFFFFFFFFFFFFLL && CC4(Buffer+Buffer_Offset+2352*1+8)==0xFFFFFF00        && CC8(Buffer+Buffer_Offset+2352*2)==0x00FFFFFFFFFFFFFFLL && CC4(Buffer+Buffer_Offset+2352*2+8)==0xFFFFFF00        && CC8(Buffer+Buffer_Offset+2352*3)==0x00FFFFFFFFFFFFFFLL && CC4(Buffer+Buffer_Offset+2352*3+8)==0xFFFFFF00))        Buffer_Offset++;    if (Buffer_Offset+2352*3+12>Buffer_Size)        return false;    //Synched is OK    return true;}

//---------------------------------------------------------------------------bool File_Dirac::Synchronize(){    //Synchronizing    while (Buffer_Offset+5<=Buffer_Size        && CC4(Buffer+Buffer_Offset)!=0x42424344)  //"BBCD"        Buffer_Offset++;    if (Buffer_Offset+5>Buffer_Size)    {        //Parsing last bytes        if (Buffer_Offset+4==Buffer_Size)        {            if (CC4(Buffer+Buffer_Offset)!=0x42424344)            {                Buffer_Offset++;                if (CC3(Buffer+Buffer_Offset)!=0x424243)                {                    Buffer_Offset++;                    if (CC2(Buffer+Buffer_Offset)!=0x4242)                    {                        Buffer_Offset++;                        if (CC1(Buffer+Buffer_Offset)!=0x42)                            Buffer_Offset++;                    }                }            }        }        return false;    }    //Synched is OK    Synched=true;    if (Streams.empty())    {        //Count of a Packets        Frame_Count=0;        //Temp        Dirac_base_video_format((int32u)-1, frame_width, frame_height, chroma_format, source_sampling,                                clean_width, clean_height, clean_left_offset, clean_top_offset,                                frame_rate, pixel_aspect_ratio);        //Default stream values        Streams.resize(0x100);        Streams[0x00].Searching_Payload=true; //Sequence header    }    return true;}

//---------------------------------------------------------------------------bool File_Aac::FileHeader_Begin(){    switch(Mode)    {        case Mode_AudioSpecificConfig :        case Mode_ADIF                :                                        MustSynchronize=false; break;        default                       : ; //Synchronization is requested, and this is the default    }    switch(Mode)    {        case Mode_Unknown             :        case Mode_ADIF                :        case Mode_ADTS                :                                        break;        default                       : return true; //no file header test with other modes    }    //Tags    if (!File__Tags_Helper::FileHeader_Begin())        return false;    //Testing    if (Buffer_Offset+4>Buffer_Size)        return false;    if (CC4(Buffer+Buffer_Offset)==0x41444946) //"ADIF"    {        Mode=Mode_ADIF;        File__Tags_Helper::Accept("ADIF");        MustSynchronize=false;    }    return true;}

//---------------------------------------------------------------------------bool File_Dts::Header_Begin(){    //Must have enough buffer for having header    if (Buffer_Offset+4>Buffer_Size)        return false;    //DTS-HD: Saving offset    size_t DTS_HD_Offset=Buffer_Offset;    //Quick test of synchro    if (Synched && CC4(Buffer+Buffer_Offset)!=SyncCode)    {        Info("DTS, Synchronisation lost"); //Should not //TODO: find a better way to detect DTS        Synched=false;    }    //Synchro    if (!Synched && !Synchronize())        return false;    //DTS-HD: Saving difference    if (Buffer_Offset-DTS_HD_Offset && Frame_Count>0)        DTS_HD_Unknown_Size=Buffer_Offset-DTS_HD_Offset;    //All should be OK...    return true;}

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

//---------------------------------------------------------------------------bool File_Dts::Detect_NonDTS (){    //Element_Size    if (Buffer_Size<4)        return true; //Must wait for more data    //Detect WAV files, the parser can't detect it easily, there is only 70 bytes of begining for sayint WAV    if (CC4(Buffer)==CC4("RIFF"))    {        Finnished();        return true;    }    //Seems OK    return false;}

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

//---------------------------------------------------------------------------bool File_Ivf::FileHeader_Begin(){    //Synchro    if (Buffer_Offset+4>Buffer_Size)        return false;    if (CC4(Buffer+Buffer_Offset)!=0x444B4946) //"DKIF"        return false;    return true;}

//---------------------------------------------------------------------------bool File_Ogg::Synchronize(){    //Synchronizing    while (Buffer_Offset+4<=Buffer_Size)    {        while(Buffer_Offset+4<=Buffer_Size && (Buffer[Buffer_Offset  ]!=0x4F                                            || Buffer[Buffer_Offset+1]!=0x67                                            || Buffer[Buffer_Offset+2]!=0x67                                            || Buffer[Buffer_Offset+3]!=0x53)) //"OggS"        {            Buffer_Offset+=1+2;            while(Buffer_Offset<Buffer_Size && Buffer[Buffer_Offset]!=0x67)                Buffer_Offset+=2;            if (Buffer_Offset>=Buffer_Size || Buffer[Buffer_Offset-1]==0x67)                Buffer_Offset--;            Buffer_Offset--;        }        if (Buffer_Offset+4<=Buffer_Size) //Testing if size is coherant        {            //Retrieving some info            if (Buffer_Offset+27>Buffer_Size)                return false; //Need more data            int8u page_segments=CC1(Buffer+Buffer_Offset+26);            if (Buffer_Offset+27+page_segments>Buffer_Size)                return false; //Need more data            size_t Size=0;            for (int8u Pos=0; Pos<page_segments; Pos++)                Size+=CC1(Buffer+Buffer_Offset+27+Pos);            //Testing            if (Buffer_Offset+27+page_segments+Size+4>Buffer_Size)                return false; //Need more data            if (CC4(Buffer+Buffer_Offset+27+page_segments+Size)!=0x4F676753) //"OggS"                Buffer_Offset++;            else                break;        }    }    //Parsing last bytes if needed    if (Buffer_Offset+4>Buffer_Size)    {        if (Buffer_Offset+3==Buffer_Size && CC3(Buffer+Buffer_Offset)!=0x4F6767) //"Ogg"            Buffer_Offset++;        if (Buffer_Offset+2==Buffer_Size && CC2(Buffer+Buffer_Offset)!=0x4F67)   //"Og"            Buffer_Offset++;        if (Buffer_Offset+1==Buffer_Size && CC1(Buffer+Buffer_Offset)!=0x4F)     //"O"            Buffer_Offset++;        return false;    }    //Synched is OK    return true;}

//---------------------------------------------------------------------------void File_Rar::Read_Buffer_Continue(){    //Integrity    if (Buffer_Size<=4)        return;    //Header    if (CC4(Buffer)!=CC4("RAR!"))    {        File_Offset=File_Size;        return;    }    //Filling    Stream_Prepare(Stream_General);    Fill("Format", "RAR");    //No need of more    File_Offset=File_Size;}

//---------------------------------------------------------------------------bool File_Dpx::FileHeader_Begin(){    //Element_Size    if (Buffer_Size<4)        return false; //Must wait for more data    int32u Magic=CC4(Buffer);    switch (Magic)    {        case 0x802A5FD7 :   //       (Cineon Big)        case 0xD75F2A80 :   //       (Cineon Little)        case 0x53445058 :   //"SPDX" (Dpx Big)        case 0x58504453 :   //"XDPS" (Dpx Little)                            break;        default         :                            Reject();                            return false;    }    //Generic Section size    if (Buffer_Size<28)        return false; //Must wait for more data    Sizes_Pos=Pos_GenericSection;    switch (Magic)    {        case 0x802A5FD7 :   //       (Cineon Big)        case 0xD75F2A80 :   //       (Cineon Little)                            IsDpx=false;                            break;        case 0x58504453 :   //"XDPS" (Dpx Little)        case 0x53445058 :   //"SPDX" (Dpx Big)                            IsDpx=true;                            break;        default         :   ;    }    switch (Magic)    {        case 0xD75F2A80 :   //       (Cineon Little)        case 0x58504453 :   //"XDPS" (Dpx Little)                            LittleEndian=true;                            break;        case 0x802A5FD7 :   //       (Cineon Big)        case 0x53445058 :   //"SPDX" (Dpx Big)                            LittleEndian=false;                            break;        default         :   ;    }    //All should be OK...    Accept();    return true;}

//---------------------------------------------------------------------------bool File_Wvpk::Synched_Test(){    //Specific case    if (FromMKV)        return true;    //Tags    if (!File__Tags_Helper::Synched_Test())        return false;    //Must have enough buffer for having header    if (Buffer_Offset+3>Buffer_Size)        return false;    //Quick test of synchro    if (CC4(Buffer+Buffer_Offset)!=CC4("wvpk"))        Synched=false;    //We continue    return true;}

//---------------------------------------------------------------------------bool File_Cdxa::FileHeader_Begin(){    //Element_Size    if (Buffer_Size<0x28)        return false; //Must wait for more data    if (                CC4(Buffer+0x00)!=0x52494646  //"RIFF"     || LittleEndian2int32u(Buffer+0x04)!=LittleEndian2int32u(Buffer+0x28)+0x24 //Sizes of chunks     ||                 CC4(Buffer+0x08)!=0x43445841  //"CDXA"     ||                 CC4(Buffer+0x0C)!=0x666D7420  //"fmt "     || LittleEndian2int32u(Buffer+0x10)!=0x10     ||                 CC2(Buffer+0x1A)!=0x5841      //"XA"     ||                 CC4(Buffer+0x24)!=0x64617461) //"data"    {        Reject("CDXA");        return false;    }    //All should be OK...    return true;}

//---------------------------------------------------------------------------bool File_Exr::Header_Begin(){    //Header    if (Buffer_Offset+4>Buffer_Size)        return false;    if (CC4(Buffer+Buffer_Offset)==0x762F3101) //"v/1"+1        return Buffer_Offset+12<=Buffer_Size;    //Name    name_End=0;    while (Buffer_Offset+name_End<Buffer_Size)    {        if (Buffer[Buffer_Offset+name_End]=='/0')            break;        if (name_End==31)            break;        name_End++;    }    if (Buffer_Offset+name_End>=Buffer_Size)        return false;    if (name_End>=31)    {        Reject();        return false;    }    if (name_End==0)        return true;    //Type    type_End=0;    while (Buffer_Offset+name_End+1+type_End<Buffer_Size)    {        if (Buffer[Buffer_Offset+name_End+1+type_End]=='/0')            break;        if (type_End==31)            break;        type_End++;    }    if (Buffer_Offset+name_End+1+type_End>=Buffer_Size)        return false;    if (type_End>=31)    {        Reject();        return false;    }    if (Buffer_Offset+name_End+1+type_End+1+4>=Buffer_Size)        return false;    return true;}

//---------------------------------------------------------------------------bool File_Cdxa::Synched_Test(){    //Must have enough buffer for having header    if (Buffer_Offset+12>Buffer_Size)        return false;    //Quick test of synchro    if (!(CC8(Buffer+Buffer_Offset)==0x00FFFFFFFFFFFFFFLL && CC4(Buffer+Buffer_Offset+8)==0xFFFFFF00))        Synched=false;    //We continue    return true;}

//---------------------------------------------------------------------------bool File_Ogg::Header_Begin(){    //Synchro    if (!Synched && !Synchronize())        return false;    //Quick test of synchro    if (CC4(Buffer+Buffer_Offset)!=Ogg::OggS && !Synchronize())        return false;    //All should be OK...    return true;}

//---------------------------------------------------------------------------bool File_Ogg::Synched_Test(){    //Must have enough buffer for having header    if (Buffer_Offset+4>Buffer_Size)        return false;    //Quick test of synchro    if (CC4(Buffer+Buffer_Offset)!=0x4F676753) //"OggS"        Synched=false;    //We continue    return true;}

//---------------------------------------------------------------------------bool File_TwinVQ::FileHeader_Begin(){    //Testing    if (Buffer_Offset+4>Buffer_Size)        return false;    if (CC4(Buffer+Buffer_Offset)!=0x5457494E) //"TWIN"    {        Reject("TwinVQ");        return false;    }    //All should be OK...    return true;}

//---------------------------------------------------------------------------bool File_Ogg::Synchronize(){    //Look for first Sync word    if (Buffer_Offset_Temp==0) //Buffer_Offset_Temp is not 0 if Synchronize() has already parsed first bytes        Buffer_Offset_Temp=Buffer_Offset;    while (Buffer_Offset_Temp+4<=Buffer_Size        && CC4(Buffer+Buffer_Offset_Temp)!=Ogg::OggS)        Buffer_Offset_Temp++;    //Not synched case    if (!Synched && Buffer_Offset_Temp+4>Buffer_Size)    {        if (Buffer_Offset_Temp+3==Buffer_Size)        {            if (CC3(Buffer+Buffer_Offset_Temp)!=CC3("Ogg"))            {                Buffer_Offset_Temp++;                if (CC2(Buffer+Buffer_Offset_Temp)!=CC2("Og"))                {                    Buffer_Offset_Temp++;                    if (CC1(Buffer+Buffer_Offset_Temp)!=CC1("O"))                        Buffer_Offset_Temp++;                }            }        }        Buffer_Offset=Buffer_Offset_Temp;        Buffer_Offset_Temp=0;        return false;    }    //Must wait more data?    if (Buffer_Offset_Temp+4>Buffer_Size)        return false;    //Error in stream?    if (Buffer_Offset_Temp-Buffer_Offset>0)    {        if (Synched)            Trusted_IsNot("Sync error");        else            Info("Synchronization");    }    //OK, we continue    Buffer_Offset=Buffer_Offset_Temp;    Buffer_Offset_Temp=0;    Synched=true;    return true;}

//---------------------------------------------------------------------------bool File_Elf::FileHeader_Begin(){    //Element_Size    if (Buffer_Size<4)        return false; //Must wait for more data    if (CC4(Buffer)!=0x7F454C46) //".ELF"    {        Reject("ELF");        return false;    }    //All should be OK...    return true;}

//---------------------------------------------------------------------------bool File_MpcSv8::FileHeader_Begin(){    //Element_Size    if (Buffer_Size<4)        return false; //Must wait for more data    if (CC4(Buffer)!=0x4D50434B) //"MPCK"    {        File__Tags_Helper::Reject("Musepack SV8");        return false;    }    //All should be OK...    return true;}