bool File_Vc3::Demux_UnpacketizeContainer_Test()
{
if (Buffer_Offset+0x2C>Buffer_Size)
return false;
int32u CompressionID=BigEndian2int32u(Buffer+Buffer_Offset+0x28);
int32u Size=Vc3_CompressedFrameSize(CompressionID);
Demux_Offset=Buffer_Offset+Size;
if (Demux_Offset>Buffer_Size && File_Offset+Buffer_Size!=File_Size)
return false; //No complete frame
Demux_UnpacketizeContainer_Demux();
return true;
}
//---------------------------------------------------------------------------
void File_Pcm::Data_Parse()
{
#if MEDIAINFO_DEMUX
if (Demux_UnpacketizeContainer)
{
Demux_Offset=(size_t)Element_Size;
Demux_UnpacketizeContainer_Demux();
}
#endif //MEDIAINFO_DEMUX
//Parsing
Skip_XX(Element_Size, "Data"); //It is impossible to detect... Default is no detection, only filling
Frame_Count++;
if (!Status[IsAccepted] && Frame_Count>=2)
{
Accept();
Finish();
}
}
bool File_DvbSubtitle::Demux_UnpacketizeContainer_Test()
{
if (Demux_Offset==0)
{
Demux_Offset=Buffer_Offset;
}
while (Demux_Offset<Buffer_Size)
{
bool MustBreak;
switch (Buffer[Demux_Offset])
{
case 0xFF :
MustBreak=true; break; //0xFF is not in the demuxed frame
default : MustBreak=false;
}
if (MustBreak)
break; //while() loop
if (Demux_Offset+6>Buffer_Size)
return false; //No complete frame
int16u segment_length=BigEndian2int16u(Buffer+Demux_Offset+4);
Demux_Offset+=6+segment_length;
if (Demux_Offset>=Buffer_Size)
return false; //No complete frame
}
if (Demux_Offset>=Buffer_Size)
return false; //No complete frame
Demux_UnpacketizeContainer_Demux();
Demux_TotalBytes++; //0xFF is not demuxed
return true;
}
//---------------------------------------------------------------------------
void File_Pcm_Vob::Read_Buffer_Continue()
{
if (Buffer_Size==0)
return;
//Parsing
Skip_B1( "Frame number");
Skip_B2( "Bytes to skip (+1?)");
Skip_B1( "Unknown");
BS_Begin();
Get_S1 (2, BitDepth, "Bit depth"); Param_Info1(Pcm_VOB_BitDepth[BitDepth]);
Get_S1 (2, Frequency, "Frequency"); Param_Info1(Pcm_VOB_Frequency[Frequency]);
Skip_SB( "Unknown");
Get_S1 (3, NumberOfChannelsMinusOne, "Number of channels (minus 1)");
BS_End();
Skip_B1( "Start code");
#if MEDIAINFO_DEMUX
if (Config->Demux_PCM_20bitTo16bit_Get() && BitDepth==1) //20-bit
{
int8u* Info=new int8u[(size_t)((Element_Size-6)*4/5)];
size_t Info_Offset=0;
while (Element_Offset+5*(NumberOfChannelsMinusOne+1)<=Element_Size)
{
size_t Buffer_Pos=Buffer_Offset+(size_t)Element_Offset;
std::memcpy(Info+Info_Offset, Buffer+Buffer_Pos, 4*(NumberOfChannelsMinusOne+1));
Info_Offset+=4*(NumberOfChannelsMinusOne+1);
Element_Offset+=5*(NumberOfChannelsMinusOne+1);
}
Element_Offset=6;
FrameInfo.PTS=FrameInfo.DTS;
if (Pcm_VOB_Frequency[Frequency])
FrameInfo.DUR=(Element_Size-6)/5*1000000000/Pcm_VOB_Frequency[Frequency];
Demux_random_access=true;
Element_Code=(int64u)-1;
Demux(Info, Info_Offset, ContentType_MainStream);
delete[] Info;
}
else
{
Demux_Offset=Buffer_Offset+(size_t)Element_Size;
Buffer_Offset+=6; //Header is dropped
Demux_UnpacketizeContainer_Demux();
Buffer_Offset-=6;
}
#endif //MEDIAINFO_DEMUX
Skip_XX(Element_Size-6, "Data");
FILLING_BEGIN();
Frame_Count++;
Frame_Count_InThisBlock++;
if (Frame_Count_NotParsedIncluded!=(int64u)-1)
Frame_Count_NotParsedIncluded++;
if (FrameInfo.DTS!=(int64u)-1 && FrameInfo.DUR!=(int64u)-1)
{
FrameInfo.DTS+=FrameInfo.DUR;
FrameInfo.PTS=FrameInfo.DTS;
}
if (!Status[IsAccepted])
{
Accept();
Finish();
}
FILLING_END();
}
//---------------------------------------------------------------------------
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();
}
