Example #1
0
//---------------------------------------------------------------------------
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");
        }
    }
}
Example #2
0
//---------------------------------------------------------------------------
void File_Ogg::Data_Parse()
{
    //Counting
    Frame_Count++;

    //If first chunk of a stream
    stream& Stream_Item=Stream[Element_Code]; //[+] FlylinkDC++ Team
    if (Stream_Item.Parser==NULL)
    {
        if (Parsing_End)
            return; //Maybe multitracks concatained, not supported
        Stream_Item.Parser=new File_Ogg_SubElement;
        Open_Buffer_Init(Stream_Item.Parser);
        ((File_Ogg_SubElement*)Stream_Item.Parser)->InAnotherContainer=IsSub;
        StreamsToDo++;
    }
    ((File_Ogg_SubElement*)Stream_Item.Parser)->MultipleStreams=Stream.size()>1; //has no sens for the first init, must check allways

    //Parsing
    File_Ogg_SubElement* Parser=(File_Ogg_SubElement*)Stream_Item.Parser;
    if (Stream_Item.SearchingPayload)
        //For each chunk
        for (size_t Chunk_Sizes_Pos=0; Chunk_Sizes_Pos<Chunk_Sizes.size(); Chunk_Sizes_Pos++)
        {
            //Info
            if (!continued)
                Peek_L1(packet_type); //Only for information
            Element_Info1(Ztring::ToZtring(packet_type, 16));
            Element_Info1C((continued), "Continue");

            //Parsing
            if (continued || Parser->File_Offset!=Parser->File_Size)
                Open_Buffer_Continue(Parser, Buffer+Buffer_Offset+(size_t)Element_Offset, Chunk_Sizes[Chunk_Sizes_Pos]);
            if (Chunk_Sizes_Pos<Chunk_Sizes.size()-1
             || (Chunk_Sizes_Pos==Chunk_Sizes.size()-1 && Chunk_Sizes_Finished))
            {
                Open_Buffer_Continue(Parser, Buffer+Buffer_Offset, 0); //Purge old datas
            }

            Element_Offset+=Chunk_Sizes[Chunk_Sizes_Pos];
            continued=false; //If there is another chunk, this can not be a continued chunk
            if (Parser->File_GoTo!=(int64u)-1)
                Chunk_Sizes_Pos=Chunk_Sizes.size();

            if (!Status[IsAccepted] && Parser->Status[IsAccepted])
                Accept("OGG");
            if (Parser->Status[IsFinished] || (Element_Offset==Element_Size && eos))
            {
                StreamsToDo--;
                Stream_Item.SearchingPayload=false;
                break;
            }
        }
    else
        Skip_XX(Element_Size,                                   "Data");

    //End of stream
    if (!Parsing_End &&
        (StreamsToDo==0 || File_Offset+Buffer_Offset+Element_Offset>256*1024))
    {
        if (IsSub)
            Finish("OGG");
        else
            GoToFromEnd(256*1024, "OGG");
        std::map<int64u, stream>::iterator Stream_Temp=Stream.begin();
        if (File_GoTo!=(int64u)-1)
            while (Stream_Temp!=Stream.end())
            {
                Stream_Temp->second.absolute_granule_position=0;
                ++Stream_Temp;
            }
        Parsing_End=true;
    }

    Element_Show();
}
Example #3
0
//---------------------------------------------------------------------------
void File_Ogg::Data_Parse()
{
    //If first chunk of a stream
    if (Stream[Element_Code].Parser==NULL)
    {
        Stream[Element_Code].Parser=new File_Ogg_SubElement;
        StreamsToDo++;
    }

    //Parsing
    File_Ogg_SubElement* Parser=(File_Ogg_SubElement*)Stream[Element_Code].Parser;
    if (!Parser->SetupFinnished)
        //For each chunk
        for (size_t Chunk_Sizes_Pos=0; Chunk_Sizes_Pos<Chunk_Sizes.size(); Chunk_Sizes_Pos++)
        {
            //Info
            if (!continued)
                Peek_L1(packet_type); //Only for information
            Element_Info(Ztring::ToZtring(packet_type, 16));
            if (continued)
                Element_Info("Continue");

            //Parsing
            Open_Buffer_Init(Parser, File_Size, File_Offset+Buffer_Offset);
            if (continued || Parser->File_Offset!=Parser->File_Size)
                Open_Buffer_Continue(Parser, Buffer+Buffer_Offset+Element_Offset, Chunk_Sizes[Chunk_Sizes_Pos]);
            if (Chunk_Sizes_Pos<Chunk_Sizes.size()-1
             || (Chunk_Sizes_Pos==Chunk_Sizes.size()-1 && Chunk_Sizes_Finnished))
                Open_Buffer_Continue(Parser, Buffer+Buffer_Offset, 0); //Purge old datas

            if (Parser->SetupFinnished)
            {
                Merge(*Parser);
                Merge(*Parser, Stream_General, 0, 0);
                Stream[Element_Code].StreamKind=((File_Ogg_SubElement*)Parser)->StreamKind;
                Stream[Element_Code].StreamPos=Count_Get(Stream[Element_Code].StreamKind)-1;
                Stream[Element_Code].absolute_granule_position_Resolution=((File_Ogg_SubElement*)Stream[Element_Code].Parser)->absolute_granule_position_Resolution;
                StreamsToDo--;
            }

            Element_Offset+=Chunk_Sizes[Chunk_Sizes_Pos];
            continued=false; //If there is another chunk, this can not be a continued chunk
            if (Parser->SetupFinnished)
                Chunk_Sizes_Pos=Chunk_Sizes.size();
        }

    //End of stream
    if (!Parsing_End && File_Size>2*256*1024 &&
        (StreamsToDo==0 || File_Offset+Buffer_Offset+Element_Offset>256*1024))
    {
        Info("OGG, Jumping to end of file");
        File_GoTo=File_Size-256*1024;
        std::map<int64u, stream>::iterator Stream_Temp=Stream.begin();
        while (Stream_Temp!=Stream.end())
        {
            Stream_Temp->second.absolute_granule_position=0;
            Stream_Temp++;
        }
        Parsing_End=true;
    }
}