//---------------------------------------------------------------------------
void File_Pdf::xref()
{
//Parsing
Element_Begin1("Cross-Reference Table");
Element_Begin1("Cross-Reference Section");
string FirstLine;
Skip_String(SizeOfLine(), "Object name");
Element_Begin1("Cross-Reference SubSection");
Get_String(SizeOfLine(), FirstLine, "Header");
size_t FirstLine_Space=FirstLine.find(' ');
int32u Base=atoi((const char*)FirstLine.c_str());
int32u Count=0;
if (FirstLine_Space!=string::npos)
Count=atoi((const char*)FirstLine.c_str()+FirstLine_Space+1);
if (0x10000+20*Count>Buffer_Size && File_Offset+Buffer_Size<File_Size)
{
// We wait for more data
Buffer_Offset=0;
Element_Offset=0;
Element_DoNotShow();
Element_End0();
Element_End0();
Element_End0();
Element_WaitForMoreData();
return;
}
while (Element_Offset<Element_Size && (Buffer[Buffer_Offset+(size_t)Element_Offset]=='\r' || Buffer[Buffer_Offset+(size_t)Element_Offset]=='\n'))
Element_Offset++;
const int8u* Buffer_Temp=Buffer+Buffer_Offset+(size_t)Element_Offset+17;
for (int32u Pos=0; Pos<Count; ++Pos)
{
if (*Buffer_Temp=='n')
{
int32u Offset=(int32u)atoi((const char*)(Buffer_Temp-17));
Objects[Base+Pos].Offset=Offset;
//Offsets[Offset]=Base+Pos;
Offsets.push_back(Offset);
}
Buffer_Temp+=20;
if (Pos>100)
Element_Offset+=20;
else
{
Skip_String(18, "Entry"); Param_Info1(Base+Pos);
Element_Offset+=2; //Skipping spaces at end and line return
}
}
Element_End0();
Element_End0();
Element_End0();
if (File_Offset+Buffer_Offset>Offsets_Max)
Offsets_Max=(int32u)(File_Offset+Buffer_Offset);
}
//---------------------------------------------------------------------------
void File_Caf::Data_Parse()
{
if (Element_Code!=Elements::data && !Element_IsComplete_Get())
{
Element_WaitForMoreData();
return;
}
#define ELEMENT_CASE(_NAME, _DETAIL) \
case Elements::_NAME : Element_Name(_DETAIL); _NAME(); break;
//Parsing
switch (Element_Code)
{
ELEMENT_CASE(data, "Audio Data");
ELEMENT_CASE(desc, "Audio Description");
ELEMENT_CASE(free, "Free");
ELEMENT_CASE(info, "Information");
ELEMENT_CASE(kuki, "Magic Cookie");
ELEMENT_CASE(pakt, "Packet Table");
ELEMENT_CASE(uuid, "User-Defined Chunk");
default :
Skip_XX(Element_Size, "Data");
}
}
//---------------------------------------------------------------------------
void File_AvsV::Header_Parse()
{
//Parsing
int8u start_code;
Skip_B3( "synchro");
Get_B1 (start_code, "start_code");
if (!Header_Parser_Fill_Size())
{
Element_WaitForMoreData();
return;
}
//Filling
Header_Fill_Code(start_code, Ztring().From_CC1(start_code));
}
//---------------------------------------------------------------------------
void File_SubRip::Read_Buffer_Continue()
{
if (!IsSub && (Buffer_Size<File_Size && Buffer_Size<65536))
{
Element_WaitForMoreData();
return;
}
ZtringListList Temp;
Temp.Separator_Set(0, __T("\r\n\r\n"));
Temp.Separator_Set(1, __T("\r\n"));
Temp.Write(Ztring().From_UTF8((const char*)Buffer, Buffer_Size>65536?65536:Buffer_Size));
if (Temp.empty())
Temp.Write(Ztring().From_Local((const char*)Buffer, Buffer_Size>65536?65536:Buffer_Size)); // Trying from local code page
size_t IsOk=0;
size_t IsNok=0;
for (size_t Pos=0; Pos<Temp.size(); Pos++)
{
if (Temp(Pos, 0).To_int64u()==Pos+1)
IsOk++;
else
IsNok++;
if (Temp(Pos, 1).size()>22 && Temp(Pos, 1)[2]==__T(':') && Temp(Pos, 1)[5]==__T(':') && Temp(Pos, 1).find(__T(" --> "))!=string::npos)
IsOk++;
else
IsNok++;
}
if (!IsOk || IsNok>IsOk/2)
{
Reject();
return;
}
if (!Status[IsAccepted])
{
Accept();
Fill(Stream_General, 0, General_Format, "SubRip");
Stream_Prepare(Stream_Text);
Fill(Stream_Text, 0, "Format", "SubRip");
Fill(Stream_Text, 0, "Codec", "SubRip");
}
Element_Offset=File_Size;
}
//---------------------------------------------------------------------------
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_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_Pdf::Header_Parse()
{
offsets::iterator Offsets_Next=upper_bound(Offsets.begin(), Offsets.end(), (int32u)(File_Offset+Buffer_Offset));
if (Offsets_Next!=Offsets.end() && *Offsets_Next>File_Offset+Buffer_Size)
{
Element_WaitForMoreData();
return;
}
int64u Size;
//if (Offsets_Current==Offsets.end())
// Size=Offsets_Max-(File_Offset+Buffer_Offset);
//else
// Size=Offsets_Current->first-(File_Offset+Buffer_Offset);
if (Offsets_Next==Offsets.end())
Size=Offsets_Max-(File_Offset+Buffer_Offset);
else
Size=*Offsets_Next-(File_Offset+Buffer_Offset);
Header_Fill_Size(Size);
}
//---------------------------------------------------------------------------
void File_Jpeg::Header_Parse()
{
if (SOS_SOD_Parsed)
{
Header_Fill_Code(0, "Data");
if (!Header_Parser_Fill_Size())
{
Element_WaitForMoreData();
return;
}
return;
}
//Parsing
int16u code, size;
Get_B2 (code, "Marker");
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::SOC :
case Elements::SOD :
case Elements::SOI :
case Elements::EOI :
size=0; break;
default : Get_B2 (size, "Fl - Frame header length");
}
//Filling
Header_Fill_Code(code, Ztring().From_CC2(code));
Header_Fill_Size(2+size);
}
//---------------------------------------------------------------------------
void File_Pdf::eof()
{
if (File_Size!=(int64u)-1 && File_Offset+Buffer_Size<File_Size)
{
Element_WaitForMoreData();
return;
}
//We need to find the exact begin
Buffer_Offset=Buffer_Size-1;
while (Buffer_Offset && (Buffer[Buffer_Offset]=='\r' || Buffer[Buffer_Offset]=='\n'))
Buffer_Offset--;
Buffer_Offset-=5;
//Parsing
Element_Begin1("End Of File");
Skip_String(SizeOfLine(), "Object name");
Element_End0();
}
//---------------------------------------------------------------------------
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);
}
//---------------------------------------------------------------------------
void File_ApeTag::Header_Parse()
{
//Testing if begin or end of tags
if (CC8(Buffer+Buffer_Offset)==0x4150455441474558LL) //"APETAGEX"
{
//Filling
Header_Fill_Code((int64u)-1, "File Footer");
Header_Fill_Size(0x20);
return;
}
//Parsing
Ztring Value;
int32u Flags, Length;
Get_L4 (Length, "Length");
Get_L4 (Flags, "Flags");
Skip_Flags(Flags, 0, "Read Only");
Skip_Flags(Flags, 1, "Binary");
Skip_Flags(Flags, 2, "Locator of external stored information");
Skip_Flags(Flags, 29, "Is the header");
Skip_Flags(Flags, 30, "Contains a footer");
Skip_Flags(Flags, 31, "Contains a header");
size_t Pos=(size_t)Element_Offset;
for (; Pos<Element_Size; Pos++)
if (Buffer[Buffer_Offset+Pos]==0x00)
break;
if (Pos==Element_Size)
{
Element_WaitForMoreData();
return;
}
Get_String(Pos-Element_Offset, Key, "Key");
Skip_L1( "0x00");
//Filling
Header_Fill_Code(0, Key.c_str());
Header_Fill_Size(Element_Offset+Length);
}
//---------------------------------------------------------------------------
void File_Pdf::FileHeader_Parse()
{
string PdfHeader;
Get_String(SizeOfLine(), PdfHeader, "Header");
for (;;)
{
int64u CommentSize=SizeOfLine();
if (Buffer_Offset+Element_Offset>=Buffer_Size)
{
Element_WaitForMoreData();
return;
}
if (Buffer[Buffer_Offset+Element_Offset]!='%')
break;
Skip_String(CommentSize, "Comment");
}
//Filling
Fill(Stream_General, 0, General_Format_Version, PdfHeader.substr(5));
GoToFromEnd(9+2+10+2+5+2); // "startxref" + EOL + 10max digits + EOL + "%%EOF" + EOL
State=State_Parsing_startxref;
}
//---------------------------------------------------------------------------
void File_Vc1::Header_Parse()
{
//Specific
if (From_WMV3 || Only_0D)
{
Header_Fill_Size(Buffer_Size);
Header_Fill_Code(From_WMV3?0x0F:0x0D, Ztring().From_CC1(From_WMV3?0x0F:0x0D));
return;
}
//Parsing
int8u start_code;
Skip_B3( "synchro");
Get_B1 (start_code, "start_code");
if (!Header_Parser_Fill_Size())
{
Element_WaitForMoreData();
return;
}
//Filling
Header_Fill_Code(start_code, Ztring().From_CC1(start_code));
}
void File_OtherText::Read_Buffer_Continue()
{
if (Buffer_Size<0x200)
{
Element_WaitForMoreData();
return;
}
Element_Offset=File_Size-(File_Offset+Buffer_Offset);
Ztring Format, FormatMore, Codec;
Ztring File;
ZtringList Lines;
//Feed File and Lines
File.From_UTF8((const char*)Buffer, Buffer_Size>65536?65536:Buffer_Size);
if (File.empty())
File.From_Local((const char*)Buffer, Buffer_Size>65536?65536:Buffer_Size); // Trying from local code page
if (File.size()<0x100)
{
File.From_Unicode((wchar_t*)Buffer, 0, Buffer_Size/sizeof(wchar_t)); //Unicode with BOM
//TODO: Order of bytes (big or Little endian)
if (File.size()<0x100)
{
Reject("Other text");
return;
}
}
if (File.size()>0x1000)
File.resize(0x1000); //Do not work on too big
File.FindAndReplace(__T("\r\n"), __T("\n"), 0, Ztring_Recursive);
File.FindAndReplace(__T("\r"), __T("\n"), 0, Ztring_Recursive);
Lines.Separator_Set(0, __T("\n"));
Lines.Write(File);
Lines.resize(0x20);
if (Lines[0]==__T("[Script Info]")
&& (Lines.Find(__T("ScriptType: v4.00"))!=Error || Lines.Find(__T("Script Type: V4.00"))!=Error)
&& Lines.Find(__T("[V4 Styles]"))!=Error
)
{
Format=__T("SSA");
FormatMore=__T("SubStation Alpha");
Codec=__T("SSA");
}
else if (Lines[0]==__T("[Script Info]")
&& (Lines.Find(__T("ScriptType: v4.00+"))!=Error || Lines.Find(__T("Script Type: V4.00+"))!=Error)
&& Lines.Find(__T("[V4+ Styles]"))!=Error
)
{
Format=__T("ASS");
FormatMore=__T("Advanced SubStation Alpha");
Codec=__T("ASS");
}
else if (Lines[0].size()>24
&& Lines[0][ 0]==__T('0') && Lines[0][ 1]==__T('0')
&& Lines[0][ 2]==__T(':') && Lines[0][ 5]==__T(':') && Lines[0][ 8]==__T(':')
&& Lines[0][11]==__T(' ')
&& Lines[0][12]==__T('0') && Lines[0][13]==__T('0')
&& Lines[0][14]==__T(':') && Lines[0][17]==__T(':') && Lines[0][20]==__T(':')
&& Lines[0][23]==__T(' ')
)
{
Format=__T("Adobe encore DVD");
Codec=__T("Adobe");
}
else if (Lines[0].size()==11
&& Lines[0][0]==__T('-') && Lines[0][1]==__T('-') && Lines[0][2]==__T('>') && Lines[0][3]==__T('>') && Lines[0][4]==__T(' ')
&& Lines[0][5]==__T('0')
&& Lines[1].empty()!=true
)
{
Format=__T("AQTitle");
Codec=__T("AQTitle");
}
else if (Lines[0].size()>28
&& Lines[0][ 0]==__T('0') && Lines[0][ 1]==__T('0')
&& Lines[0][ 2]==__T(':') && Lines[0][ 5]==__T(':') && Lines[0][ 8]==__T(':')
&& Lines[0][11]==__T(' ') && Lines[0][12]==__T(',') && Lines[0][13]==__T(' ')
&& Lines[0][14]==__T('0') && Lines[0][15]==__T('0')
&& Lines[0][16]==__T(':') && Lines[0][19]==__T(':') && Lines[0][22]==__T(':')
&& Lines[0][25]==__T(' ') && Lines[0][16]==__T(',') && Lines[0][27]==__T(' ')
)
{
Format=__T("Captions 32");
Codec=__T("Caption 32");
}
else if (Lines[0].size()==23
&& Lines[0]==__T("*Timecode type: PAL/EBU")
&& Lines[1].empty()
&& Lines[2].size()==23
&& Lines[2][ 0]==__T('0') && Lines[2][ 1]==__T('0')
&& Lines[2][ 2]==__T(':') && Lines[2][ 5]==__T(':') && Lines[2][ 8]==__T(':')
&& Lines[2][11]==__T(' ')
&& Lines[2][12]==__T('0') && Lines[2][13]==__T('0')
&& Lines[2][14]==__T(':') && Lines[2][17]==__T(':') && Lines[2][20]==__T(':')
&& Lines[2].size()>0
)
{
Format=__T("Captions Inc");
Codec=__T("Captions inc");
}
else if (Lines[0].size()>1
&& Lines[0][0]==__T('*')
&& Lines.Find(__T("** Caption Number 1"))!=Error
)
{
Format=__T("Cheeta");
}
else if (Lines[0].size()>10
&& Lines[0][0]==__T('~') && Lines[0][1]==__T('C') && Lines[0][2]==__T('P') && Lines[0][3]==__T('C') && Lines[0][9]==__T('~')
&& Lines[1][ 0]==__T('0') && Lines[1][ 1]==__T('0')
&& Lines[1][ 2]==__T(':') && Lines[1][ 5]==__T(':') && Lines[1][ 8]==__T(':')
)
{
Format=__T("CPC Captioning");
Codec=__T("CPC Captioning");
}
else if (Lines[0].find(__T("<SAMI>"))==0)
{
Format=__T("SAMI");
}
else
return;
if (Format.empty())
return;
Accept("Other text");
if (!IsSub)
{
Fill(Stream_General, 0, General_Format, Format);
Fill(Stream_General, 0, General_Format_Info, FormatMore, true);
}
Stream_Prepare(Stream_Text);
Fill(Stream_Text, 0, Text_Format, Format);
Fill(Stream_Text, 0, Text_Codec, Codec);
//No more need data
Element_Begin1(Format);
Element_End0();
Finish("Other text");
}
//---------------------------------------------------------------------------
bool File_SubRip::FileHeader_Begin()
{
if (!IsSub && (Buffer_Size<File_Size && Buffer_Size<65536))
{
Element_WaitForMoreData();
return false;
}
ZtringListList List;
List.Separator_Set(0, __T("\n\n"));
List.Separator_Set(1, __T("\n"));
if (Buffer[0]==0xEF
&& Buffer[1]==0xBB
&& Buffer[2]==0xBF)
HasBOM=true;
bool IsLocal=false;
Ztring Temp;
Temp.From_UTF8((const char*)Buffer+(HasBOM?3:0), (Buffer_Size>65536?65536:Buffer_Size)-(HasBOM?3:0));
if (Temp.empty())
{
Temp.From_Local((const char*)Buffer+(HasBOM?3:0), (Buffer_Size>65536?65536:Buffer_Size)-(HasBOM?3:0)); // Trying from local code page
IsLocal=true;
}
Temp.FindAndReplace(__T("\r\n"), __T("\n"), 0, Ztring_Recursive);
Temp.FindAndReplace(__T("\r"), __T("\n"), 0, Ztring_Recursive);
List.Write(Temp);
if (List(0, 0)==__T("WEBVTT FILE") || List(0, 0)==__T("WEBVTT"))
IsVTT=true;
if (!IsVTT)
{
size_t IsOk=0;
size_t IsNok=0;
for (size_t Pos=0; Pos<List.size(); Pos++)
{
if (List(Pos, 0).To_int64u()==Pos+1)
IsOk++;
else
IsNok++;
if (List(Pos, 1).size()>22 && List(Pos, 1)[2]==__T(':') && List(Pos, 1)[5]==__T(':') && List(Pos, 1).find(__T(" --> "))!=string::npos)
IsOk++;
else
IsNok++;
}
if (!IsOk || IsNok>IsOk/2)
{
Reject();
return true;
}
}
if (!IsSub && File_Size!=(int64u)-1 && Buffer_Size!=File_Size)
{
Element_WaitForMoreData();
return false;
}
if (!Status[IsAccepted])
{
Accept();
Fill(Stream_General, 0, General_Format, IsVTT?"WebVTT":"SubRip");
Stream_Prepare(Stream_Text);
Fill(Stream_Text, 0, "Format", IsVTT?"WebVTT":"SubRip");
Fill(Stream_Text, 0, "Codec", IsVTT?"WebVTT":"SubRip");
}
if (IsLocal)
Temp.From_Local((const char*)Buffer+(HasBOM?3:0), Buffer_Size-(HasBOM?3:0));
else
Temp.From_UTF8((const char*)Buffer+(HasBOM?3:0), Buffer_Size-(HasBOM?3:0));
Temp.FindAndReplace(__T("\r\n"), __T("\n"), 0, Ztring_Recursive);
Temp.FindAndReplace(__T("\r"), __T("\n"), 0, Ztring_Recursive);
List.Write(Temp);
#if MEDIAINFO_DEMUX
size_t Pos=0;
for (;;)
{
if (Pos>=List.size())
break;
if (List[Pos].size()>=3 || (IsVTT && List[Pos].size()>=2))
{
Ztring PTS_Begin_String=List[Pos][IsVTT?0:1].SubString(Ztring(), __T(" --> "));
Ztring PTS_End_String=List[Pos][IsVTT?0:1].SubString(__T(" --> "), Ztring());
if (IsVTT)
{
size_t Extra_Pos=PTS_End_String.find(__T(' '));
if (Extra_Pos!=string::npos)
PTS_End_String.resize(Extra_Pos); //Discarding positioning
}
item Item;
Item.PTS_Begin=SubRip_str2timecode(PTS_Begin_String.To_UTF8().c_str());
Item.PTS_End=SubRip_str2timecode(PTS_End_String.To_UTF8().c_str());
for (size_t Pos2=IsVTT?1:2; Pos2<List[Pos].size(); Pos2++)
{
List[Pos][Pos2].Trim();
Item.Content+=List[Pos][Pos2];
if (Pos2+1<List[Pos].size())
Item.Content+=EOL;
}
Items.push_back(Item);
}
Pos++;
}
#endif //MEDIAINFO_DEMUX
return true;
}
//---------------------------------------------------------------------------
void File_ChannelGrouping::Read_Buffer_Continue()
{
//Handling of multiple frames in one block
if (Buffer_Size-Buffer_Offset_AlreadyInCommon==0)
{
if (Common->Parser && Common->Parser->Buffer_Size)
Open_Buffer_Continue(Common->Parser, Common->MergedChannel.Buffer+Common->MergedChannel.Buffer_Offset, 0);
Element_WaitForMoreData();
return;
}
//If basic PCM is already detected
if (Common->IsPcm)
{
if (Buffer_Size==Buffer_Offset_AlreadyInCommon)
{
Element_WaitForMoreData();
return;
}
Buffer_Offset_AlreadyInCommon=0;
#if MEDIAINFO_DEMUX
Demux_Level=2; //Container
Demux_Offset=Buffer_Size;
FrameInfo.PTS=FrameInfo.DTS;
if (IsPcm_Frame_Count)
FrameInfo.DUR*=IsPcm_Frame_Count+1;
Demux_UnpacketizeContainer_Demux();
#endif //MEDIAINFO_DEMUX
Skip_XX(Element_Size, "Data");
if (IsPcm_Frame_Count)
{
Frame_Count+=IsPcm_Frame_Count;
IsPcm_Frame_Count=0;
}
Frame_Count++;
if (!Status[IsFilled])
{
Finish();
}
return;
}
else if (Buffer_Size && Buffer_Size>Buffer_Offset_AlreadyInCommon && !Common->IsAes3)
IsPcm_Frame_Count++;
//Demux
#if MEDIAINFO_DEMUX
if (Demux_UnpacketizeContainer)
{
Common->Parser->Demux_UnpacketizeContainer=true;
Common->Parser->Demux_Level=2; //Container
Demux_Level=4; //Intermediate
}
Demux(Common->MergedChannel.Buffer+Common->MergedChannel.Buffer_Offset, Common->MergedChannel.Buffer_Size-Common->MergedChannel.Buffer_Offset, ContentType_MainStream);
#endif //MEDIAINFO_EVENTS
//Copying to Channel buffer
if (Common->Channels[Channel_Pos]->Buffer_Size+Buffer_Size-Buffer_Offset_AlreadyInCommon>Common->Channels[Channel_Pos]->Buffer_Size_Max)
Common->Channels[Channel_Pos]->resize(Common->Channels[Channel_Pos]->Buffer_Size+Buffer_Size-Buffer_Offset_AlreadyInCommon);
memcpy(Common->Channels[Channel_Pos]->Buffer+Common->Channels[Channel_Pos]->Buffer_Size, Buffer+Buffer_Offset_AlreadyInCommon, Buffer_Size-Buffer_Offset_AlreadyInCommon);
Common->Channels[Channel_Pos]->Buffer_Size+=Buffer_Size-Buffer_Offset_AlreadyInCommon;
if (!Common->IsAes3)
Buffer_Offset_AlreadyInCommon=Buffer_Size;
else
Buffer_Offset_AlreadyInCommon=0;
Common->Channel_Current++;
if (Common->Channel_Current>=Channel_Total)
Common->Channel_Current=0;
//Copying to merged channel
size_t Minimum=(size_t)-1;
for (size_t Pos=0; Pos<Common->Channels.size(); Pos++)
if (Minimum>Common->Channels[Pos]->Buffer_Size-Common->Channels[Pos]->Buffer_Offset)
Minimum=Common->Channels[Pos]->Buffer_Size-Common->Channels[Pos]->Buffer_Offset;
while (Minimum>=ByteDepth)
{
for (size_t Pos=0; Pos<Common->Channels.size(); Pos++)
{
if (Common->MergedChannel.Buffer_Size+Minimum>Common->MergedChannel.Buffer_Size_Max)
Common->MergedChannel.resize(Common->MergedChannel.Buffer_Size+Minimum);
memcpy(Common->MergedChannel.Buffer+Common->MergedChannel.Buffer_Size, Common->Channels[Pos]->Buffer+Common->Channels[Pos]->Buffer_Offset, ByteDepth);
Common->Channels[Pos]->Buffer_Offset+=ByteDepth;
Common->MergedChannel.Buffer_Size+=ByteDepth;
}
Minimum-=ByteDepth;
}
if (Common->MergedChannel.Buffer_Size-Common->MergedChannel.Buffer_Offset)
{
if (FrameInfo_Next.DTS!=(int64u)-1)
Common->Parser->FrameInfo=FrameInfo_Next; //AES3 parse has its own buffer management
else
Common->Parser->FrameInfo=FrameInfo;
Open_Buffer_Continue(Common->Parser, Common->MergedChannel.Buffer+Common->MergedChannel.Buffer_Offset, Common->MergedChannel.Buffer_Size-Common->MergedChannel.Buffer_Offset);
Common->MergedChannel.Buffer_Offset=Common->MergedChannel.Buffer_Size;
}
if (!Common->IsAes3)
{
if (!Status[IsFilled] && Common->Parser->Status[IsAccepted])
{
if (Common->Parser->Get(Stream_Audio, 0, Audio_Format)==_T("PCM"))
Common->IsPcm=true;
else
{
Common->IsAes3=true;
if (Common->Channel_Master==(size_t)-1)
Common->Channel_Master=Channel_Pos;
Buffer_Offset_AlreadyInCommon=0;
Fill();
}
}
else if (Common->MergedChannel.Buffer_Size==0 && IsPcm_Frame_Count>=2)
Common->IsPcm=true;
}
if (Common->IsAes3)
Buffer_Offset=Buffer_Size;
else
Element_WaitForMoreData();
if (Common->Parser->Status[IsFinished])
Finish();
//Optimize buffer
for (size_t Pos=0; Pos<Common->Channels.size(); Pos++)
Common->Channels[Pos]->optimize();
Common->MergedChannel.optimize();
}