Ztring ZtringListList::Read1 (size_type Pos1) const
{
Ztring ToReturn;
size_type Size=size()-1;
for (size_type Pos=0; Pos<Size; Pos++)
ToReturn+=operator[](Pos).Read(Pos1)+Separator[0];
ToReturn+=operator[](Size).Read(Pos1);
//Delete all useless separators at the end
if(ToReturn(ToReturn.size()-1)==Separator[0][Separator[0].size()-1]) //Optimize speed
while (ToReturn.find(Separator[0].c_str(), ToReturn.size()-Separator[0].size())!=std::string::npos)
ToReturn.resize(ToReturn.size()-Separator[0].size());
return ToReturn;
}
//---------------------------------------------------------------------------
void File_Cmml::Configuration()
{
Element_Name("Configuration");
//Parsing
Ztring Data;
Get_UTF8(Element_Size, Data, "Data");
FILLING_BEGIN();
Ztring Value;
Value=Data.SubString(_T("<head>"), _T("</head>"));
if (!Value.empty())
Fill(Stream_Text, 0, Text_Title, Value.SubString(_T("<title>"), _T("</title>")));
if (Data.find(_T("<clip"))!=string::npos)
Finish("CMML");
FILLING_END();
}
//---------------------------------------------------------------------------
// Read
Ztring ZtringListList::Read () const
{
//Integrity
if (size()==0)
return _T("");
Ztring ToReturn;
size_type Size=size()-1;
for (size_type Pos0=0; Pos0<Size; Pos0++)
ToReturn+=Read(Pos0)+Separator[0];
ToReturn+=Read(Size);
//Delete all useless separators at the end
if(ToReturn.size()>0 && Separator[0].size() && ToReturn(ToReturn.size()-1)==Separator[0][Separator[0].size()-1]) //Optimize speed
while (ToReturn.find(Separator[0].c_str(), ToReturn.size()-Separator[0].size())!=std::string::npos)
ToReturn.resize(ToReturn.size()-Separator[0].size());
return ToReturn;
}
//---------------------------------------------------------------------------
// Read
Ztring ZtringList::Read () const
{
//Integrity
if (size()==0)
return _T("");
Ztring Retour;
for (size_type Pos=0; Pos<size(); Pos++)
{
if (operator[](Pos).find(Separator[0])==std::string::npos)
Retour+=operator[](Pos)+Separator[0];
else
Retour+=Quote+operator[](Pos)+Quote+Separator[0];
}
//delete all useless separators at the end
while (Retour.find(Separator[0].c_str(), Retour.size()-Separator[0].size())!=std::string::npos)
Retour.resize(Retour.size()-Separator[0].size());
return Retour;
}
//---------------------------------------------------------------------------
// Read
Ztring ZtringList::Read () const
{
//Integrity
if (size()==0)
return Ztring();
Ztring Retour;
Ztring ToFind=Separator[0]+Quote[0]+__T("\r\n");
for (size_type Pos=0; Pos<size(); Pos++)
{
if (operator[](Pos).find_first_of(ToFind)==std::string::npos)
Retour+=operator[](Pos)+Separator[0];
else if (operator[](Pos).find(Separator[0])==std::string::npos
&& operator[](Pos).find(Quote)==std::string::npos
&& operator[](Pos).find('\r')==std::string::npos
&& operator[](Pos).find('\n')==std::string::npos)
Retour+=operator[](Pos)+Separator[0];
else
{
if (operator[](Pos).find(Quote)==std::string::npos)
Retour+=Quote+operator[](Pos)+Quote+Separator[0];
else
{
Ztring Value=operator[](Pos);
Value.FindAndReplace(Quote, Quote+Quote, 0, Ztring_Recursive);
Retour+=Quote+Value+Quote+Separator[0];
}
}
}
//delete all useless separators at the end
//while (Retour.find(Separator[0].c_str(), Retour.size()-Separator[0].size())!=std::string::npos)
if (Retour.find(Separator[0].c_str(), Retour.size()-Separator[0].size())!=std::string::npos)
Retour.resize(Retour.size()-Separator[0].size());
return Retour;
}
//---------------------------------------------------------------------------
Ztring Export_PBCore::Transform(MediaInfo_Internal &MI)
{
Node Node_Main("PBCoreDescriptionDocument");
Node_Main.Add_Attribute("xsi:schemaLocation", "http://www.pbcore.org/PBCore/PBCoreNamespace.html http://www.pbcore.org/PBCore/PBCoreXSD_Ver_1-2-1.xsd");
Node_Main.Add_Attribute("xmlns:xsi", "http://www.w3.org/2001/XMLSchema-instance");
Node_Main.Add_Attribute("xmlns", "http://www.pbcore.org/PBCore/PBCoreNamespace.html");
Node* Node_Identifier = Node_Main.Add_Child("pbcoreIdentifier");
Node_Identifier->Add_Child("identifier", "***");
Node_Identifier->Add_Child("identifierSource", "***");
Node_Main.Add_Child("pbcoreTitle")->Add_Child("title", "***");
Node* Node_Description = Node_Main.Add_Child("pbcoreDescription");
Node_Description->Add_Child("description", "***");
Node_Description->Add_Child("descriptionType", "***");
Node* Node_Instantiation = Node_Main.Add_Child("pbcoreInstantiation");
//pbcoreFormatID
Node* Node_FormatID = Node_Instantiation->Add_Child("pbcoreFormatID");
//formatIdentifier
Node_FormatID->Add_Child("formatIdentifier", MI.Get(Stream_General, 0, General_FileName));
//formatIdentifierSource
Node_FormatID->Add_Child("formatIdentifierSource", "File Name", "version", "PBCoreXSD_Ver_1.2_D1");
//formatDigital
//TODO: how to implement formats without Media Type?
Ztring Format;
if (!MI.Get(Stream_General, 0, General_InternetMediaType).empty())
Format=Ztring(MI.Get(Stream_General, 0, General_InternetMediaType));
else if (MI.Count_Get(Stream_Video))
Format=__T("video/x-")+Ztring(MI.Get(Stream_General, 0, __T("Format"))).MakeLowerCase();
else if (MI.Count_Get(Stream_Image))
Format=__T("image/x-")+Ztring(MI.Get(Stream_General, 0, __T("Format"))).MakeLowerCase();
else if (MI.Count_Get(Stream_Audio))
Format=__T("audio/x-")+Ztring(MI.Get(Stream_General, 0, __T("Format"))).MakeLowerCase();
else
Format=__T("application/x-")+Ztring(MI.Get(Stream_General, 0, __T("Format"))).MakeLowerCase();
Node_Instantiation->Add_Child("formatDigital", Format);
//formatLocation
Node_Instantiation->Add_Child("formatLocation", MI.Get(Stream_General, 0, General_CompleteName));
//dateCreated
if (!MI.Get(Stream_General, 0, General_Encoded_Date).empty())
{
Ztring dateCreated=MI.Get(Stream_General, 0, General_Recorded_Date);
dateCreated.FindAndReplace(__T("UTC"), __T("-"));
dateCreated.FindAndReplace(__T(" "), __T("T"));
dateCreated+=__T('Z');
Node_Instantiation->Add_Child("dateCreated", dateCreated);
}
//dateIssued
if (!MI.Get(Stream_General, 0, General_Recorded_Date).empty())
{
Ztring dateIssued=MI.Get(Stream_General, 0, General_Recorded_Date);
dateIssued.FindAndReplace(__T("UTC"), __T("-"));
dateIssued.FindAndReplace(__T(" "), __T("T"));
dateIssued+=__T('Z');
Node_Instantiation->Add_Child("dateIssued", dateIssued);
}
//formatMediaType
Node_Instantiation->Add_Child("formatMediaType", PBCore_MediaType(MI).empty()?Ztring(__T("application/octet-stream")):PBCore_MediaType(MI), "version", "PBCoreXSD_Ver_1.2_D1");
//formatGenerations
Node_Instantiation->Add_Child("formatGenerations", "","version", "PBCoreXSD_Ver_1.2_D1");
//formatFileSize
Node_Instantiation->Add_Child_IfNotEmpty(MI, Stream_General, 0, General_FileSize, "formatFileSize");
//formatTimeStart
if (!MI.Get(Stream_Video, 0, Video_Delay_Original_String3).empty())
Node_Instantiation->Add_Child("formatTimeStart", MI.Get(Stream_Video, 0, Video_Delay_Original_String3));
else if (!MI.Get(Stream_Video, 0, Video_Delay_String3).empty())
Node_Instantiation->Add_Child("formatTimeStart", MI.Get(Stream_Video, 0, Video_Delay_String3));
//formatDuration
Node_Instantiation->Add_Child_IfNotEmpty(MI, Stream_General, 0, General_Duration_String3, "formatDuration");
//formatDataRate
if (!MI.Get(Stream_General, 0, General_OverallBitRate).empty())
{
Ztring formatDataRate=MI.Get(Stream_General, 0, General_OverallBitRate);
if (!MI.Get(Stream_General, 0, General_OverallBitRate_Mode).empty())
formatDataRate+=__T(' ')+MI.Get(Stream_General, 0, General_OverallBitRate_Mode);
Node_Instantiation->Add_Child("formatDataRate", formatDataRate);
}
//formatTracks
Node_Instantiation->Add_Child("formatTracks", Ztring::ToZtring(MI.Count_Get(Stream_Video)+MI.Count_Get(Stream_Audio)+MI.Count_Get(Stream_Image)+MI.Count_Get(Stream_Text)));
Ztring ToReturn;
//Streams
for (size_t StreamKind=Stream_General+1; StreamKind<Stream_Max; StreamKind++)
for (size_t StreamPos=0; StreamPos<MI.Count_Get((stream_t)StreamKind); StreamPos++)
PBCore_Transform(Node_Instantiation, MI, (stream_t)StreamKind, StreamPos);
ToReturn+=Ztring().From_UTF8(To_XML(Node_Main, 0, true, true).c_str());
size_t Pos=ToReturn.find(__T("<PBCoreDescriptionDocument"));
if(Pos!=Ztring::npos)
ToReturn.insert(Pos, __T("<!-- Warning: MediaInfo outputs only pbcoreInstantiation, other mandatory PBCore data is junk -->\n"));
//Carriage return
if (MediaInfoLib::Config.LineSeparator_Get()!=__T("\n"))
ToReturn.FindAndReplace(__T("\n"), MediaInfoLib::Config.LineSeparator_Get(), 0, Ztring_Recursive);
return ToReturn;
}
//---------------------------------------------------------------------------
void File_Ptx::Read_Buffer_Continue()
{
if (File_Offset || Buffer_Offset)
{
if (Buffer_Size)
Reject(); //Problem
return;
}
//Parsing
ZtringList Names;
Ztring LibraryName, LibraryVersion, Format, Directory;
int32u LibraryName_Length, LibraryVersion_Length, LibraryRelease_Length, Format_Length, Platform_Length, Info_Count, Names_Count, Info_Length, Name_Length, FileName_Count, Directory_Length;
int32u Unknown_Length;
int16u Audio_Count;
Element_Begin1("Header");
Skip_B1( "Magic");
Skip_Local(16, "Magic");
Skip_L2( "0x0500");
Skip_L1( "Unknown");
Skip_L1( "0x5A");
Skip_L2( "0x0001");
Skip_L2( "0x0004");
Skip_L2( "0x0000");
Skip_L4( "Unknown");
Skip_L2( "0x035A");
Skip_L2( "0x6400");
Skip_L2( "0x0000");
Skip_L2( "0x0300");
Skip_L2( "0x0000");
Get_L4 (LibraryName_Length, "WritingLibrary name length");
Get_UTF8(LibraryName_Length, LibraryName, "Library name");
Skip_L4( "0x00000003");
Skip_L4( "Library version, major");
Skip_L4( "Library version, minor");
Skip_L4( "Library version, revision");
Get_L4 (LibraryVersion_Length, "Library version length");
Get_UTF8(LibraryVersion_Length, LibraryVersion, "Library version");
Skip_L1( "0x01");
Get_L4 (LibraryRelease_Length, "Library release length");
Skip_UTF8(LibraryRelease_Length, "Library release");
Skip_L1( "0x00");
Get_L4 (Format_Length, "Format length");
Get_UTF8(Format_Length, Format, "Format");
if (Format!=__T("Pro Tools Session File"))
{
Element_End();
Reject("Ptx");
return;
}
Skip_L2( "0x0006");
Get_L4 (Platform_Length, "Platform length");
Skip_UTF8(Platform_Length, "Platform");
Skip_L4( "0x00000000");
Skip_L4( "0x00085A05");
Skip_L4( "Unknown");
Skip_L4( "0x00002067");
Skip_L4( "0x002A0000");
Skip_L4( "Unknown");
Skip_L4( "Unknown");
Skip_L4( "Unknown");
Element_End();
Element_Begin1("Info list");
Get_L4 (Info_Count, "Info count");
if (4*Info_Count>Element_Size)
{
Element_End();
Reject();
return;
}
for (int32u Pos=0; Pos<Info_Count; Pos++)
{
Element_Begin1("Info");
Get_L4 (Info_Length, "Info length");
if (Info_Length)
{
Info_UTF8(Info_Length, Info, "Name"); Element_Info1(Info);
}
Element_End();
}
Element_End();
Element_Begin1("Unknown");
Skip_L4( "0x00000000");
Element_Begin1("Names list 1");
Get_L4 (Names_Count, "Names count minus 1");
if (4*Names_Count>Element_Size)
{
Element_End();
Reject();
return;
}
for (int16u Pos=0; Pos<1+Names_Count; Pos++)
{
Element_Begin1("Name");
Get_L4 (Name_Length, "Name length");
if (Name_Length)
{
Info_UTF8(Name_Length, Name, "Name"); Element_Name(Name);
}
Element_End();
}
Element_End();
Skip_L4( "0x00000000");
Skip_L4( "0x0000002A");
Skip_L4( "Unknown");
Skip_L4( "Unknown");
Element_Begin1("Names list 2");
Get_L4 (Names_Count, "Names count");
if (4*Names_Count>Element_Size)
{
Element_End();
Reject();
return;
}
for (int16u Pos=0; Pos<Names_Count; Pos++)
{
Element_Begin1("Name");
Get_L4 (Name_Length, "Name length");
if (Name_Length)
{
Info_UTF8(Name_Length, Name, "Name"); Element_Name(Name);
}
Element_End();
}
Element_End();
Skip_L4( "0x00000000");
Skip_L4( "0x0000002A");
Skip_L4( "Unknown");
Skip_L4( "Unknown");
Skip_L4( "0x00000000");
Skip_L4( "Unknown");
Skip_L4( "0x00000101");
Skip_L4( "0x00055A00");
Skip_L4( "Unknown");
Skip_L4( "0x00012519");
Skip_L4( "0x00000000");
Skip_L4( "0x00000000");
Skip_L4( "0x00000001");
Skip_L2( "0x0003");
Element_End();
Get_L2 (Audio_Count, "Audio count");
if (111*Audio_Count>Element_Size)
{
Reject();
return;
}
Element_Begin1("Audio tracks list 1");
for (int16u Pos=0; Pos<Audio_Count; Pos++)
{
Element_Begin1("Name");
Skip_L4( "0x00000000");
Get_L4 (Unknown_Length, "Name length");
Info_UTF8(Unknown_Length, Name, "Name");
Skip_L2( "0x0000");
Skip_L4( "0x00000000");
Skip_L4( "0x0000002A");
Skip_L4( "Unknown (same 1/2/3)");
Skip_L4( "Unknown (same 1/2/3)");
Info_L1(Number, "Ordered number"); Element_Info1(Number);
Element_Info1(Name);
Element_End();
Names.push_back(Name);
}
Element_End();
Skip_L2( "0x0000");
Element_Begin1("Audio tracks list 2");
for (int16u Pos=0; Pos<Audio_Count; Pos++)
{
Element_Begin1("Name");
int32u Size;
Skip_L3( "0x00025A");
Get_L4 (Size, "Size");
Skip_L4( "0x0000251A");
Get_L4 (Unknown_Length, "Name length");
Info_UTF8(Unknown_Length, Name, "Name");
Skip_L2( "0x0000");
Skip_L4( "0x00000000");
Skip_L4( "0x0000002A");
Skip_L4( "Unknown (same 1/2/3)");
Skip_L4( "Unknown (same 1/2/3)");
Info_L1(Number, "Ordered number"); Element_Info1(Number);
Skip_L4( "0x00000000");
Element_Info1(Name);
if (Unknown_Length+31!=Size)
{
Reject();
return;
}
Element_End();
}
Element_End();
Get_L2 (Audio_Count, "Audio count");
if (4*Audio_Count>Element_Size)
{
Reject();
return;
}
Skip_L2( "0x00");
Element_Begin1("Audio tracks list 3");
for (int16u Pos=0; Pos<Audio_Count; Pos++)
{
Element_Begin1("Name");
int32u Size;
Skip_L3( "0x00025A");
Get_L4 (Size, "Size");
Skip_L4( "0x0000251A");
Get_L4 (Unknown_Length, "Name length");
Info_UTF8(Unknown_Length, Name, "Name");
Skip_L2( "0x0000");
Skip_L4( "0x00000000");
Skip_L4( "0x0000002A");
Skip_L4( "Unknown (same 1/2/3)");
Skip_L4( "Unknown (same 1/2/3)");
Info_L1(Number, "Ordered number"); Element_Info1(Number);
Skip_L4( "0x00000000");
Element_Info1(Name);
if (Unknown_Length+31!=Size)
{
Reject();
return;
}
Element_End();
}
Element_End();
Skip_L2( "0x0000");
Skip_L2( "0x0018");
Skip_L4( "0x00000001");
Skip_L2( "0x0018");
Skip_L4( "0x00000001");
Skip_L2( "0x0001");
Skip_L3( "0x00095A");
Get_L4 (Unknown_Length, "Opaque length");
Skip_XX(Unknown_Length, "Opaque");
Skip_L3( "0x00045A");
Skip_L4( "0x00000016");
Skip_L4( "0x06002026");
Skip_L4( "0x00000000");
Skip_L2( "0x0000");
Skip_L4( "Unknown");
Skip_L4( "Unknown");
Skip_L4( "0x00000000");
Skip_L3( "0x00025A");
Skip_L4( "0x00000015");
Skip_L4( "0x075A2032");
Skip_L4( "0x00000C00");
Skip_L4( "0x01204200");
Skip_L4( "0x01000000");
Skip_L4( "Unknown");
Skip_L4( "0x00025A00");
Skip_L4( "Unknown");
Skip_L4( "Unknown");
Skip_L4( "0x015A0000");
Skip_L4( "Unknown");
Skip_L4( "Unknown");
Skip_L4( "0x01000000");
Get_L4 (FileName_Count, "File name count");
if (13*FileName_Count>Element_Size)
{
Reject();
return;
}
Get_L4 (Directory_Length, "Directory length");
Get_UTF8(Directory_Length, Directory, "Directory");
Skip_L4( "0x00000000");
Element_Begin1("File names");
size_t Pos_Offset=0;
for (int32u Pos=0; Pos<FileName_Count; Pos++)
{
Ztring Name;
int32u Name_Length, Purpose;
Element_Begin1("File names");
Skip_L1( "0x0002");
Skip_L4( "Ordered number except WAV files and -1");
Get_L4 (Name_Length, "Name length");
Get_UTF8(Name_Length, Name, "Name"); Element_Name(Name);
Get_C4 (Purpose, "Purpose (e.g. EVAW for .wav files)");
Element_End();
switch (Purpose)
{
case 0x45564157:
if (Pos-Pos_Offset<Names.size()
&& (Name.find(Names[Pos-Pos_Offset])==0
|| Name.find(Names[Pos-Pos_Offset]+__T(".wav"))+5==Name.size()))
{
File__ReferenceFilesHelper::reference ReferenceFile;
ReferenceFile.StreamKind=Stream_Audio;
ReferenceFile.FileNames.push_back(Directory+PathSeparator+Name);
ReferenceFiles->References.push_back(ReferenceFile);
}
else if (ReferenceFiles->References.empty())
Pos_Offset++;
default: ;
}
}
Element_End();
Skip_XX(Element_Size-Element_Offset, "Unknown");
FILLING_BEGIN();
Accept("Ptx"); //Could be Ptf (former formatn but not supported, so we don't care currently
Fill("Ptx");
Fill(Stream_General, 0, General_Format, "Pro Tools Session");
Fill(Stream_General, 0, General_Format_Version, "Version 10");
Fill(Stream_General, 0, General_Encoded_Library_Name, LibraryName);
Fill(Stream_General, 0, General_Encoded_Library_Version, LibraryVersion);
FILLING_END();
}
//---------------------------------------------------------------------------
// Write
void ZtringListList::Write(const Ztring &ToWrite)
{
clear();
if (ToWrite.empty())
return;
size_type PosC=0;
bool Fini=false;
Ztring C1;
ZtringList ZL1;
ZL1.Separator_Set(0, Separator[1]);
ZL1.Quote_Set(Quote);
ZL1.Max_Set(0, Max[1]);
//Detecting carriage return format
Ztring WriteSeparator;
if (Separator[0]==EOL)
{
size_t CarriageReturn_Pos=ToWrite.find_first_of(__T("\r\n"));
if (CarriageReturn_Pos!=string::npos)
{
if (ToWrite[CarriageReturn_Pos]==__T('\r'))
{
if (CarriageReturn_Pos+1<ToWrite.size() && ToWrite[CarriageReturn_Pos+1]==__T('\n'))
WriteSeparator=__T("\r\n");
else
WriteSeparator=__T("\r");
}
else
WriteSeparator=__T("\n");
}
else
WriteSeparator=Separator[0];
}
else
WriteSeparator=Separator[0];
do
{
//Searching end of line, but it must not be in quotes
bool InQuotes=false;
Ztring CharsToFind=WriteSeparator+Quote;
size_t Pos_End=PosC;
while (Pos_End<ToWrite.size())
{
Pos_End=ToWrite.find(WriteSeparator, Pos_End);
if (Pos_End!=string::npos)
{
if (Pos_End+Quote.size()<ToWrite.size() && ToWrite[Pos_End]==Quote[0] && ToWrite[Pos_End+1]!=Quote[0])
{
InQuotes=!InQuotes; //This is not double quotes, so this is a normal quote
/*if (!InQuotes)
{
C1=ToWrite.substr(PosC, Pos_End-PosC);
break;
}*/
}
if (!InQuotes && Pos_End+WriteSeparator.size()<=ToWrite.size() && ToWrite[Pos_End]==WriteSeparator[0])
{
C1=ToWrite.substr(PosC, Pos_End-PosC);
break;
}
if (InQuotes && Pos_End+Quote.size()*2<ToWrite.size() && ToWrite[Pos_End]==Quote[0] && ToWrite[Pos_End+1]==Quote[0])
Pos_End+=2;
else
Pos_End++;
}
}
if (Pos_End>=ToWrite.size())
C1=ToWrite.substr(PosC, string::npos);
ZL1.Write(C1);
push_back(ZL1);
PosC+=C1.size()+WriteSeparator.size();
if (PosC>=ToWrite.size())
Fini=true;
}
while (!Fini);
}
//---------------------------------------------------------------------------
void File_Ttml::Read_Buffer_Continue()
{
tinyxml2::XMLDocument document;
if (!FileHeader_Begin_XML(document))
return;
XMLElement* Root=document.FirstChildElement("tt");
if (!Root)
{
Reject();
return;
}
if (!Status[IsAccepted])
{
Accept();
#if MEDIAINFO_EVENTS
MuxingMode=(int8u)-1;
if (StreamIDs_Size>=2 && ParserIDs[StreamIDs_Size-2]==MediaInfo_Parser_Mpeg4)
MuxingMode=11; //MPEG-4
if (StreamIDs_Size>2 && ParserIDs[StreamIDs_Size-2]==MediaInfo_Parser_Mxf) //Only if referenced MXF
MuxingMode=13; //MXF
#endif //MEDIAINFO_EVENTS
#if MEDIAINFO_DEMUX && MEDIAINFO_NEXTPACKET
if (Config->NextPacket_Get() && Config->Event_CallBackFunction_IsSet())
return; // Waiting for NextPacket
#endif //MEDIAINFO_DEMUX && MEDIAINFO_NEXTPACKET
}
tinyxml2::XMLElement* div=NULL;
#if MEDIAINFO_EVENTS
tinyxml2::XMLElement* p=NULL;
#endif //MEDIAINFO_EVENTS
for (XMLElement* tt_element=Root->FirstChildElement(); tt_element; tt_element=tt_element->NextSiblingElement())
{
//body
if (!strcmp(tt_element->Value(), "body"))
{
for (XMLElement* body_element=tt_element->FirstChildElement(); body_element; body_element=body_element->NextSiblingElement())
{
//div
if (!strcmp(body_element->Value(), "div"))
{
for (XMLElement* div_element=body_element->FirstChildElement(); div_element; div_element=div_element->NextSiblingElement())
{
//p
if (!strcmp(div_element->Value(), "p"))
{
div=body_element;
#if MEDIAINFO_EVENTS
p=div_element;
#endif //MEDIAINFO_EVENTS
break;
}
}
if (div)
break;
}
}
if (div)
break;
}
}
#if MEDIAINFO_DEMUX
Demux(Buffer, Buffer_Size, ContentType_MainStream);
#endif //MEDIAINFO_DEMUX
// Output
#if MEDIAINFO_EVENTS
for (; p; p=p->NextSiblingElement())
{
//p
if (!strcmp(p->Value(), "p"))
{
int64u DTS_Begin=(int64u)-1;
const char* Attribute=p->Attribute("begin");
if (Attribute)
DTS_Begin=Ttml_str2timecode(Attribute);
int64u DTS_End=(int64u)-1;
Attribute=p->Attribute("end");
if (Attribute)
DTS_End=Ttml_str2timecode(Attribute);
string ContentUtf8;
XMLPrinter printer;
p->Accept(&printer);
ContentUtf8+=printer.CStr();
while (!ContentUtf8.empty() && (ContentUtf8[ContentUtf8.size()-1]=='\r' || ContentUtf8[ContentUtf8.size()-1]=='\n'))
ContentUtf8.resize(ContentUtf8.size()-1);
Ztring Content; Content.From_UTF8(ContentUtf8.c_str());
Frame_Count_NotParsedIncluded=Frame_Count;
EVENT_BEGIN (Global, SimpleText, 0)
//Hack: remove "p", "span", "br"
Content.FindAndReplace(__T("\r"), Ztring(), 0, ZenLib::Ztring_Recursive);
Content.FindAndReplace(__T("\n"), Ztring(), 0, ZenLib::Ztring_Recursive);
for (;;)
{
size_t Span_Begin=Content.find(__T("<p"));
if (Span_Begin==string::npos)
break;
size_t Span_End=Content.find(__T(">"), Span_Begin+5);
if (Span_End==string::npos)
break;
size_t ShlashSpan_Begin=Content.find(__T("</p>"), Span_End+1);
if (ShlashSpan_Begin==string::npos)
break;
Content.erase(ShlashSpan_Begin, 7);
Content.erase(Span_Begin, Span_End-Span_Begin+1);
}
for (;;)
{
size_t Span_Begin=Content.find(__T("<span"));
if (Span_Begin==string::npos)
break;
size_t Span_End=Content.find(__T(">"), Span_Begin+5);
if (Span_End==string::npos)
break;
size_t ShlashSpan_Begin=Content.find(__T("</span>"), Span_End+1);
if (ShlashSpan_Begin==string::npos)
break;
Content.erase(ShlashSpan_Begin, 7);
Content.erase(Span_Begin, Span_End-Span_Begin+1);
}
Content.FindAndReplace(__T("<br>"), EOL, 0, ZenLib::Ztring_Recursive);
Content.FindAndReplace(__T("<br/>"), EOL, 0, ZenLib::Ztring_Recursive);
Content.FindAndReplace(__T("<br />"), EOL, 0, ZenLib::Ztring_Recursive);
Event.DTS=DTS_Begin;
Event.PTS=Event.DTS;
Event.DUR=DTS_End-DTS_Begin;
Event.Content=Content.c_str();
Event.Flags=0;
Event.MuxingMode=MuxingMode;
Event.Service=(int8u)Element_Code;
Event.Row_Max=0;
Event.Column_Max=0;
Event.Row_Values=NULL;
Event.Row_Attributes=NULL;
EVENT_END ()
EVENT_BEGIN (Global, SimpleText, 0)
Event.DTS=DTS_End;
Event.PTS=Event.DTS;
Event.DUR=0;
Event.Content=__T("");
Event.Flags=0;
Event.MuxingMode=MuxingMode;
Event.Service=(int8u)Element_Code;
Event.Row_Max=0;
Event.Column_Max=0;
Event.Row_Values=NULL;
Event.Row_Attributes=NULL;
EVENT_END ()
Frame_Count++;
}
}
#endif //MEDIAINFO_EVENTS
Buffer_Offset=Buffer_Size;
}
//---------------------------------------------------------------------------
void File__Analyze::Fill (stream_t StreamKind, size_t StreamPos, const char* Parameter, const Ztring &Value, bool Replace)
{
//Integrity
if (StreamKind>Stream_Max || Parameter==NULL || Parameter[0]=='\0')
return;
//Handling values with \r\n inside
if (Value.find(_T('\r'))!=string::npos || Value.find(_T('\n'))!=string::npos)
{
Ztring NewValue=Value;
NewValue.FindAndReplace(_T("\r\n"), _T(" / "), 0, Ztring_Recursive);
NewValue.FindAndReplace(_T("\r"), _T(" / "), 0, Ztring_Recursive);
NewValue.FindAndReplace(_T("\n"), _T(" / "), 0, Ztring_Recursive);
if (NewValue.size()>=3 && NewValue.rfind(_T(" / "))==NewValue.size()-3)
NewValue.resize(NewValue.size()-3);
Fill(StreamKind, StreamPos, Parameter, NewValue, Replace);
return;
}
//Handle Value before StreamKind
if (StreamKind==Stream_Max || StreamPos>=(*Stream)[StreamKind].size())
{
ZtringList NewList;
NewList.push_back(Ztring().From_UTF8(Parameter));
NewList.push_back(Value);
Fill_Temp.push_back(NewList);
return; //No streams
}
//Handling of well known parameters
size_t Pos=MediaInfoLib::Config.Info_Get(StreamKind).Find(Ztring().From_Local(Parameter));
if (Pos!=Error)
{
Fill(StreamKind, StreamPos, Pos, Value, Replace);
return;
}
//Handling of unknown parameters
if (Value.empty())
{
if (!Replace)
{
size_t Pos=(*Stream_More)[StreamKind][StreamPos].Find(Ztring().From_UTF8(Parameter), Info_Name);
if (Pos!=(size_t)-1)
(*Stream_More)[StreamKind][StreamPos][Pos].clear(); //Empty value --> clear other values
}
}
else
{
Ztring &Target=(*Stream_More)[StreamKind][StreamPos](Ztring().From_UTF8(Parameter), Info_Text);
if (Target.empty() || Replace)
{
Target=Value; //First value
(*Stream_More)[StreamKind][StreamPos](Ztring().From_UTF8(Parameter), Info_Options)=_T("Y NT");
}
else
{
Target+=MediaInfoLib::Config.TagSeparator_Get();
Target+=Value;
}
}
}
//---------------------------------------------------------------------------
void File_ApeTag::Data_Parse()
{
//If footer
if (Element_Code==(int64u)-1)
{
HeaderFooter();
Finish("ApeTag");
return;
}
//Parsing
Ztring Value;
Get_UTF8(Element_Size, Value, "Value"); Element_Info(Value);
//Filling
transform(Key.begin(), Key.end(), Key.begin(), (int(*)(int))toupper); //(int(*)(int)) is a patch for unix
if (Key=="ALBUM") Fill(Stream_General, 0, General_Album, Value);
else if (Key=="ARTIST") Fill(Stream_General, 0, General_Performer, Value);
else if (Key=="AUTHOR") Fill(Stream_General, 0, General_WrittenBy, Value);
else if (Key=="BAND") Fill(Stream_General, 0, General_Performer, Value);
else if (Key=="COMMENT") Fill(Stream_General, 0, General_Comment, Value);
else if (Key=="COMMENTS") Fill(Stream_General, 0, General_Comment, Value);
else if (Key=="COMPOSER") Fill(Stream_General, 0, General_Composer, Value);
else if (Key=="CONTENTGROUP") Fill(Stream_General, 0, General_Genre, Value);
else if (Key=="COPYRIGHT") Fill(Stream_General, 0, General_Copyright, Value);
else if (Key=="DISK")
{
if (Value.find(_T("/"))!=Error)
{
Fill(Stream_General, 0, General_Part_Position_Total, Value.SubString(_T("/"), _T("")));
Fill(Stream_General, 0, General_Part_Position, Value.SubString(_T(""), _T("/")));
}
else
Fill(Stream_General, 0, General_Track_Position, Value);
}
else if (Key=="ENCODEDBY") Fill(Stream_General, 0, General_EncodedBy, Value);
else if (Key=="GENRE") Fill(Stream_General, 0, General_Genre, Value);
else if (Key=="ORIGARTIST") Fill(Stream_General, 0, General_Original_Performer, Value);
else if (Key=="TITLE") Fill(Stream_General, 0, General_Title, Value);
else if (Key=="TRACK")
{
if (Value.find(_T("/"))!=Error)
{
Fill(Stream_General, 0, General_Track_Position_Total, Value.SubString(_T("/"), _T("")));
Fill(Stream_General, 0, General_Track_Position, Value.SubString(_T(""), _T("/")));
}
else
Fill(Stream_General, 0, General_Track_Position, Value);
}
else if (Key=="UNSYNCEDLYRICS") Fill(Stream_General, 0, General_Lyrics, Value);
else if (Key=="WWW") Fill(Stream_General, 0, General_Title_Url, Value);
else if (Key=="YEAR") Fill(Stream_General, 0, General_Recorded_Date, Value);
else if (Key=="CONTENT GROUP DESCRIPTION") Fill(Stream_General, 0, General_Title, Value);
else if (Key=="ORIGINAL ALBUM/MOVIE/SHOW TITLE") Fill(Stream_General, 0, General_Original_Album, Value);
else if (Key=="ORIGINAL ARTIST(S)/PERFORMER(S)") Fill(Stream_General, 0, General_Original_Performer, Value);
else if (Key=="MP3GAIN_MINMAX") Fill(Stream_Audio, 0, "MP3Gain, Min/Max", Value);
else if (Key=="MP3GAIN_UNDO") Fill(Stream_Audio, 0, "MP3Gain, Undo", Value);
else if (Key=="REPLAYGAIN_TRACK_GAIN") Fill(Stream_Audio, 0, Audio_ReplayGain_Gain, Value.To_float64(), 2, true);
else if (Key=="REPLAYGAIN_TRACK_PEAK") Fill(Stream_Audio, 0, Audio_ReplayGain_Peak, Value.To_float64(), 6, true);
else Fill(Stream_General, 0, Key.c_str(), Value);
}
